diff --git a/CMakeLists.txt b/CMakeLists.txt
index f9740a90..927c1ec2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,74 +1,73 @@
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 # set the project name and version
-project(phasicFlow VERSION 0.1 )
+project(phasicFlow VERSION 1.0 )
 
 set(CMAKE_CXX_STANDARD 17 CACHE STRING "" FORCE)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_INSTALL_PREFIX ${phasicFlow_SOURCE_DIR} CACHE PATH "Install path of phasicFlow" FORCE)
 set(CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
+set(BUILD_SHARED_LIBS ON CACHE BOOL "Build using shared libraries" FORCE)
+mark_as_advanced(FORCE var BUILD_SHARED_LIBS)
 
 message(STATUS ${CMAKE_INSTALL_PREFIX})
 
-mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_LAMBDA)
-mark_as_advanced(FORCE var Kokkos_ENABLE_OPENMP)
-mark_as_advanced(FORCE var Kokkos_ENABLE_SERIAL)
-mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_LAMBDA)
-mark_as_advanced(FORCE var BUILD_SHARED_LIBS)
+include(cmake/globals.cmake)
 
-option(USE_STD_PARALLEL_ALG "Use TTB std parallel algorithms" ON)
+#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} ${phasicFlow_BINARY_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)
 option(pFlow_Build_Cuda   "Build phasicFlow and backends for Cuda execution" OFF)
-option(pFlow_Build_Double "Build phasicFlow with double precision variables" ON)
+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)
 
-set(BUILD_SHARED_LIBS ON CACHE BOOL "Build using shared libraries" FORCE)
 
 if(pFlow_Build_Serial)
 	set(Kokkos_ENABLE_SERIAL ON CACHE BOOL "Serial execution" FORCE) 
 	set(Kokkos_ENABLE_OPENMP OFF 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_ENABLE_CUDA_CONSTEXPR OFF CACHE BOOL "Enable constexpr on cuda code" FORCE)
 elseif(pFlow_Build_OpenMP )
 	set(Kokkos_ENABLE_SERIAL ON CACHE BOOL "Serial execution" FORCE) 
 	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_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) 
 	set(Kokkos_ENABLE_OPENMP OFF CACHE BOOL "OpenMP execution" FORCE)
 	set(Kokkos_ENABLE_CUDA ON CACHE BOOL "Cuda execution" FORCE)
 	set(Kokkos_ENABLE_CUDA_LAMBDA ON CACHE BOOL "Cuda execution" FORCE)
+	set(Kokkos_ENABLE_CUDA_CONSTEXPR ON CACHE BOOL "Enable constexpr on cuda code" FORCE)
 endif()
 
-
-
-include(cmake/globals.cmake)
-message(STATUS "Valid file extensions are ${validFiles}")
+if(pFlow_Build_MPI)
+	find_package(MPI REQUIRED)
+endif()
 
 include(cmake/makeLibraryGlobals.cmake)
 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}")
 
-#main subdirectories of the code 
-set(Kokkos_Source_DIR)
-
-if(DEFINED ENV{Kokkos_DIR})
-   set(Kokkos_Source_DIR $ENV{Kokkos_DIR})
-#  add_subdirectory($ENV{Kokkos_DIR} ${phasicFlow_BINARY_DIR}/kokkos)
-#  message(STATUS "Kokkos directory is $ENV{Kokkos_DIR}")
-else()
-#  add_subdirectory($ENV{HOME}/Kokkos/kokkos ${phasicFlow_BINARY_DIR}/kokkos)
-  set(Kokkos_Source_DIR $ENV{HOME}/Kokkos/kokkos)
-endif()
-
-message(STATUS "Kokkos source directory is ${Kokkos_Source_DIR}")
-add_subdirectory(${Kokkos_Source_DIR} ${phasicFlow_BINARY_DIR}/kokkos)
 
 add_subdirectory(src)
 
@@ -76,13 +75,11 @@ add_subdirectory(solvers)
 
 add_subdirectory(utilities)
 
-add_subdirectory(DEMSystems)
-#add_subdirectory(testIO)
-
+#add_subdirectory(DEMSystems)
+add_subdirectory(testIO)
 
 install(FILES "${PROJECT_BINARY_DIR}/phasicFlowConfig.H"
-  DESTINATION include
-)
+  DESTINATION include)
 
 include(InstallRequiredSystemLibraries)
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
diff --git a/cmake/bashrc b/cmake/bashrc
index 50f8fa60..32c92d87 100644
--- a/cmake/bashrc
+++ b/cmake/bashrc
@@ -1,5 +1,5 @@
 
-export pFlow_PROJECT_VERSION=v0.1
+export pFlow_PROJECT_VERSION=v-1.0
 
 export pFlow_PROJECT=phasicFlow
 
@@ -20,6 +20,8 @@ export pFlow_SRC_DIR="$pFlow_PROJECT_DIR/src"
 
 export Kokkos_DIR="$kokkosDir"
 
+export Zoltan_DIR="$projectDir/Zoltan"
+
 # Cleanup variables (done as final statement for a clean exit code)
 unset projectDir
 
@@ -27,5 +29,7 @@ export PATH="$pFlow_BIN_DIR:$PATH"
 
 export LD_LIBRARY_PATH="$pFlow_LIB_DIR:$LD_LIBRARY_PATH"
 
+export LD_LIBRARY_PATH="$Zoltan_DIR/lib:$LD_LIBRARY_PATH"
+
 
 #------------------------------------------------------------------------------
diff --git a/cmake/globals.cmake b/cmake/globals.cmake
index b3158dd8..34c075b4 100644
--- a/cmake/globals.cmake
+++ b/cmake/globals.cmake
@@ -2,3 +2,52 @@
 set(validFiles)
 list(APPEND validFiles *.C *.cpp *.cxx *.c *.cu *.H *.hpp *.hxx *.h *.cuh)
 
+macro(Kokkos_cmake_settings)
+
+#mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_LAMBDA)
+mark_as_advanced(FORCE var Kokkos_CXX_STANDARD)
+#mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_CONSTEXPR)
+mark_as_advanced(FORCE var Kokkos_ENABLE_OPENMP)
+mark_as_advanced(FORCE var Kokkos_ENABLE_SERIAL)
+mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA)
+mark_as_advanced(FORCE var Kokkos_ENABLE_HIP)
+mark_as_advanced(FORCE var Kokkos_ENABLE_AGGRESSIVE_VECTORIZATION)
+mark_as_advanced(FORCE var Kokkos_ENABLE_BENCHMARKS)
+mark_as_advanced(FORCE var Kokkos_ENABLE_COMPILE_AS_CMAKE_LANGUAGE)
+mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_LDG_INTRINSIC)
+mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_RELOCATABLE_DEVICE_CODE)
+mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_UVM)
+mark_as_advanced(FORCE var Kokkos_ENABLE_DEPRECATED_CODE_3)
+mark_as_advanced(FORCE var Kokkos_ENABLE_DEPRECATED_CODE_4)
+mark_as_advanced(FORCE var Kokkos_ENABLE_DEPRECATION_WARNINGS)
+mark_as_advanced(FORCE var Kokkos_ENABLE_DESUL_ATOMICS_EXTERNAL)
+mark_as_advanced(FORCE var Kokkos_ENABLE_EXAMPLES)
+mark_as_advanced(FORCE var Kokkos_ENABLE_HEADER_SELF_CONTAINMENT_TESTS)
+mark_as_advanced(FORCE var Kokkos_ENABLE_HIP_MULTIPLE_KERNEL_INSTANTIATIONS)
+mark_as_advanced(FORCE var Kokkos_ENABLE_HIP_RELOCATABLE_DEVICE_CODE)
+mark_as_advanced(FORCE var Kokkos_ENABLE_HPX)
+mark_as_advanced(FORCE var Kokkos_ENABLE_HWLOC)
+mark_as_advanced(FORCE var Kokkos_ENABLE_IMPL_CUDA_MALLOC_ASYNC)
+mark_as_advanced(FORCE var Kokkos_ENABLE_IMPL_HPX_ASYNC_DISPATCH)
+mark_as_advanced(FORCE var Kokkos_ENABLE_LARGE_MEM_TESTS)
+mark_as_advanced(FORCE var Kokkos_ENABLE_DEBUG_DUALVIEW_MODIFY_CHECK)
+mark_as_advanced(FORCE var Kokkos_ENABLE_LIBQUADMATH)
+mark_as_advanced(FORCE var Kokkos_ENABLE_LIBRT)
+mark_as_advanced(FORCE var Kokkos_ENABLE_MEMKIND)
+mark_as_advanced(FORCE var Kokkos_ENABLE_ONEDPL)
+mark_as_advanced(FORCE var Kokkos_ENABLE_OPENACC)
+mark_as_advanced(FORCE var Kokkos_ENABLE_OPENMPTARGET)
+mark_as_advanced(FORCE var Kokkos_ENABLE_ROCM)
+mark_as_advanced(FORCE var Kokkos_ENABLE_SYCL)
+mark_as_advanced(FORCE var Kokkos_ENABLE_TESTS)
+mark_as_advanced(FORCE var Kokkos_ENABLE_THREADS)
+mark_as_advanced(FORCE var Kokkos_ENABLE_TUNING)
+mark_as_advanced(FORCE var Kokkos_ENABLE_UNSUPPORTED_ARCHS)
+mark_as_advanced(FORCE var Kokkos_HPX_DIR)
+mark_as_advanced(FORCE var Kokkos_HWLOC_DIR)
+mark_as_advanced(FORCE var Kokkos_MEMKIND_DIR)
+mark_as_advanced(FORCE var Kokkos_ROCM_DIR)
+mark_as_advanced(FORCE var Kokkos_THREADS_DIR)
+
+endmacro()
+
diff --git a/cmake/makeExecutableGlobals.cmake b/cmake/makeExecutableGlobals.cmake
index 24eb6e0f..06c48e14 100644
--- a/cmake/makeExecutableGlobals.cmake
+++ b/cmake/makeExecutableGlobals.cmake
@@ -31,7 +31,7 @@ target_include_directories(${target_name}
 
 message(STATUS "\nCreating make file for executable ${target_name}")
 message(STATUS "  ${target_name} link libraries are: ${${target_link_libs}}")
-message(STATUS "  ${target_name} source files are: ${source_files}")
+message(STATUS "  ${target_name} source files are: ${${source_files}}")
 message(STATUS "  ${target_name} include dirs are: ${includeDirs}\n")
 
 
diff --git a/cmake/makeLibraryGlobals.cmake b/cmake/makeLibraryGlobals.cmake
index b5e30156..4197983b 100644
--- a/cmake/makeLibraryGlobals.cmake
+++ b/cmake/makeLibraryGlobals.cmake
@@ -42,7 +42,7 @@ target_include_directories(${target_name}
 message(STATUS "\nCreating make file for library ${target_name}")
 message(STATUS "  ${target_name} link libraries are: ${${target_link_libs}}")
 message(STATUS "  ${target_name} source files are: ${source_files}")
-message(STATUS "  ${target_name} include dirs are: ${includeDirs}\n")
+message(STATUS "  ${target_name} include dirs are: ${includeDirs}\n \n")
 
 install(TARGETS ${target_name} DESTINATION lib)
 install(FILES ${includeFiles}  DESTINATION include/${target_name})
diff --git a/phasicFlowConfig.H.in b/phasicFlowConfig.H.in
index 919867e4..0f1b3224 100644
--- a/phasicFlowConfig.H.in
+++ b/phasicFlowConfig.H.in
@@ -5,5 +5,6 @@
 #cmakedefine pFlow_Build_Serial
 #cmakedefine pFlow_Build_OpenMP
 #cmakedefine pFlow_Build_Cuda
-#cmakedefine USE_STD_PARALLEL_ALG
-#cmakedefine pFlow_Build_Double
\ No newline at end of file
+#cmakedefine pFlow_STD_Parallel_Alg
+#cmakedefine pFlow_Build_Double
+#cmakedefine pFlow_Build_MPI
diff --git a/solvers/CMakeLists.txt b/solvers/CMakeLists.txt
index 45bc40aa..7db5fd36 100644
--- a/solvers/CMakeLists.txt
+++ b/solvers/CMakeLists.txt
@@ -1,6 +1,6 @@
 
 
-#add_subdirectory(iterateSphereParticles)
+add_subdirectory(iterateSphereParticles)
 
 add_subdirectory(iterateGeometry)
 
diff --git a/solvers/iterateGeometry/iterateGeometry.cpp b/solvers/iterateGeometry/iterateGeometry.cpp
index a43212c1..d541a5bf 100755
--- a/solvers/iterateGeometry/iterateGeometry.cpp
+++ b/solvers/iterateGeometry/iterateGeometry.cpp
@@ -28,13 +28,14 @@ Licence:
  * (https://github.com/PhasicFlow/phasicFlow/tree/main/tutorials/iterateGeometry)
  * folder.
  */
- 
-#include "systemControl.hpp"
-#include "geometryMotion.hpp"
-#include "commandLine.hpp"
-#include "readControlDict.hpp"
 
-using pFlow::commandLine;
+#include "vocabs.hpp"
+#include "systemControl.hpp"
+#include "geometry.hpp"
+#include "commandLine.hpp"
+//#include "readControlDict.hpp"
+
+using namespace pFlow;
 
 int main( int argc, char* argv[] )
 {
@@ -54,6 +55,8 @@ commandLine cmds(
    
 
 // this should be palced in each main 
+processors::initProcessors(argc, argv);
+initialize_pFlowProcessors();
 #include "initialize_Control.hpp"
 	
 	#include "setProperty.hpp"
@@ -68,6 +71,7 @@ commandLine cmds(
 
 // this should be palced in each main 
 #include "finalize.hpp"
+processors::finalizeProcessors();
 
 }
 
diff --git a/solvers/iterateSphereParticles/CMakeLists.txt b/solvers/iterateSphereParticles/CMakeLists.txt
new file mode 100644
index 00000000..59700110
--- /dev/null
+++ b/solvers/iterateSphereParticles/CMakeLists.txt
@@ -0,0 +1,7 @@
+
+set(source_files
+iterateSphereParticles.cpp
+)
+set(link_lib  Particles)
+
+pFlow_make_executable_install(iterateSphereParticles source_files link_lib)
diff --git a/solvers/iterateSphereParticles/createDEMComponents.hpp b/solvers/iterateSphereParticles/createDEMComponents.hpp
new file mode 100755
index 00000000..85cb798a
--- /dev/null
+++ b/solvers/iterateSphereParticles/createDEMComponents.hpp
@@ -0,0 +1,25 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+//
+REPORT(0)<<"\nReading sphere particles . . ."<<END_REPORT;
+sphereParticles sphParticles(Control, proprties);
+
+WARNING<<"Particle insertion has not been set yet!"<<END_WARNING;
diff --git a/solvers/iterateSphereParticles/iterateSphereParticles.cpp b/solvers/iterateSphereParticles/iterateSphereParticles.cpp
new file mode 100755
index 00000000..fee9c6a5
--- /dev/null
+++ b/solvers/iterateSphereParticles/iterateSphereParticles.cpp
@@ -0,0 +1,89 @@
+
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+/** 
+ * \file sphereGranFlow.cpp
+ * \brief sphereGranFlow solver 
+ *
+ * This solver simulate granular flow of cohesion-less, spherical particles. 
+ * Particle insertion can be activated in the solver to gradually insert 
+ * particles into the simulation. Geometry can be defined generally with 
+ * built-in features of the code or through ASCII stl files or a combination
+ * of both. For more information refer to [tutorials/sphereGranFlow/]
+ * (https://github.com/PhasicFlow/phasicFlow/tree/main/tutorials/sphereGranFlow) folder.
+ */
+
+#include "vocabs.hpp"
+#include "property.hpp"
+#include "sphereParticles.hpp"
+#include "systemControl.hpp"
+#include "commandLine.hpp"
+
+using namespace pFlow;
+
+/**
+ * DEM solver for simulating granular flow of cohesion-less particles.
+ *
+ * In the root case directory just simply enter the following command to 
+ * run the simulation. For command line options use flag -h. 
+ */
+int main( int argc, char* argv[])
+{
+
+commandLine cmds(
+		"sphereGranFlow",
+		"DEM solver for non-cohesive spherical particles with particle insertion "
+		"mechanism and moving geometry");
+
+bool isCoupling = false;
+
+if(!cmds.parse(argc, argv)) return 0;
+
+// this should be palced in each main 
+processors::initProcessors(argc, argv);
+initialize_pFlowProcessors();
+#include "initialize_Control.hpp"
+	
+	#include "setProperty.hpp"
+
+	#include "createDEMComponents.hpp"
+	
+	REPORT(0)<<"\nStart of time loop . . .\n"<<END_REPORT;
+
+	do 
+	{
+		
+		sphParticles.beforeIteration();
+	
+		sphParticles.iterate();
+
+		sphParticles.afterIteration();		
+
+	}while(Control++);
+
+	REPORT(0)<<"\nEnd of time loop.\n"<<END_REPORT;
+
+// this should be palced in each main 
+#include "finalize.hpp"
+processors::finalizeProcessors();
+
+
+}	
+
diff --git a/solvers/sphereGranFlow/createDEMComponents.hpp b/solvers/sphereGranFlow/createDEMComponents.hpp
index 92cf1f53..6fcbde29 100755
--- a/solvers/sphereGranFlow/createDEMComponents.hpp
+++ b/solvers/sphereGranFlow/createDEMComponents.hpp
@@ -19,11 +19,11 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 //
-REPORT(0)<<"\nReading sphere particles . . ."<<endREPORT;
+REPORT(0)<<"\nReading sphere particles . . ."<<END_REPORT;
 sphereParticles sphParticles(Control, proprties);
 
 //
-REPORT(0)<<"\nCreating particle insertion object . . ."<<endREPORT;
+REPORT(0)<<"\nCreating particle insertion object . . ."<<END_REPORT;
 /*auto& sphInsertion = 
 	Control.caseSetup().emplaceObject<sphereInsertion>(
 		objectFile(
@@ -36,12 +36,12 @@ REPORT(0)<<"\nCreating particle insertion object . . ."<<endREPORT;
 		sphParticles.shapes()
 	);*/
 
-auto sphInsertion =  sphereInsertion(
+/*auto sphInsertion =  sphereInsertion(
 	Control.caseSetup().path()+insertionFile__, 
 	sphParticles, 
-	sphParticles.shapes());
+	sphParticles.shapes());*/
 
-REPORT(0)<<"\nCreating interaction model for sphere-sphere contact and sphere-wall contact . . ."<<endREPORT;
+REPORT(0)<<"\nCreating interaction model for sphere-sphere contact and sphere-wall contact . . ."<<END_REPORT;
 auto interactionPtr = interaction::create(
 	Control,
 	sphParticles,
diff --git a/solvers/sphereGranFlow/sphereGranFlow.cpp b/solvers/sphereGranFlow/sphereGranFlow.cpp
index da435776..c36bc987 100755
--- a/solvers/sphereGranFlow/sphereGranFlow.cpp
+++ b/solvers/sphereGranFlow/sphereGranFlow.cpp
@@ -30,30 +30,22 @@ Licence:
  * (https://github.com/PhasicFlow/phasicFlow/tree/main/tutorials/sphereGranFlow) folder.
  */
 
+#include "vocabs.hpp"
+#include "phasicFlowKokkos.hpp"
+#include "systemControl.hpp"
+#include "commandLine.hpp"
 #include "property.hpp"
 #include "geometry.hpp"
 #include "sphereParticles.hpp"
-#include "Insertions.hpp"
-#include "systemControl.hpp"
-#include "contactSearch.hpp"
-#include "sphereInteraction.hpp"
-#include "commandLine.hpp"
-#include "readControlDict.hpp"
-
-using pFlow::output;
-using pFlow::endl;
-using pFlow::property;
-using pFlow::sphereParticles;
-using pFlow::objectFile;
-using pFlow::sphereInsertion;
-using pFlow::insertionFile__;
-using pFlow::interactionFile__;
-using pFlow::contactSearch;
-using pFlow::interaction;
-using pFlow::commandLine;
+#include "interaction.hpp"
+//#include "Insertions.hpp"
 
 
 
+//#include "readControlDict.hpp"
+
+using namespace pFlow;
+
 /**
  * DEM solver for simulating granular flow of cohesion-less particles.
  *
@@ -73,52 +65,58 @@ bool isCoupling = false;
 if(!cmds.parse(argc, argv)) return 0;
 
 // this should be palced in each main 
+processors::initProcessors(argc, argv);
+initialize_pFlowProcessors();
 #include "initialize_Control.hpp"
-	
+	 
 	#include "setProperty.hpp"
 	#include "setSurfaceGeometry.hpp"
 	
 
 	#include "createDEMComponents.hpp"
 	
-	REPORT(0)<<"\nStart of time loop . . .\n"<<endREPORT;
+	REPORT(0)<<"\nStart of time loop . . .\n"<<END_REPORT;
 
 	do 
 	{
 		
-		if(! sphInsertion.insertParticles( 
+		/*if(! sphInsertion.insertParticles( 
 			Control.time().currentTime(),
 			Control.time().dt()	) )
 		{
 			fatalError<<
 			"particle insertion failed in sphereDFlow solver.\n";
 			return 1;
-		}
-
+		}*/
+		
+		// set force to zero
 		surfGeometry.beforeIteration();
-		
-		sphInteraction.beforeIteration();
 
+		// set force to zero, predict, particle deletion and etc. 
 		sphParticles.beforeIteration();
+
+		sphInteraction.beforeIteration();
 		
+		sphInteraction.iterate();	
 		
-		sphInteraction.iterate();
+		surfGeometry.iterate();
 
 		sphParticles.iterate();
 
-		surfGeometry.iterate();
+		sphInteraction.afterIteration();
+
+		surfGeometry.afterIteration();
 
 		sphParticles.afterIteration();
-		
-		surfGeometry.afterIteration();
-		
+				
 
 	}while(Control++);
 
-	REPORT(0)<<"\nEnd of time loop.\n"<<endREPORT;
+	REPORT(0)<<"\nEnd of time loop.\n"<<END_REPORT;
 
 // this should be palced in each main 
 #include "finalize.hpp"
+processors::finalizeProcessors();
 
 
 }	
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b6a61171..7b403304 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -7,9 +7,9 @@ add_subdirectory(Property)
 
 add_subdirectory(Particles)
 
+add_subdirectory(Geometry)
+
 add_subdirectory(Interaction)
 
 add_subdirectory(MotionModel)
 
-add_subdirectory(Geometry)
-
diff --git a/src/Geometry/geometry/geometry.cpp b/src/Geometry/geometry/geometry.cpp
index 4d7edc04..00855156 100644
--- a/src/Geometry/geometry/geometry.cpp
+++ b/src/Geometry/geometry/geometry.cpp
@@ -19,33 +19,41 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "geometry.hpp"
+#include "systemControl.hpp"
 #include "vocabs.hpp"
 
 
-bool pFlow::geometry::findPropertyId()
+bool pFlow::geometry::createPropertyId()
 {
-
-	int8Vector propId(0, surface().capacity(),RESERVE());
-	propId.clear();
-
-	uint32 pId;
-	ForAll(matI, materialName_)
+	if(materialName_.size() != numSurfaces() )
 	{
+		fatalErrorInFunction<<
+		"number of subSurface and material names do not match"<<endl;
+		return false;
+	}
+
+	uint32Vector propId(
+		"propId", 
+		capacity(), 
+		size(),
+		RESERVE());
+
+	ForAll(i, materialName_)
+	{
+		uint32 pIdx =0;
 		
-		if( !wallProperty_.nameToIndex( materialName_[matI], pId ) )
+		if( !wallProperty_.nameToIndex(materialName_[i], pIdx) )
 		{
-		 	fatalErrorInFunction<<
-		 	"material name for the geometry is invalid: "<< materialName_[matI]<<endl;
-		 	return false;
+			fatalErrorInFunction<<
+			"Property/material name is invalid "<<materialName_[i]<<
+			". A list of valid names are \n"<< wallProperty_.materials()<<endl;
+			return false;
 		}
-
-		int32 surfSize = surface().surfNumTriangles(matI);
-
-		for(int32 i=0; i<surfSize; i++)
-		{
-			propId.push_back(pId);
-		}
-	}	
+		
+		auto triRange = subSurfaceRange(i);
+		propId.fill(triRange.start(), triRange.end(), pIdx);
+		
+	}
 
 	propertyId_.assign(propId);
 
@@ -53,83 +61,361 @@ bool pFlow::geometry::findPropertyId()
 
 }
 
+void pFlow::geometry::zeroForce()
+{
+	contactForceWall_.fill(zero3);
+}
+
 pFlow::geometry::geometry
 (
 	systemControl& control,
 	const property& prop
 )
 :
-	demGeometry(control),
+	multiTriSurface
+	(
+		objectFile
+		(
+			triSurfaceFile__,
+			"",
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_ALWAYS
+		),
+		&control.geometry()
+	),
+	demComponent
+	(
+		"geometry",
+		control
+	),
 	wallProperty_(prop),
-	geometryRepository_(control.geometry()),
-	triSurface_(
-		control.geometry().emplaceObject<multiTriSurface>(
-			objectFile(
-				"triSurface",
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS
-				)
-			)
+	propertyId_
+	(
+		objectFile
+		(
+			"propertyId",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_NEVER
 		),
-	motionComponentName_(
-		control.geometry().emplaceObject<wordField>(
-			objectFile(
-				"motionComponentName",
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS	
-				),
-			"motionNamesList"
-			)
+		*this,
+		0u
+	),
+	contactForceWall_
+	(
+		objectFile
+		(
+			"contactForcWall",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_NEVER
 		),
-	materialName_(
-		control.geometry().emplaceObject<wordField>(
-			objectFile(
-				"materialName",
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS
-				),
-			"materialNamesList"
-			)
+		*this,
+		zero3
+	),
+	normalStressWall_
+	(
+		objectFile
+		(
+			"normalStressWall",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_NEVER
 		),
-	propertyId_(
-		control.geometry().emplaceObject<int8TriSurfaceField_D>(
-			objectFile(
-				"propertyId",
-				"",
-				objectFile::READ_NEVER,
-				objectFile::WRITE_NEVER),
-			surface(),
-			0 ) ),
-	contactForceWall_(
-		control.geometry().emplaceObject<realx3TriSurfaceField_D>(
-			objectFile(
-				"contactForceWall",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS),
-			surface(),
-			zero3) ),
-	stressWall_(
-		control.geometry().emplaceObject<realx3TriSurfaceField_D>(
-			objectFile(
-				"stressWall",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS),
-			surface(),
-			zero3) )
+		*this,
+		zero3
+	),
+	shearStressWall_
+	(
+		objectFile
+		(
+			"shearStressWall",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_NEVER
+		),
+		*this,
+		zero3
+	)
 {
 
-	if(!findPropertyId())
+	readWholeObject_ = false;
+	if( !IOobject::readObject() )
+    {
+        fatalErrorInFunction<<
+        "Error in reading from file "<<IOobject::path()<<endl;
+        fatalExit;
+    }
+	readWholeObject_ = true;
+
+	if( this->numSurfaces() != motionComponentName_.size() )
+	{
+		fatalErrorInFunction<<
+		"Number of surfaces is not equal to number of motion component names"<<endl;
+		fatalExit;
+	}
+	
+	if(!createPropertyId())
 	{
 		fatalExit;
 	}
 }
 
 pFlow::geometry::geometry
+(
+	systemControl &control, 
+	const property &prop, 
+	multiTriSurface &surf, 
+	const wordVector &motionCompName, 
+	const wordVector &materialName,
+	const dictionary& motionDict
+)
+:
+	multiTriSurface
+	(
+		objectFile
+		(
+			triSurfaceFile__,
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_ALWAYS
+		),
+		&control.geometry(),
+		surf
+	),
+	demComponent
+	(
+		"geometry",
+		control
+	),
+	wallProperty_
+	(
+		prop
+	),
+	propertyId_
+	(
+		objectFile
+		(
+			"propertyId",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_NEVER
+		),
+		*this,
+		0u
+	),
+	contactForceWall_
+	(
+		objectFile
+		(
+			"contactForcWall",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_NEVER
+		),
+		*this,
+		zero3
+	),
+	normalStressWall_
+	(
+		objectFile
+		(
+			"normalStressWall",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_NEVER
+		),
+		*this,
+		zero3
+	),
+	shearStressWall_
+	(
+		objectFile
+		(
+			"shearStressWall",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_NEVER
+		),
+		*this,
+		zero3
+	)
+	
+{
+	motionComponentName_.assign(motionCompName);
+	materialName_.assign(materialName);
+
+
+	if( this->numSurfaces() != motionComponentName_.size() )
+	{
+		fatalErrorInFunction<<
+		"Number of surfaces is not equal to number of motion component names"<<endl;
+		fatalExit;
+	}
+
+	if(!createPropertyId())
+	{
+		fatalExit;
+	}
+}
+
+bool pFlow::geometry::beforeIteration()
+{
+	zeroForce();
+    return true;
+}
+
+bool pFlow::geometry::iterate()
+{
+    return true;
+}
+
+bool pFlow::geometry::afterIteration()
+{
+	auto numTris = size();
+	auto& normalsD = normals().deviceViewAll();
+	auto& areaD = area().deviceViewAll();
+	auto& cForceD = contactForceWall_.deviceViewAll();
+	auto& sStressD = shearStressWall_.deviceViewAll();
+	auto& nStressD = normalStressWall_.deviceViewAll();
+
+	Kokkos::parallel_for(
+		"pFlow::geometry::afterIteration",
+		deviceRPolicyStatic(0, numTris),
+		LAMBDA_HD(uint32 i)
+		{	
+			realx3 n = normalsD[i];
+			real A = max(areaD[i],smallValue);
+			realx3 nF = dot(cForceD[i],n)*n;
+			realx3 sF = cForceD[i] - nF;
+			nStressD[i] = nF/A;
+			sStressD[i] = sF/A;
+		});
+	Kokkos::fence();
+    
+	return true;
+}
+
+bool pFlow::geometry::read(iIstream &is, const IOPattern &iop)
+{
+	motionComponentName_.read(is, iop);
+	
+	materialName_.read(is, iop);
+	
+	if( readWholeObject_ )
+	{
+		return multiTriSurface::read(is, iop);
+	}
+
+    return true;
+}
+
+bool pFlow::geometry::write(iOstream &os, const IOPattern &iop) const
+{
+    
+	if( !motionComponentName_.write(os, iop) )
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+	if( !materialName_.write(os,iop))
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+	
+	return multiTriSurface::write(os,iop);
+}
+
+
+pFlow::uniquePtr<pFlow::geometry> 
+	pFlow::geometry::create
+(
+	systemControl& control,
+	const property& prop
+)
+{
+	
+	//
+	fileDictionary dict( motionModelFile__, control.time().geometry().path());
+
+	word model = dict.getVal<word>("motionModel");
+	
+	auto geomModel = angleBracketsNames("geometry", model);
+
+	REPORT(1)<< "Selecting geometry model . . ."<<END_REPORT;
+	if( systemControlvCtorSelector_.search(geomModel) )
+	{
+		auto objPtr = systemControlvCtorSelector_[geomModel] (control, prop);
+		REPORT(2)<<"Model "<< Green_Text(geomModel)<<" is created.\n"<<END_REPORT;
+		return objPtr;
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< Yellow_Text(geomModel) << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			systemControlvCtorSelector_
+		);
+		fatalExit;
+	}
+
+	return nullptr;
+}
+
+pFlow::uniquePtr<pFlow::geometry> 
+	pFlow::geometry::create
+	(
+		systemControl& control, 
+		const property& prop,
+		multiTriSurface& surf,
+		const wordVector& motionCompName,
+		const wordVector& materialName,
+		const dictionary& motionDic
+	)
+{
+
+	word model = motionDic.getVal<word>("motionModel");
+
+	auto geomModel = angleBracketsNames("geometry", model);
+
+	REPORT(1)<< "Selecting geometry model . . ."<<END_REPORT;
+
+	if( dictionaryvCtorSelector_.search(geomModel) )
+	{
+		auto objPtr = dictionaryvCtorSelector_[geomModel] 
+			(
+				control,
+				prop, 
+				surf,
+				motionCompName,
+				materialName,
+				motionDic
+			);
+		REPORT(2)<<"Model "<< Green_Text(geomModel)<<" is created.\n"<<END_REPORT;
+		return objPtr;
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< Yellow_Text(geomModel) << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			dictionaryvCtorSelector_
+		);
+		fatalExit;
+	}
+	return nullptr;
+}
+
+
+
+
+/*pFlow::geometry::geometry
 (
 	systemControl& control,
 	const property& prop,
@@ -224,52 +510,7 @@ pFlow::geometry::geometry
 {}
 
 
-pFlow::uniquePtr<pFlow::geometry> 
-	pFlow::geometry::create
-(
-	systemControl& control,
-	const property& prop
-)
-{
-	//motionModelFile__
-	auto motionDictPtr = IOobject::make<dictionary>
-	(
-		objectFile
-		(
-			motionModelFile__,
-			control.geometry().path(),
-			objectFile::READ_ALWAYS,
-			objectFile::WRITE_NEVER
-		),
-		motionModelFile__,
-		true
-	);
 
-	word model = motionDictPtr().getObject<dictionary>().getVal<word>("motionModel");
-	
-	auto geomModel = angleBracketsNames("geometry", model);
-
-	REPORT(1)<< "Selecting geometry model . . ."<<endREPORT;
-	if( systemControlvCtorSelector_.search(geomModel) )
-	{
-		auto objPtr = systemControlvCtorSelector_[geomModel] (control, prop);
-		REPORT(2)<<"Model "<< greenText(geomModel)<<" is created.\n"<<endREPORT;
-		return objPtr;
-	}
-	else
-	{
-		printKeys
-		( 
-			fatalError << "Ctor Selector "<< yellowText(geomModel) << " dose not exist. \n"
-			<<"Avaiable ones are: \n\n"
-			,
-			systemControlvCtorSelector_
-		);
-		fatalExit;
-	}
-
-	return nullptr;
-}
 
 bool pFlow::geometry::beforeIteration()
 { 
@@ -296,48 +537,4 @@ bool pFlow::geometry::afterIteration()
 	Kokkos::fence();
 	return true;
 	
-}
-
-pFlow::uniquePtr<pFlow::geometry> 
-	pFlow::geometry::create(
-			systemControl& control,
-			const property& prop,
-			const dictionary& dict,
-			const multiTriSurface& triSurface,
-			const wordVector& motionCompName,
-			const wordVector& propName)
-{
-
-	word model = dict.getVal<word>("motionModel");
-
-	auto geomModel = angleBracketsNames("geometry", model);
-
-	REPORT(1)<< "Selecting geometry model . . ."<<endREPORT;
-
-	if( dictionaryvCtorSelector_.search(geomModel) )
-	{
-		auto objPtr = dictionaryvCtorSelector_[geomModel] 
-			(
-				control,
-				prop, 
-				dict,
-				triSurface,
-				motionCompName,
-				propName
-			);
-		REPORT(2)<<"Model "<< greenText(geomModel)<<" is created.\n"<<endREPORT;
-		return objPtr;
-	}
-	else
-	{
-		printKeys
-		( 
-			fatalError << "Ctor Selector "<< yellowText(geomModel) << " dose not exist. \n"
-			<<"Avaiable ones are: \n\n"
-			,
-			dictionaryvCtorSelector_
-		);
-		fatalExit;
-	}
-	return nullptr;
-}
\ No newline at end of file
+}*/
diff --git a/src/Geometry/geometry/geometry.hpp b/src/Geometry/geometry/geometry.hpp
index a8296700..c336cbf2 100644
--- a/src/Geometry/geometry/geometry.hpp
+++ b/src/Geometry/geometry/geometry.hpp
@@ -23,13 +23,14 @@ Licence:
 
 
 #include "virtualConstructor.hpp"
-#include "demGeometry.hpp"
+#include "demComponent.hpp"
 #include "property.hpp"
-#include "Fields.hpp"
-#include "Vectors.hpp"
 #include "multiTriSurface.hpp"
 #include "triSurfaceFields.hpp"
-#include "dictionary.hpp"
+//#include "Fields.hpp"
+//#include "Vectors.hpp"
+
+
 
 namespace pFlow
 {
@@ -42,49 +43,50 @@ namespace pFlow
  */
 class geometry
 :
-	public demGeometry
+	public multiTriSurface,
+	public demComponent
 {
-protected:
+private:
 
 	// - Protected members 
 
 		/// Const reference to physical property of materials 
 		const property& 	wallProperty_;
 
-		/// Repository to store geometry data at each simulation moment
-		repository&  		geometryRepository_;
-
-		/// All triangles in the set of wall surfaces 
-		multiTriSurface&  	triSurface_;
-
 		/// The name of motion component of each wall surface 
-		wordField& 			motionComponentName_;
+		wordField_H 		motionComponentName_{
+								"motionComponentName",	
+								"motionComponentName"};
 
 		/// Material name of each wall surface  
-		wordField&   		materialName_;
+		wordField_H   		materialName_{
+								"materialName",
+								"materialName"};
 		
 		/// Property id of each triangle in the set of wall surfaces
-		int8TriSurfaceField_D& 		propertyId_;
+		uint32TriSurfaceField_D 		propertyId_;
 
 		/// Contact force on each triangle in the set of wall surfaces
-		realx3TriSurfaceField_D& 	contactForceWall_;
+		realx3TriSurfaceField_D 		contactForceWall_;
 
-		/// Stress on ech triangle in the set of wall surfaces 
-		realx3TriSurfaceField_D&    stressWall_;
+		/// Stress on each triangle in the set of wall surfaces 
+		realx3TriSurfaceField_D 		normalStressWall_;
+
+		/// Stress on each triangle in the set of wall surfaces 
+		realx3TriSurfaceField_D 		shearStressWall_;
+
+
+		bool readWholeObject_ = true; 			
 
 	// - Protected member functions
 	
 		/// Find property id of each triangle based on the supplied material name
 		/// and the surface wall that the triangle belongs to. 
-		bool findPropertyId();
+		bool createPropertyId();
 
 		/// Initialize contact force to zero 
-		void zeroForce()
-		{
-			contactForceWall_.fill(zero3);
-		}
-
-
+		void zeroForce();
+		
 public:
 
 	/// Type info
@@ -95,8 +97,15 @@ public:
 		/// Construct from controlSystem and property, for reading from file
 		geometry(systemControl& control, const property& prop);
 
+		geometry(systemControl& control, 
+			const property& prop,
+			multiTriSurface& surf,
+			const wordVector& motionCompName,
+			const wordVector& materialName,
+			const dictionary& motionDict);
+
 		/// Construct from components
-		geometry(systemControl& control,
+		/*geometry(systemControl& control,
 				 const property& prop,
 				 const multiTriSurface& triSurface,
 				 const wordVector& motionCompName,
@@ -110,10 +119,10 @@ public:
 				 const dictionary& dict,
 				 const multiTriSurface& triSurface,
 				 const wordVector& motionCompName,
-				 const wordVector& propName);
+				 const wordVector& propName);*/
 
 		/// Destructor
-		virtual ~geometry() = default;
+		~geometry()override = default;
 
 		/// Virtual constructor 
 		create_vCtor
@@ -132,156 +141,96 @@ public:
 		(
 			geometry,
 			dictionary,
-			(systemControl& control,
-			 const property& prop,
-			 const dictionary& dict,
-			 const multiTriSurface& triSurface,
-			 const wordVector& motionCompName,
-			 const wordVector& propName),
-			(control, prop, dict, triSurface, motionCompName, propName)
+			(
+				systemControl& control, 
+				const property& prop,
+				multiTriSurface& surf,
+				const wordVector& motionCompName,
+				const wordVector& materialName,
+				const dictionary& motionDic),
+			(control, prop, surf, motionCompName, materialName, motionDic)
 		);
 
-	//- Methods 
-
-		/// Size of tri-surface 
-		inline
-		auto size()const
+	//- Methods 	
+		inline 
+		const auto& motionComponentName()const
 		{
-			return triSurface_.size();
+			return motionComponentName_;
 		}
-
-		/// Number of points in the set of surface walls 
-		inline
-		auto numPoints()const
-		{
-			return triSurface_.numPoints();
-		}
-
-		/// Number of triangles in the set of surface walls 
-		inline
-		auto numTriangles()const
-		{
-			return size();
-		}
-
-		/// Access to the points
-		inline
-		const auto& points()const
-		{
-			return triSurface_.points();
-		}
-
-		/// Access to the vertices 
-		inline
-		const auto& vertices()const
-		{
-			return triSurface_.vertices();
-		}
-
-		/// Obtain an object for accessing triangles 
-		inline auto getTriangleAccessor()const
-		{
-			return triSurface_.getTriangleAccessor();
-		}
-
-		/// Surface 
-		inline auto& surface()
-		{
-			return triSurface_;
-		}
-
-		/// Surface 
-		inline const auto& surface()const
-		{
-			return triSurface_;
-		}
-
+		
 		/// Access to contact force
 		inline
-		realx3TriSurfaceField_D& contactForceWall()
+		auto& contactForceWall()
 		{
 			return contactForceWall_;
 		}
 
 		/// Access to contact force
 		inline
-		const realx3TriSurfaceField_D& contactForceWall() const
+		const auto& contactForceWall() const
 		{
 			return contactForceWall_;
 		}
 
+		/// Property ide of triangles 
+		inline
+		const auto& propertyId()const
+		{
+			return propertyId_;
+		}
+
 		/// Access to property 
 		inline const auto& wallProperty()const
 		{
 			return wallProperty_;
 		}
 
-		/// Owner repository
-		inline
-		const repository& owner()const
-		{
-			return geometryRepository_;
-		}
-
-		/// Owner repository
-		inline
-		repository& owner()
-		{
-			return geometryRepository_;
-		}
-
-		/// Path to the repository folder 
-		inline auto path()
-		{
-			return owner().path();
-		}
-
 		/// The name of motion model 
 		virtual 
 		word motionModelTypeName()const = 0;
 
 		/// Motion model index of triangles 
 		virtual
-		const int8Vector_HD& 			triMotionIndex() const =0;
+		const uint32Field_D& triMotionIndex() const =0;
 
 		/// Motion model index of points 
 		virtual 
-		const int8Vector_HD& 			pointMotionIndex()const = 0;
+		const uint32Field_D& pointMotionIndex()const = 0;
 
-		/// Property ide of triangles 
-		const int8TriSurfaceField_D& 	propertyId() const
-		{
-			return propertyId_;
-		}
-
-		/// Operations before each iteration 
+		
 		bool beforeIteration() override;
-
-		/// Operations after each iteration
+		
+		/// This is called in time loop. Perform the main calculations 
+		/// when the component should evolve along time.
+		bool iterate() override;
+		
+		/// This is called in time loop, after iterate.
 		bool afterIteration() override;
-
+		
 	//- IO
 
+		bool read(iIstream& is, const IOPattern& iop) override;
+
 		/// write 
-		bool write()const
-		{
-			return owner().write();
-		}
+		bool write( iOstream& os, const IOPattern& iop )const override;
+		
 
 
 	//- Static members 
 
 		static
-		uniquePtr<geometry> create(systemControl& control, const property& prop);
+		uniquePtr<geometry> create(
+			systemControl& control, 
+			const property& prop);
 
 		static
 		uniquePtr<geometry> create(
-				systemControl& control,
-				const property& prop,
-				const dictionary& dict,
-				const multiTriSurface& triSurface,
-				const wordVector& motionCompName,
-				const wordVector& propName);
+			systemControl& control, 
+			const property& prop,
+			multiTriSurface& surf,
+			const wordVector& motionCompName,
+			const wordVector& materialName,
+			const dictionary& motionDic);
 
 };
 
diff --git a/src/Geometry/geometryMotion/geometryMotion.cpp b/src/Geometry/geometryMotion/geometryMotion.cpp
index ece859df..6420dadb 100644
--- a/src/Geometry/geometryMotion/geometryMotion.cpp
+++ b/src/Geometry/geometryMotion/geometryMotion.cpp
@@ -1,3 +1,4 @@
+#include "geometryMotion.hpp"
 /*------------------------------- phasicFlow ---------------------------------
       O        C enter of
      O O       E ngineering and
@@ -21,42 +22,88 @@ Licence:
 template<typename MotionModel>
 bool pFlow::geometryMotion<MotionModel>::findMotionIndex()
 {
-	motionIndex_.clear();
-	triMotionIndex_.reserve( this->surface().capacity() );
-	triMotionIndex_.clear();
-
-	ForAll( surfI, motionComponentName_)
+	
+	if(motionComponentName().size() != numSurfaces() )
 	{
-		auto mName = motionComponentName_[surfI];
-		auto mInd = motionModel_.nameToIndex(mName);
-		motionIndex_.push_back(mInd);
-		// fill motionIndex for triangles of the surface
-		int32 surfSize = this->surface().surfNumTriangles(surfI);
-		for(int32 i=0; i<surfSize; i++)
+		fatalErrorInFunction<<
+		"size of motion component names in the triSurface is not"<<
+		" equal to size of number of sub-surfaces"<<endl;
+		 return false;
+	}
+
+	uint32Vector surfMotionIndex("surfMotionIndex");
+	uint32Vector triMotionIndex("triMotionIndex");
+	uint32Vector pointMotionIndex("pointMotionIndex");
+
+	ForAll( surfI, motionComponentName())
+	{
+		auto mName = motionComponentName()[surfI];
+		uint32 mInd=0;
+		
+		if( !motionModel_.nameToIndex(mName, mInd) )
 		{
-			triMotionIndex_.push_back(mInd);
+			fatalErrorInFunction<<
+			mName<< " does not exist in the list of motion names -> "<<
+			motionModel_.componentNames();
+            return false;
+		}
+		surfMotionIndex.push_back(mInd);
+		
+		auto surfRange = subSurfaceRange(surfI);
+		
+		for(uint32 i=0; i<surfRange.numElements(); i++)
+		{
+			triMotionIndex.push_back(mInd);
+		}
+
+		auto pointRange = subSurfacePointRange(surfI);
+		for(uint32 n=0; n<pointRange.numElements(); n++)
+		{
+			pointMotionIndex.push_back(mInd);
 		}
 	}
-	motionIndex_.syncViews();
-	triMotionIndex_.syncViews();
-
-	pointMotionIndex_.reserve(triSurface_.numPoints());
-	pointMotionIndex_.clear();
-
-	ForAll(surfI, motionIndex_)
-	{
-		auto nP = triSurface_.surfNumPoints(surfI);
-		for(int32 i=0; i<nP; i++)
-		{
-			pointMotionIndex_.push_back(motionIndex_[surfI]);
-		}
-	}
-	pointMotionIndex_.syncViews();
+	
+	surfMotionIndex_.assign(surfMotionIndex);
+	triMotionIndex_.assign(triMotionIndex);
+	pointMotionIndex_.assign(pointMotionIndex);
 
 	return true;
 }
 
 
+template<typename MotionModel>
+ bool pFlow::geometryMotion<MotionModel>::moveGeometry()
+ {
+
+    uint32 iter = this->currentIter();
+    real t = this->currentTime();
+    real dt = this->dt();
+        
+    auto mModel = motionModel_.getModelInterface(iter, t, dt);
+    
+    auto& pointMIndexD= pointMotionIndex_.deviceViewAll();
+    auto& pointsD = points().deviceViewAll();
+    
+
+    Kokkos::parallel_for(
+         "geometryMotion<MotionModel>::movePoints",
+         deviceRPolicyStatic(0, numPoints()),
+         LAMBDA_HD(uint32 i){
+             auto newPos = mModel.transferPoint(pointMIndexD[i], pointsD[i], dt);
+             pointsD[i] = newPos;
+         });
+
+    Kokkos::fence();
+
+    // move the motion components
+    motionModel_.move(iter, t,dt);
+
+    // end of calculations
+     
+
+     return true;
+ }
+
 template<typename MotionModel>
 pFlow::geometryMotion<MotionModel>::geometryMotion
 (
@@ -65,144 +112,75 @@ pFlow::geometryMotion<MotionModel>::geometryMotion
 )
 :
 	geometry(control, prop),
-	motionModel_(
-		this->owner().template emplaceObject<MotionModel>(
-			objectFile(
-				motionModelFile__,
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS
-				)
-			)
+	motionModel_
+	(
+		objectFile
+		(
+			motionModelFile__,
+			"",
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_ALWAYS
 		),
+		owner()
+	),
 	moveGeomTimer_("move geometry", &this->timers())
 {
-	findMotionIndex();
-}
-
-template<typename MotionModel>
-pFlow::geometryMotion<MotionModel>::geometryMotion
-(
-	systemControl& control,
-	const property& prop,
-	const multiTriSurface& triSurface,
-	const wordVector& motionCompName,
-	const wordVector& propName,
-	const MotionModel& motionModel
-)
-:
-	geometry(
-		control,
-		prop,
-		triSurface,
-		motionCompName,
-		propName
-		),
-	motionModel_(
-		this->owner().template emplaceObject<MotionModel>(
-			objectFile(
-				motionModelFile__,
-				"",
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS
-				),
-			motionModel
-			)
-		),
-	moveGeomTimer_("move geometry", &this->timers())
-{
-	findMotionIndex();
-}
-
-template<typename MotionModel>
-pFlow::geometryMotion<MotionModel>::geometryMotion
-(
-	systemControl& control,
-	const property& prop,
-	const dictionary& dict,
-	const multiTriSurface& triSurface,
-	const wordVector& motionCompName,
-	const wordVector& propName
-)
-:
-	geometry(
-		control,
-		prop,
-		dict,
-		triSurface,
-		motionCompName,
-		propName
-		),
-	motionModel_(
-		this->owner().template emplaceObject<MotionModel>(
-			objectFile(
-				motionModelFile__,
-				"",
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS
-				),
-			dict
-			)
-		),
-	moveGeomTimer_("move geometry", &this->timers())
-{
-	findMotionIndex();
-}
-
-template<typename MotionModel>
-bool pFlow::geometryMotion<MotionModel>::beforeIteration() 
-{ 
-	geometry::beforeIteration();
-	return true;
-}
-
-template<typename MotionModel>
-bool pFlow::geometryMotion<MotionModel>::iterate()
-{
-	if( motionModel_.isMoving() )
+	if(!findMotionIndex())
 	{
-		moveGeomTimer_.start();
-		moveGeometry();
-		moveGeomTimer_.end();
+		fatalExit;
 	}
-	return true;
 }
 
-template<typename MotionModel>
-bool pFlow::geometryMotion<MotionModel>::afterIteration() 
+template <typename MotionModelType>
+pFlow::geometryMotion<MotionModelType>::geometryMotion
+(
+	systemControl &control, 
+	const property &prop, 
+	multiTriSurface &surf, 
+	const wordVector &motionCompName, 
+	const wordVector &materialName, 
+	const dictionary &motionDict
+)
+:
+	geometry
+	(
+		control, 
+		prop, 
+		surf, 
+		motionCompName, 
+		materialName,
+        motionDict
+	),
+	motionModel_
+	(
+		objectFile
+		(
+			motionModelFile__,
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_ALWAYS
+		),
+		motionDict,
+		owner()
+	),
+	moveGeomTimer_("move geometry", &this->timers())
 {
-	geometry::afterIteration();
-	return true;
-}
-
-template<typename MotionModel>
-bool pFlow::geometryMotion<MotionModel>::moveGeometry()
-{
-
-	real dt = this->dt();
-	real t = this->currentTime();
-
-	auto pointMIndex= pointMotionIndex_.deviceVector();
-	auto mModel = motionModel_.getModel(t);
-	realx3* points = triSurface_.pointsData_D();
-	auto numPoints = triSurface_.numPoints();
+	if(!findMotionIndex())
+	{
+		fatalExit;
+	}
+} 
 
 
-	Kokkos::parallel_for(
-		"geometryMotion<MotionModel>::movePoints",
-		numPoints,
-		LAMBDA_HD(int32 i){
-			auto newPos = mModel.transferPoint(pointMIndex[i], points[i], dt);
-			points[i] = newPos;
-		});
-
-	Kokkos::fence();
-
-	// move the motion components 
-	motionModel_.move(t,dt);
-
-	// end of calculations 
-	moveGeomTimer_.end();
-
-	return true;
-}
\ No newline at end of file
+ template<typename MotionModel>
+ bool pFlow::geometryMotion<MotionModel>::iterate()
+ {
+     if( motionModel_.isMoving() )
+     {
+        moveGeomTimer_.start();
+          moveGeometry();
+          this->calculateNormals();
+        moveGeomTimer_.end();
+     }
+     return true;
+ }
diff --git a/src/Geometry/geometryMotion/geometryMotion.hpp b/src/Geometry/geometryMotion/geometryMotion.hpp
index cf47c613..157c05e0 100644
--- a/src/Geometry/geometryMotion/geometryMotion.hpp
+++ b/src/Geometry/geometryMotion/geometryMotion.hpp
@@ -20,9 +20,8 @@ Licence:
 #ifndef __geometryMotion_hpp__
 #define __geometryMotion_hpp__
 
-
+#include "vocabs.hpp"
 #include "geometry.hpp"
-#include "VectorDuals.hpp"
 
 namespace pFlow
 {
@@ -39,21 +38,23 @@ class	geometryMotion
 {
 public:
 	
-	using MotionModel = MotionModelType;
+	using MotionModel 	 = MotionModelType;
 
-protected: 
+	using ModelComponent = typename MotionModelType::ModelComponent;
+
+private: 
 	
 	/// Ref to motion model 
-	MotionModel& 		motionModel_;
+	MotionModelType 	motionModel_;
 	
 	/// motion indext mapped on each surface 
-	int32Vector_HD  	motionIndex_;
+	uint32Field_D  		surfMotionIndex_{"triMotionIndex"};
 
 	/// motion index mapped on each triangle 
-	int8Vector_HD 		triMotionIndex_; 
+	uint32Field_D 		triMotionIndex_ {"surfMotionIndex"}; 
 
 	/// motion index mapped on each point 
-	int8Vector_HD		pointMotionIndex_;
+	uint32Field_D		pointMotionIndex_{"pointMotionIndex"};
 
 	/// timer for moveGeometry
 	Timer 				moveGeomTimer_;			
@@ -61,32 +62,25 @@ protected:
 	/// determine the motion index of each triangle 
 	bool findMotionIndex();
 	
+	/// Move geometry 
+	bool moveGeometry();
+
 public:
 
 	/// Type info
-	TypeInfoTemplate("geometry", MotionModel);
+	TypeInfoTemplate11("geometry", ModelComponent);
 
 	// - Constructors
 		
 		geometryMotion(systemControl& control, const property& prop);
 
-		
 		geometryMotion(
-			systemControl& control,
+			systemControl& control, 
 			const property& prop,
-			const multiTriSurface& triSurface,
+			multiTriSurface& surf,
 			const wordVector& motionCompName,
-			const wordVector& propName,
-			const MotionModel& motionModel);
-
-		/// Construct from components and dictionary that contains 
-		/// motionModel
-		geometryMotion(systemControl& control,
-				 const property& prop,
-				 const dictionary& dict,
-				 const multiTriSurface& triSurface,
-				 const wordVector& motionCompName,
-				 const wordVector& propName);
+			const wordVector& materialName,
+			const dictionary& motionDict);
 
 		/// Add virtual constructor 
 		add_vCtor
@@ -107,9 +101,9 @@ public:
 	// - Methods
 
 		/// Obtain motion model at time t 
-		auto getModel(real t)const
+		auto getModel(uint32 iter, real t, real dt)const
 		{
-			return motionModel_.getModel(t);
+			return motionModel_.getModelInterface(iter, t, dt);
 		}
 
 		/// TypeName / TypeInfo of motion model 
@@ -119,28 +113,21 @@ public:
 		}
 
 		/// Access to motion model index of triangles 
-		const int8Vector_HD& triMotionIndex()const override
+		const uint32Field_D& triMotionIndex()const override
 		{
 			return triMotionIndex_;
 		}
 
 		/// Access to motion model index of points 
-		const int8Vector_HD& pointMotionIndex()const override
+		const uint32Field_D& pointMotionIndex()const override
 		{
 			return pointMotionIndex_;
 		}
 
-		/// Operations before each iteration 
-		bool beforeIteration() override;
-
 		/// Iterate geometry one time step  
 		bool iterate() override ;
 
-		/// Operations after each iteration 
-		bool afterIteration() override;
-
-		/// Move geometry 
-		bool moveGeometry();
+		
 
 };
 
@@ -148,9 +135,6 @@ public:
 
 #include "geometryMotion.cpp"
 
-#ifndef BUILD_SHARED_LIBS
-	#include "geometryMotionsInstantiate.cpp"
-#endif
 
 
 #endif  //__geometryMotion_hpp__
diff --git a/src/Geometry/geometryMotion/geometryMotions.cpp b/src/Geometry/geometryMotion/geometryMotions.cpp
index 4eaa179a..8b1d1d55 100644
--- a/src/Geometry/geometryMotion/geometryMotions.cpp
+++ b/src/Geometry/geometryMotion/geometryMotions.cpp
@@ -17,9 +17,13 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
 #include "geometryMotions.hpp"
 
-#ifdef BUILD_SHARED_LIBS
-#include "geometryMotionsInstantiate.cpp"
-#endif
+
+template class pFlow::geometryMotion<pFlow::vibratingMotion>;
+
+template class pFlow::geometryMotion<pFlow::rotatingAxisMotion>;
+
+template class pFlow::geometryMotion<pFlow::stationaryWall>;
+
+//template class pFlow::geometryMotion<pFlow::multiRotatingAxisMotion>;
diff --git a/src/Geometry/geometryMotion/geometryMotions.hpp b/src/Geometry/geometryMotion/geometryMotions.hpp
index cd636ae6..1bb078d8 100644
--- a/src/Geometry/geometryMotion/geometryMotions.hpp
+++ b/src/Geometry/geometryMotion/geometryMotions.hpp
@@ -22,22 +22,23 @@ Licence:
 #define __geometryMotions_hpp__
 
 #include "geometryMotion.hpp"
-#include "fixedWall.hpp"
+#include "stationaryWall.hpp"
 #include "rotatingAxisMotion.hpp"
-#include "multiRotatingAxisMotion.hpp"
+//#include "multiRotatingAxisMotion.hpp"
 #include "vibratingMotion.hpp"
 
 
 namespace pFlow
 {
 
-typedef geometryMotion<vibratingMotion> vibratingMotionGeometry;
+using vibratingMotionGeometry = geometryMotion<vibratingMotion>;
 
-typedef geometryMotion<rotatingAxisMotion> rotationAxisMotionGeometry;
+using rotationAxisMotionGeometry = geometryMotion<rotatingAxisMotion>;
 
-typedef geometryMotion<multiRotatingAxisMotion> multiRotationAxisMotionGeometry;
+using stationaryGeometry = geometryMotion<stationaryWall>;
+
+//typedef geometryMotion<multiRotatingAxisMotion> multiRotationAxisMotionGeometry;
 
-typedef geometryMotion<fixedWall> fixedGeometry;
 
 
 
diff --git a/src/Integration/AdamsBashforth2/AdamsBashforth2.cpp b/src/Integration/AdamsBashforth2/AdamsBashforth2.cpp
index 09a4eaa0..c6bb54a6 100644
--- a/src/Integration/AdamsBashforth2/AdamsBashforth2.cpp
+++ b/src/Integration/AdamsBashforth2/AdamsBashforth2.cpp
@@ -19,59 +19,146 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "AdamsBashforth2.hpp"
+#include "pointStructure.hpp"
+#include "Time.hpp"
+#include "vocabs.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)
+{
+
+	auto d_dy = dy.deviceView();
+	auto d_y  = y.deviceView();
+	auto d_dy1= dy1.deviceView();
+	auto activeRng = dy1.activeRange();
+
+	Kokkos::parallel_for(
+		"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_dy1[i] = d_dy[i];
+		});
+	Kokkos::fence();
+
+	return true;	
+}
+
+bool intScattered
+(
+	real dt, 
+	realx3Field_D& y,
+	realx3PointField_D& dy,
+	realx3PointField_D& dy1
+)
+{
+
+	auto d_dy 		= dy.deviceView();
+	auto d_y  		= y.deviceView();
+	auto d_dy1		= dy1.deviceView();
+	auto activeRng 	= dy1.activeRange();
+	const auto& activeP = dy1.activePointsMaskDevice();
+
+	Kokkos::parallel_for(
+		"AdamsBashforth2::correct",
+		rpIntegration (activeRng.start(), activeRng.end()),
+		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_dy1[i] = d_dy[i];
+			}
+		});
+	Kokkos::fence();
+
+
+	return true;
+}
+
+}
+
 
-//const real AB2_coef[] = { 3.0 / 2.0, 1.0 / 2.0};
 
 pFlow::AdamsBashforth2::AdamsBashforth2
 (
 	const word& baseName,
-	repository& owner,
-	const pointStructure& pStruct,
-	const word& method
+	pointStructure& pStruct,
+	const word& method,
+	const realx3Field_D& initialValField
 )
 :
-	integration(baseName, owner, pStruct, method),
-	dy1_(
-		owner.emplaceObject<realx3PointField_D>(
-			objectFile(
-				groupNames(baseName,"dy1"),
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS),
-			pStruct,
-			zero3))
-{
-
-}
+	integration(baseName, pStruct, method, initialValField),
+	realx3PointField_D
+	(
+		objectFile
+		(
+			groupNames(baseName,"dy1"),
+			pStruct.time().integrationFolder(),
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS
+		),
+		pStruct,
+		zero3,
+		zero3
+	)
+{}
 
 bool pFlow::AdamsBashforth2::predict
 (
 	real UNUSED(dt),
-	realx3Vector_D& UNUSED(y),
-	realx3Vector_D& UNUSED(dy)
+	realx3PointField_D& UNUSED(y),
+	realx3PointField_D& UNUSED(dy)
 )
 {
-
 	return true;
 }
 
+bool pFlow::AdamsBashforth2::predict
+(
+	real dt, 
+	realx3Field_D &y, 
+	realx3PointField_D &dy
+)
+{
+    return true;
+}
+
 bool pFlow::AdamsBashforth2::correct
 (
 	real dt,
-	realx3Vector_D& y,
-	realx3Vector_D& dy
+	realx3PointField_D& y,
+	realx3PointField_D& dy
 )
 {
-	if(this->pStruct().allActive())
+	return correct(dt, y.field(), dy);
+}
+
+bool pFlow::AdamsBashforth2::correct(real dt, realx3Field_D &y, realx3PointField_D &dy)
+{
+	auto& dy1l = dy1();
+
+	if(dy1l.isAllActive())
 	{
-		return intAll(dt, y, dy, this->pStruct().activeRange());
+		return intAllActive(dt, y, dy, dy1l);
 	}
 	else
 	{
-		return intRange(dt, y, dy, this->pStruct().activePointsMaskD());
+		return intScattered(dt, y, dy, dy1l);
 	}
-
-	return true;
+    return false;
 }
 
 bool pFlow::AdamsBashforth2::setInitialVals(
@@ -81,25 +168,3 @@ bool pFlow::AdamsBashforth2::setInitialVals(
 	return true;
 }
 
-bool pFlow::AdamsBashforth2::intAll(
-	real dt, 
-	realx3Vector_D& y, 
-	realx3Vector_D& dy, 
-	range activeRng)
-{
-
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_dy1= dy1_.deviceVectorAll();
-
-	Kokkos::parallel_for(
-		"AdamsBashforth2::correct",
-		rpIntegration (activeRng.first, activeRng.second),
-		LAMBDA_HD(int32 i){
-			d_y[i] +=  dt*(static_cast<real>(3.0 / 2.0) * d_dy[i] - static_cast<real>(1.0 / 2.0) * d_dy1[i]);
-			d_dy1[i] = d_dy[i];
-		});
-	Kokkos::fence();
-
-	return true;	
-}
\ No newline at end of file
diff --git a/src/Integration/AdamsBashforth2/AdamsBashforth2.hpp b/src/Integration/AdamsBashforth2/AdamsBashforth2.hpp
index 6e2a8892..863bd8a1 100644
--- a/src/Integration/AdamsBashforth2/AdamsBashforth2.hpp
+++ b/src/Integration/AdamsBashforth2/AdamsBashforth2.hpp
@@ -36,20 +36,16 @@ namespace pFlow
  */
 class AdamsBashforth2
 :
-	public integration
+	public integration,
+	public realx3PointField_D
 {
-protected:
+private:
 
-	/// dy at t-dt
-	realx3PointField_D& dy1_;
-
-	/// Range policy for integration kernel (alias)
-	using rpIntegration = Kokkos::RangePolicy<
-			DefaultExecutionSpace,
-			Kokkos::Schedule<Kokkos::Static>,
-			Kokkos::IndexType<int32>
-			>;
 
+	auto& dy1()
+	{
+		return static_cast<realx3PointField_D&>(*this);
+	}
 public:
 
 	/// Type info
@@ -60,17 +56,12 @@ public:
 		/// Construct from components
 		AdamsBashforth2(
 			const word& baseName,
-			repository& owner,
-			const pointStructure& pStruct,
-			const word& method);
-
-		uniquePtr<integration> clone()const override
-		{
-			return makeUnique<AdamsBashforth2>(*this);
-		}
+			pointStructure& pStruct,
+			const word& method,
+			const realx3Field_D& initialValField);
 
 		/// Destructor 
-		virtual ~AdamsBashforth2()=default;
+		~AdamsBashforth2()final = default;
 
 		/// Add this to the virtual constructor table 
 		add_vCtor(
@@ -80,71 +71,44 @@ public:
 
 
 	// - Methods
+		/// return integration method 
+		word method()const override
+		{
+			return "AdamsBashforth2";
+		}
 
 		bool predict(
 			real UNUSED(dt), 
-			realx3Vector_D& UNUSED(y), 
-			realx3Vector_D& UNUSED(dy)) override;
+			realx3PointField_D& UNUSED(y), 
+			realx3PointField_D& UNUSED(dy)) final;
+		
+		bool predict(
+			real dt, 
+			realx3Field_D& y, 
+			realx3PointField_D& dy) final;
 
 		bool correct(
 			real dt, 
-			realx3Vector_D& y, 
-			realx3Vector_D& dy) override;
+			realx3PointField_D& y, 
+			realx3PointField_D& dy) final;
+
+		bool correct(
+			real dt, 
+			realx3Field_D& y, 
+			realx3PointField_D& dy);
+		
 
 		bool setInitialVals(
 			const int32IndexContainer& newIndices,
-			const realx3Vector& y) override;
+			const realx3Vector& y) final;
 
-		bool needSetInitialVals()const override
+		bool needSetInitialVals()const final
 		{
 			return false;
 		}
-		
-		/// Integrate on all points in the active range 
-		bool intAll(
-			real dt, 
-			realx3Vector_D& y, 
-			realx3Vector_D& dy, 
-			range activeRng);
-
-		/// Integrate on active points in the active range 
-		template<typename activeFunctor>
-		bool intRange(
-			real dt, 
-			realx3Vector_D& y, 
-			realx3Vector_D& dy, 
-			activeFunctor activeP );
 
 };
 
-template<typename activeFunctor>
-bool pFlow::AdamsBashforth2::intRange(
-	real dt, 
-	realx3Vector_D& y,
-	realx3Vector_D& dy,
-	activeFunctor activeP )
-{
-
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_dy1= dy1_.deviceVectorAll();
-	auto activeRng = activeP.activeRange();
-
-	Kokkos::parallel_for(
-		"AdamsBashforth2::correct",
-		rpIntegration (activeRng.first, activeRng.second),
-		LAMBDA_HD(int32 i){
-			if( activeP(i))
-			{
-				d_y[i] +=  dt*(static_cast<real>(3.0 / 2.0) * d_dy[i] - static_cast<real>(1.0 / 2.0) * d_dy1[i]);
-				d_dy1[i] = d_dy[i];
-			}
-		});
-	Kokkos::fence();
-
-
-	return true;
-}
 
 } // pFlow
 
diff --git a/src/Integration/AdamsBashforth3/AdamsBashforth3.cpp b/src/Integration/AdamsBashforth3/AdamsBashforth3.cpp
index 040a9e40..f8ec6b5a 100644
--- a/src/Integration/AdamsBashforth3/AdamsBashforth3.cpp
+++ b/src/Integration/AdamsBashforth3/AdamsBashforth3.cpp
@@ -89,9 +89,9 @@ bool pFlow::AdamsBashforth3::intAll(
 	realx3Vector_D& dy, 
 	range activeRng)
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_history = history_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_history = history_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsBashforth3::correct",
diff --git a/src/Integration/AdamsBashforth3/AdamsBashforth3.hpp b/src/Integration/AdamsBashforth3/AdamsBashforth3.hpp
index 6bd47b11..279fdcda 100644
--- a/src/Integration/AdamsBashforth3/AdamsBashforth3.hpp
+++ b/src/Integration/AdamsBashforth3/AdamsBashforth3.hpp
@@ -160,9 +160,9 @@ bool pFlow::AdamsBashforth3::intRange(
 	realx3Vector_D& dy,
 	activeFunctor activeP )
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_history = history_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_history = history_.deviceViewAll();
 	auto activeRng = activeP.activeRange();
 
 	Kokkos::parallel_for(
diff --git a/src/Integration/AdamsBashforth4/AdamsBashforth4.cpp b/src/Integration/AdamsBashforth4/AdamsBashforth4.cpp
index 547de93f..23bad29b 100644
--- a/src/Integration/AdamsBashforth4/AdamsBashforth4.cpp
+++ b/src/Integration/AdamsBashforth4/AdamsBashforth4.cpp
@@ -89,9 +89,9 @@ bool pFlow::AdamsBashforth4::intAll(
 	realx3Vector_D& dy, 
 	range activeRng)
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_history = history_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_history = history_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsBashforth4::correct",
diff --git a/src/Integration/AdamsBashforth4/AdamsBashforth4.hpp b/src/Integration/AdamsBashforth4/AdamsBashforth4.hpp
index 4f4a2914..cf1f50d8 100644
--- a/src/Integration/AdamsBashforth4/AdamsBashforth4.hpp
+++ b/src/Integration/AdamsBashforth4/AdamsBashforth4.hpp
@@ -165,9 +165,9 @@ bool pFlow::AdamsBashforth4::intRange(
 	realx3Vector_D& dy,
 	activeFunctor activeP )
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_history = history_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_history = history_.deviceViewAll();
 	auto activeRng = activeP.activeRange();
 
 	Kokkos::parallel_for(
diff --git a/src/Integration/AdamsBashforth5/AdamsBashforth5.cpp b/src/Integration/AdamsBashforth5/AdamsBashforth5.cpp
index 580f0c06..7b87a4a3 100644
--- a/src/Integration/AdamsBashforth5/AdamsBashforth5.cpp
+++ b/src/Integration/AdamsBashforth5/AdamsBashforth5.cpp
@@ -89,9 +89,9 @@ bool pFlow::AdamsBashforth5::intAll(
 	realx3Vector_D& dy, 
 	range activeRng)
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_history = history_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_history = history_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsBashforth5::correct",
diff --git a/src/Integration/AdamsBashforth5/AdamsBashforth5.hpp b/src/Integration/AdamsBashforth5/AdamsBashforth5.hpp
index 99261588..16b55927 100644
--- a/src/Integration/AdamsBashforth5/AdamsBashforth5.hpp
+++ b/src/Integration/AdamsBashforth5/AdamsBashforth5.hpp
@@ -165,9 +165,9 @@ bool pFlow::AdamsBashforth5::intRange(
 	realx3Vector_D& dy,
 	activeFunctor activeP )
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_history = history_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_history = history_.deviceViewAll();
 	auto activeRng = activeP.activeRange();
 
 	Kokkos::parallel_for(
diff --git a/src/Integration/AdamsMoulton3/AdamsMoulton3.cpp b/src/Integration/AdamsMoulton3/AdamsMoulton3.cpp
index cb819c7c..4fb030bf 100644
--- a/src/Integration/AdamsMoulton3/AdamsMoulton3.cpp
+++ b/src/Integration/AdamsMoulton3/AdamsMoulton3.cpp
@@ -124,11 +124,11 @@ bool pFlow::AdamsMoulton3::predictAll(
 	range activeRng)
 {
 
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_y0 = y0_.deviceVectorAll();
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_dy1= dy1_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_y0 = y0_.deviceViewAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_dy1= dy1_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsMoulton3::predict",
@@ -150,12 +150,12 @@ bool pFlow::AdamsMoulton3::intAll(
 	range activeRng)
 {
 
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsMoulton3::correct",
diff --git a/src/Integration/AdamsMoulton3/AdamsMoulton3.hpp b/src/Integration/AdamsMoulton3/AdamsMoulton3.hpp
index 349d62b2..3193a819 100644
--- a/src/Integration/AdamsMoulton3/AdamsMoulton3.hpp
+++ b/src/Integration/AdamsMoulton3/AdamsMoulton3.hpp
@@ -144,11 +144,11 @@ bool AdamsMoulton3::predictRange(
 	realx3Vector_D& dy,
 	activeFunctor activeP)
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
-	auto d_y0 = y0_.deviceVectorAll();
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_dy1= dy1_.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
+	auto d_y0 = y0_.deviceViewAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_dy1= dy1_.deviceViewAll();
 	
 	auto activeRng = activeP.activeRange();
 
@@ -182,12 +182,12 @@ bool pFlow::AdamsMoulton3::intRange(
 	activeFunctor activeP)
 {
 
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
 
 	auto activeRng = activeP.activeRange();
 
diff --git a/src/Integration/AdamsMoulton4/AdamsMoulton4.cpp b/src/Integration/AdamsMoulton4/AdamsMoulton4.cpp
index ec735ac8..3cdbbc8f 100644
--- a/src/Integration/AdamsMoulton4/AdamsMoulton4.cpp
+++ b/src/Integration/AdamsMoulton4/AdamsMoulton4.cpp
@@ -135,13 +135,13 @@ bool pFlow::AdamsMoulton4::predictAll(
 	range activeRng)
 {
 
-	auto d_dy  = dy.deviceVectorAll();
-	auto d_y   = y.deviceVectorAll();
+	auto d_dy  = dy.deviceViewAll();
+	auto d_y   = y.deviceViewAll();
 
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsMoulton4::predict",
@@ -165,13 +165,13 @@ bool pFlow::AdamsMoulton4::intAll(
 	range activeRng)
 {
 
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsMoulton4::correct",
diff --git a/src/Integration/AdamsMoulton4/AdamsMoulton4.hpp b/src/Integration/AdamsMoulton4/AdamsMoulton4.hpp
index c0da0f62..3950798a 100644
--- a/src/Integration/AdamsMoulton4/AdamsMoulton4.hpp
+++ b/src/Integration/AdamsMoulton4/AdamsMoulton4.hpp
@@ -147,13 +147,13 @@ bool AdamsMoulton4::predictRange(
 	realx3Vector_D& dy,
 	activeFunctor activeP )
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_y0 = y0_.deviceVectorAll();
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
+	auto d_y0 = y0_.deviceViewAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
 	
 	auto activeRng = activeP.activeRange();
 
@@ -185,13 +185,13 @@ bool pFlow::AdamsMoulton4::intRange(
 	activeFunctor activeP )
 {
 
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
 
 	auto activeRng = activeP.activeRange();
 
diff --git a/src/Integration/AdamsMoulton5/AdamsMoulton5.cpp b/src/Integration/AdamsMoulton5/AdamsMoulton5.cpp
index c3f62f18..37629649 100644
--- a/src/Integration/AdamsMoulton5/AdamsMoulton5.cpp
+++ b/src/Integration/AdamsMoulton5/AdamsMoulton5.cpp
@@ -145,14 +145,14 @@ bool pFlow::AdamsMoulton5::predictAll(
 	range activeRng)
 {
 
-	auto d_dy  = dy.deviceVectorAll();
-	auto d_y   = y.deviceVectorAll();
+	auto d_dy  = dy.deviceViewAll();
+	auto d_y   = y.deviceViewAll();
 
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
-	auto d_dy3 = dy3_.deviceVectorAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
+	auto d_dy3 = dy3_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsMoulton5::predict",
@@ -178,14 +178,14 @@ bool pFlow::AdamsMoulton5::intAll(
 	range activeRng)
 {
 
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
-	auto d_dy3 = dy3_.deviceVectorAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
+	auto d_dy3 = dy3_.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"AdamsMoulton5::correct",
diff --git a/src/Integration/AdamsMoulton5/AdamsMoulton5.hpp b/src/Integration/AdamsMoulton5/AdamsMoulton5.hpp
index 2e381d4a..451ff81f 100644
--- a/src/Integration/AdamsMoulton5/AdamsMoulton5.hpp
+++ b/src/Integration/AdamsMoulton5/AdamsMoulton5.hpp
@@ -150,14 +150,14 @@ bool AdamsMoulton5::predictRange(
 	realx3Vector_D& dy,
 	activeFunctor activeP )
 {
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_y0 = y0_.deviceVectorAll();
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
-	auto d_dy3 = dy3_.deviceVectorAll();
+	auto d_y0 = y0_.deviceViewAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
+	auto d_dy3 = dy3_.deviceViewAll();
 	
 	auto activeRng = activeP.activeRange();
 
@@ -189,14 +189,14 @@ bool pFlow::AdamsMoulton5::intRange(
 	activeFunctor activeP )
 {
 
-	auto d_dy = dy.deviceVectorAll();
-	auto d_y  = y.deviceVectorAll();
+	auto d_dy = dy.deviceViewAll();
+	auto d_y  = y.deviceViewAll();
 
-	auto d_dy0 = dy0_.deviceVectorAll();
-	auto d_y0  = y0_.deviceVectorAll();
-	auto d_dy1 = dy1_.deviceVectorAll();
-	auto d_dy2 = dy2_.deviceVectorAll();
-	auto d_dy3 = dy3_.deviceVectorAll();
+	auto d_dy0 = dy0_.deviceViewAll();
+	auto d_y0  = y0_.deviceViewAll();
+	auto d_dy1 = dy1_.deviceViewAll();
+	auto d_dy2 = dy2_.deviceViewAll();
+	auto d_dy3 = dy3_.deviceViewAll();
 
 	auto activeRng = activeP.activeRange();
 
diff --git a/src/Integration/CMakeLists.txt b/src/Integration/CMakeLists.txt
index f3a03112..fca650cd 100644
--- a/src/Integration/CMakeLists.txt
+++ b/src/Integration/CMakeLists.txt
@@ -1,13 +1,13 @@
 
 list(APPEND SourceFiles 
 integration/integration.cpp 
-AdamsBashforth5/AdamsBashforth5.cpp
-AdamsBashforth4/AdamsBashforth4.cpp
-AdamsBashforth3/AdamsBashforth3.cpp
 AdamsBashforth2/AdamsBashforth2.cpp
-AdamsMoulton3/AdamsMoulton3.cpp
-AdamsMoulton4/AdamsMoulton4.cpp
-AdamsMoulton5/AdamsMoulton5.cpp
+#AdamsBashforth5/AdamsBashforth5.cpp
+#AdamsBashforth4/AdamsBashforth4.cpp
+#AdamsBashforth3/AdamsBashforth3.cpp
+#AdamsMoulton3/AdamsMoulton3.cpp
+#AdamsMoulton4/AdamsMoulton4.cpp
+#AdamsMoulton5/AdamsMoulton5.cpp
 )
 
 set(link_libs Kokkos::kokkos phasicFlow)
diff --git a/src/Integration/integration/integration.cpp b/src/Integration/integration/integration.cpp
index 6e48ddaf..f3126e1e 100644
--- a/src/Integration/integration/integration.cpp
+++ b/src/Integration/integration/integration.cpp
@@ -19,33 +19,35 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "integration.hpp"
+#include "pointStructure.hpp"
+#include "repository.hpp"
 
 pFlow::integration::integration
 (
 	const word& baseName,
-	repository& owner,
-	const pointStructure& pStruct,
-	const word& method
+	pointStructure& pStruct,
+	const word&,
+	const realx3Field_D&
 )
 :
-	owner_(owner),
-	baseName_(baseName),
-	pStruct_(pStruct)
-{
-	CONSUME_PARAM(method);
-}
+	owner_(*pStruct.owner()),
+	pStruct_(pStruct),
+	baseName_(baseName)	
+{}
 
 
 pFlow::uniquePtr<pFlow::integration> 
-	pFlow::integration::create(
+	pFlow::integration::create
+(
 		const word& baseName,
-		repository& owner,
-		const pointStructure& pStruct,
-		const word& method)
+		pointStructure& pStruct,
+		const word& method,
+		const realx3Field_D& initialValField
+)
 {
 	if( wordvCtorSelector_.search(method) )
 	{
-		return wordvCtorSelector_[method] (baseName, owner, pStruct, method);
+		return wordvCtorSelector_[method] (baseName, pStruct, method, initialValField);
 	}
 	else
 	{
diff --git a/src/Integration/integration/integration.hpp b/src/Integration/integration/integration.hpp
index 3cca58c2..4769c3ec 100644
--- a/src/Integration/integration/integration.hpp
+++ b/src/Integration/integration/integration.hpp
@@ -23,14 +23,16 @@ Licence:
 
 
 #include "virtualConstructor.hpp"
-#include "Vectors.hpp"
-#include "pointStructure.hpp"
-#include "repository.hpp"
+#include "pointFields.hpp"
 
 
 namespace pFlow
 {
 
+// - Forward
+class repository;
+class pointStructure;
+
 /**
  * Base class for integrating the first order ODE (IVP) 
  * 
@@ -48,19 +50,19 @@ namespace pFlow
  */
 class integration
 {
-protected:
+private:
 
 	// - Protected data members 
 
 		/// The owner repository that all fields are storred in
 		repository& owner_;
 
-		/// The base name for integration 
-		const word baseName_;
-
 		/// A reference to pointStructure
 		const pointStructure& pStruct_;
 
+		/// The base name for integration 
+		const word baseName_;
+
 public:
 
 	/// Type info
@@ -72,9 +74,9 @@ public:
 		/// Construct from components
 		integration(
 			const word& baseName,
-			repository& owner,
-			const pointStructure& pStruct,
-			const word& method);
+			pointStructure& pStruct,
+			const word& method,
+			const realx3Field_D& initialValField);
 
 		/// Copy constructor 
 		integration(const integration&) = default;
@@ -88,22 +90,22 @@ public:
 		/// Move assignment
 		integration& operator = (integration&&) = default;
 
-		/// Polymorphic copy/cloning
-		virtual 
-		uniquePtr<integration> clone()const=0;
-
 		/// Destructor 
 		virtual ~integration()=default;
 
 		/// Add a virtual constructor 
-		create_vCtor(
+		create_vCtor
+		(
 			integration,
 			word,
-			(const word& baseName,
-			repository& owner,
-			const pointStructure& pStruct,
-			const word& method),
-			(baseName, owner, pStruct, method) );
+			(
+				const word& baseName,
+				pointStructure& pStruct,
+				const word& method,
+				const realx3Field_D& initialValField
+			),
+			(baseName, pStruct, method, initialValField)
+		);
 
 
 	// - Methods
@@ -129,13 +131,23 @@ public:
 			return owner_;
 		}
 
+		/// return integration method 
+		virtual 
+		word method()const = 0 ;
+
 		/// Prediction step in integration
 		virtual 
-		bool predict(real dt, realx3Vector_D& y, realx3Vector_D& dy) = 0;
+		bool predict(real dt, realx3PointField_D& y, realx3PointField_D& dy) = 0;
+
+		virtual 
+		bool predict(real dt, realx3Field_D& y, realx3PointField_D& dy) = 0;
 
 		/// Correction/main integration step
 		virtual 
-		bool correct(real dt, realx3Vector_D& y, realx3Vector_D& dy) = 0;
+		bool correct(real dt, realx3PointField_D& y, realx3PointField_D& dy) = 0;
+
+		virtual 
+		bool correct(real dt, realx3Field_D& y, realx3PointField_D& dy) = 0;
 
 		/// Set the initial values for new indices 
 		virtual 
@@ -152,9 +164,9 @@ public:
 	static
 		uniquePtr<integration> create(
 			const word& baseName,
-			repository& owner,
-			const pointStructure& pStruct,
-			const word& method);
+			pointStructure& pStruct,
+			const word& method,
+			const realx3Field_D& initialValField);
 
 }; // integration
 
diff --git a/src/Interaction/CMakeLists.txt b/src/Interaction/CMakeLists.txt
index 25d43014..7e9212da 100644
--- a/src/Interaction/CMakeLists.txt
+++ b/src/Interaction/CMakeLists.txt
@@ -1,5 +1,10 @@
 
 set(SourceFiles 
+contactSearch/methods/cellBased/NBS/mapperNBS.cpp
+contactSearch/methods/cellBased/NBS/mapperNBSKernels.cpp
+contactSearch/methods/cellBased/NBS/NBSLevel0.cpp
+contactSearch/methods/cellBased/NBS/NBS.cpp
+contactSearch/methods/cellBased/NBS/cellsWallLevel0.cpp
 contactSearch/contactSearch/contactSearch.cpp
 contactSearch/ContactSearch/ContactSearchs.cpp
 interaction/interaction.cpp
diff --git a/src/Interaction/Models/contactForce/linearCF.hpp b/src/Interaction/Models/contactForce/linearCF.hpp
index 5ef6da3e..88bf2108 100644
--- a/src/Interaction/Models/contactForce/linearCF.hpp
+++ b/src/Interaction/Models/contactForce/linearCF.hpp
@@ -133,8 +133,9 @@ protected:
 			return false;
 		}
 
-		realVector etha_n(nElem);
-		realVector etha_t(nElem);
+		realVector etha_n("etha_n", nElem);
+		realVector etha_t("etha_t", nElem);
+
 		ForAll(i , kn)
 		{
 			etha_n[i] = -2.0*log(en[i])*sqrt(kn[i])/
@@ -144,7 +145,7 @@ protected:
 					sqrt(pow(log(et[i]),2.0)+ pow(Pi,2.0));
 		}
 
-		Vector<linearProperties> prop(nElem);
+		Vector<linearProperties> prop("prop", nElem);
 		ForAll(i,kn)
 		{
 			prop[i] = {kn[i], kt[i], etha_n[i], etha_t[i], mu[i]};
@@ -219,10 +220,10 @@ public:
 	void contactForce
 	(
 		const real dt,
-		const int32 i,
-		const int32 j,
-		const int32 propId_i,
-		const int32 propId_j,
+		const uint32 i,
+		const uint32 j,
+		const uint32 propId_i,
+		const uint32 propId_j,
 		const real Ri,
 		const real Rj,
 		const real ovrlp_n,
diff --git a/src/Interaction/Models/contactForce/nonLinearCF.hpp b/src/Interaction/Models/contactForce/nonLinearCF.hpp
index b9f42d69..3ba1c5c5 100644
--- a/src/Interaction/Models/contactForce/nonLinearCF.hpp
+++ b/src/Interaction/Models/contactForce/nonLinearCF.hpp
@@ -121,7 +121,7 @@ protected:
 		}
 
 
-		realVector etha_n(nElem);
+		realVector etha_n("etha_n",nElem);
 		
 		ForAll(i , en)
 		{
@@ -137,7 +137,7 @@ protected:
 
 		}
 
-		Vector<nonLinearProperties> prop(nElem);
+		Vector<nonLinearProperties> prop("prop",nElem);
 		ForAll(i,Yeff)
 		{
 			prop[i] = {Yeff[i], Geff[i], etha_n[i], mu[i]};
@@ -214,10 +214,10 @@ public:
 	void contactForce
 	(
 		const real dt,
-		const int32 i,
-		const int32 j,
-		const int32 propId_i,
-		const int32 propId_j,
+		const uint32 i,
+		const uint32 j,
+		const uint32 propId_i,
+		const uint32 propId_j,
 		const real Ri,
 		const real Rj,
 		const real ovrlp_n,
diff --git a/src/Interaction/Models/contactForce/nonLinearMod.hpp b/src/Interaction/Models/contactForce/nonLinearMod.hpp
index 3bfbd29b..9a771970 100644
--- a/src/Interaction/Models/contactForce/nonLinearMod.hpp
+++ b/src/Interaction/Models/contactForce/nonLinearMod.hpp
@@ -121,7 +121,7 @@ protected:
 		}
 
 
-		Vector<nonLinearProperties> prop(nElem);
+		Vector<nonLinearProperties> prop("prop",nElem);
 		ForAll(i,Yeff)
 		{
 			prop[i] = {Yeff[i], Geff[i], etha_n[i], mu[i]};
@@ -198,10 +198,10 @@ public:
 	void contactForce
 	(
 		const real dt,
-		const int32 i,
-		const int32 j,
-		const int32 propId_i,
-		const int32 propId_j,
+		const uint32 i,
+		const uint32 j,
+		const uint32 propId_i,
+		const uint32 propId_j,
 		const real Ri,
 		const real Rj,
 		const real ovrlp_n,
diff --git a/src/Interaction/Models/rolling/normalRolling.hpp b/src/Interaction/Models/rolling/normalRolling.hpp
index de850e3c..80b8e321 100644
--- a/src/Interaction/Models/rolling/normalRolling.hpp
+++ b/src/Interaction/Models/rolling/normalRolling.hpp
@@ -76,10 +76,10 @@ public:
 	void rollingFriction
 	(
 		const real dt,
-		const int32 i,
-		const int32 j,
-		const int32 propId_i,
-		const int32 propId_j,
+		const uint32 i,
+		const uint32 j,
+		const uint32 propId_i,
+		const uint32 propId_j,
 		const real Ri,
 		const real Rj,
 		const realx3& wi,
diff --git a/src/Interaction/contactLists/sortedContactList.hpp b/src/Interaction/contactLists/sortedContactList.hpp
index 45c8e4b0..73f0ce4b 100644
--- a/src/Interaction/contactLists/sortedContactList.hpp
+++ b/src/Interaction/contactLists/sortedContactList.hpp
@@ -53,7 +53,7 @@ protected:
 
 	ViewType1D<ValueType,ExecutionSpace> 	values_;
 
-	int32 									size0_ = 0;
+	uint32 									size0_ = 0;
 
 	ViewType1D<PairType,ExecutionSpace> 	sortedPairs0_;
 
@@ -73,7 +73,7 @@ protected:
 	using rpReFillPairs = Kokkos::RangePolicy<
 		ExecutionSpace,
 		Kokkos::Schedule<Kokkos::Static>,
-		Kokkos::IndexType<int32>,
+		Kokkos::IndexType<uint32>,
 		TagReFillPairs>;
 
 public:
@@ -81,7 +81,7 @@ public:
 	TypeInfoNV("sortedContactList");
 
 
-	sortedContactList(int32 initialSize =1)
+	explicit sortedContactList(uint32 initialSize =1)
 	:
 		SortedPairs(initialSize),
 		values_("values", SortedPairs::capacity()),
@@ -114,31 +114,31 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	ValueType getValue(int32 idx)const
+	ValueType getValue(uint32 idx)const
 	{
 		return values_[idx];
 	}
 
 	INLINE_FUNCTION_HD
-	void setValue(int32 idx, const ValueType& val)const
+	void setValue(uint32 idx, const ValueType& val)const
 	{
 		values_[idx] = val;
 	}
 
 	INLINE_FUNCTION_HD
-	void operator()(TagReFillPairs, int32 idx)const
+	void operator()(TagReFillPairs, uint32 idx)const
 	{
 
-		auto searchLen = max(size0_/1000,10);
-		auto start 	= max(0,idx-searchLen);
-		auto end 	= min(size0_,idx+searchLen);
+		uint32 searchLen = max(size0_/1000u,10u);
+		uint32 start 	= idx-min(searchLen,idx);
+		uint32 end 	= min(size0_,idx+searchLen);
 		auto newPair = this->sortedPairs_[idx];
 		if(	auto idx0 = binarySearch(
 				sortedPairs0_,
 				start,
 				end,
 				newPair);
-				idx0>=0)
+				idx0!=-1)
 		{
 			values_[idx] = values0_[idx0];
 		}
@@ -147,7 +147,7 @@ public:
 			start, 
 			end,
 			newPair);
-			idx0>=0)
+			idx0!=-1)
 		{
 			values_[idx] = values0_[idx0];
 			
diff --git a/src/Interaction/contactLists/sortedPairs.hpp b/src/Interaction/contactLists/sortedPairs.hpp
index d8b74a50..12593810 100644
--- a/src/Interaction/contactLists/sortedPairs.hpp
+++ b/src/Interaction/contactLists/sortedPairs.hpp
@@ -52,24 +52,24 @@ public:
 	{
 		using PairType = typename sortedPairs::PairType;
 
-		int32 size_;
+		uint32 size_;
 
 		ViewType1D<PairType,ExecutionSpace> sortedParis_;
 
 		INLINE_FUNCTION_HD
-		int32 size()const { return size_; }
+		uint32 size()const { return size_; }
 
 		INLINE_FUNCTION_HD
-		int32 loopCount()const { return size_; }
+		uint32 loopCount()const { return size_; }
 
 		INLINE_FUNCTION_HD
-		bool isValid(int32 i)const { return i<size_; }
+		bool isValid(uint32 i)const { return i<size_; }
 
 		INLINE_FUNCTION_HD
-		PairType getPair(int i)const {	return sortedParis_[i];	}
+		PairType getPair(uint32 i)const {	return sortedParis_[i];	}
 
 		INLINE_FUNCTION_HD
-		bool getPair(int32 i, PairType& pair)const {
+		bool getPair(uint32 i, PairType& pair)const {
 			if(i<size_)	{
 				pair = sortedParis_[i];
 				return true;
@@ -85,22 +85,22 @@ public:
 protected:
 
 	/// size of pair list
-	int32 			size_ = 0;
+	uint32 			size_ = 0;
 
-	ViewType1D<int32,ExecutionSpace>		flags_;
+	ViewType1D<uint32,ExecutionSpace>		flags_;
 
 	ViewType1D<PairType,ExecutionSpace> 	sortedPairs_;
 
 	using rpFillFlag = Kokkos::RangePolicy<
 		ExecutionSpace,
 		Kokkos::Schedule<Kokkos::Static>,
-		Kokkos::IndexType<int32>,
+		Kokkos::IndexType<uint32>,
 		TagFillFlag	>;
 
 	using rpFillPairs = Kokkos::RangePolicy<
 		ExecutionSpace,
 		Kokkos::Schedule<Kokkos::Static>,
-		Kokkos::IndexType<int32>,
+		Kokkos::IndexType<uint32>,
 		TagFillPairs>;
 	
 public:
@@ -110,7 +110,7 @@ public:
 
 
 	// constructors
-	sortedPairs(int32 initialSize =1)
+	explicit sortedPairs(uint32 initialSize =1)
 	:
 		UnsortedPairs(initialSize),
 		flags_("flags_",UnsortedPairs::capacity()+1),
@@ -134,7 +134,7 @@ public:
 	//   return the pair at index idx
 	//   perform no check for size and existance
 	INLINE_FUNCTION_HD
-	PairType getPair(int32 idx)const
+	PairType getPair(uint32 idx)const
 	{
 		return sortedPairs_[idx];
 	}
@@ -142,7 +142,7 @@ public:
 	// - Device/host call
 	//   return the pair at index idx
 	INLINE_FUNCTION_HD
-	bool getPair(int32 idx, PairType& p)const
+	bool getPair(uint32 idx, PairType& p)const
 	{
 		if(isValid(idx))
 		{
@@ -156,7 +156,7 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	bool isValid(int32 idx)const
+	bool isValid(uint32 idx)const
 	{
 		return idx < size_;	
 	}
@@ -164,12 +164,12 @@ public:
 
 	//use this when the value of size_ is updated
 	INLINE_FUNCTION_H
-	int32 size()const
+	uint32 size()const
 	{
 		return size_;
 	}
 
-	int32 loopCount()const
+	uint32 loopCount()const
 	{
 		return size_;
 	}
@@ -189,7 +189,7 @@ public:
 	void prepareSorted()
 	{
 		// first check the size of flags_ 
-		int32 capacity = UnsortedPairs::capacity();
+		uint32 capacity = UnsortedPairs::capacity();
 
 		if( capacity+1 > flags_.size() )
 		{
@@ -218,7 +218,7 @@ public:
 		if( size_>sortedPairs_.size() )
 		{
 			// get more space to prevent reallocations in next iterations
-			int32 len = size_*1.1+1; 
+			uint32 len = size_*1.1+1; 
 			reallocNoInit(sortedPairs_, len);
 		}
 		
@@ -235,7 +235,7 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	void operator()(TagFillFlag, int32 i)const
+	void operator()(TagFillFlag, uint32 i)const
 	{
 		if(this->container_.valid_at(i) )
 			flags_[i] = 1;
@@ -244,7 +244,7 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	void operator()(TagFillPairs, int32 i)const
+	void operator()(TagFillPairs, uint32 i)const
 	{
 		auto fi = flags_[i];
 		if(fi!=flags_[i+1])
diff --git a/src/Interaction/contactLists/unsortedContactList.hpp b/src/Interaction/contactLists/unsortedContactList.hpp
index f2200fd9..2a3150b1 100644
--- a/src/Interaction/contactLists/unsortedContactList.hpp
+++ b/src/Interaction/contactLists/unsortedContactList.hpp
@@ -72,7 +72,7 @@ protected:
 	using rpFillPairs = Kokkos::RangePolicy<
 		ExecutionSpace,
 		Kokkos::Schedule<Kokkos::Static>,
-		Kokkos::IndexType<int32>,
+		Kokkos::IndexType<uint32>,
 		TagReFillPairs>;
 
 
@@ -80,7 +80,7 @@ public:
 
 	TypeInfoNV("unsortedContactList");
 
-	unsortedContactList(int32 capacity=1)
+	explicit unsortedContactList(uint32 capacity=1)
 	:
 		UnsortedPairs(capacity),
 		values_("values", UnsortedPairs::capacity()),
@@ -122,7 +122,7 @@ public:
 	INLINE_FUNCTION_HD
 	bool getValue(const PairType& p, ValueType& val)const
 	{
-		if(auto idx = this->find(p); idx>=0)
+		if(auto idx = this->find(p); idx!=-1)
 		{
 			val = getValue(idx); 
 			return true;
@@ -131,7 +131,7 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	void setValue(int32 idx, const ValueType& val)const
+	void setValue(uint32 idx, const ValueType& val)const
 	{
 		values_[idx] = val;
 	}
@@ -139,7 +139,7 @@ public:
 	INLINE_FUNCTION_HD
 	bool setValue(const PairType& p, const ValueType& val)const
 	{
-		if(auto idx = this->find(p); idx>=0)
+		if(uint32 idx = this->find(p); idx!=-1)
 		{
 			setValue(idx, val);
 			return true;;
@@ -148,13 +148,13 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	void operator()(TagReFillPairs, int32 idx)const
+	void operator()(TagReFillPairs, uint32 idx)const
 	{
 		if( this->isValid(idx) )
 		{
-			if( int32 idx0 = 
+			if( uint32 idx0 = 
 					container0_.find(this->getPair(idx));
-					idx0>=0 )
+					idx0!=-1 )
 			{
 				values_[idx] = values0_[idx0];
 			}
diff --git a/src/Interaction/contactLists/unsortedPairs.hpp b/src/Interaction/contactLists/unsortedPairs.hpp
index e9434751..fd4f117d 100644
--- a/src/Interaction/contactLists/unsortedPairs.hpp
+++ b/src/Interaction/contactLists/unsortedPairs.hpp
@@ -41,7 +41,7 @@ public:
 
 	using memory_space 		= typename ExecutionSpace::memory_space;
 
-	using PairType 			= kPair<idType,idType>;
+	using PairType 			= Pair<idType,idType>;
 
 	using ContainerType 	= unorderedSet<PairType, ExecutionSpace>;
 
@@ -52,19 +52,19 @@ public:
 		ContainerType 		Container_;
 
 		INLINE_FUNCTION_HD
-		int32 size()const { return Container_.size(); }
+		uint32 size()const { return Container_.size(); }
 
 		INLINE_FUNCTION_HD
-		int32 loopCount()const { return Container_.capacity(); }
+		uint32 loopCount()const { return Container_.capacity(); }
 
 		INLINE_FUNCTION_HD
-		bool isValid(int32 idx)const { return Container_.valid_at(idx); }
+		bool isValid(uint32 idx)const { return Container_.valid_at(idx); }
 
 		INLINE_FUNCTION_HD
-		PairType getPair(int idx)const {	return Container_.key_at(idx); }
+		PairType getPair(uint32 idx)const {	return Container_.key_at(idx); }
 
 		INLINE_FUNCTION_HD
-		bool getPair(int32 idx, PairType& pair)const {
+		bool getPair(uint32 idx, PairType& pair)const {
 			if(Container_.valid_at(idx))	{
 				pair = Container_.key_at(idx);
 				return true;
@@ -84,7 +84,7 @@ public:
 	TypeInfoNV("unsorderedPairs");
 
 	// constructor
-	unsortedPairs(int32 capacity=1)
+	explicit unsortedPairs(uint32 capacity=1)
 	:
 		container_(capacity) // the minimum capacity would be 128 
 	{}
@@ -102,7 +102,7 @@ public:
 	
 	// - Device call
 	INLINE_FUNCTION_HD
-	int32 insert(idType i, idType j)const
+	uint32 insert(idType i, idType j)const
 	{
 		if(auto insertResult = container_.insert(PairType(i,j)); insertResult.failed())
 			return -1;
@@ -112,7 +112,7 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	int32 insert(const PairType& p)const
+	uint32 insert(const PairType& p)const
 	{
 		if(auto insertResult = container_.insert(p); insertResult.failed())
 			return -1;
@@ -125,7 +125,7 @@ public:
 	//   return the pair at index idx
 	//   perform no check for size and existance
 	INLINE_FUNCTION_HD
-	PairType getPair(int32 idx)const
+	PairType getPair(uint32 idx)const
 	{
 		return container_.key_at(idx);
 	}
@@ -133,7 +133,7 @@ public:
 	// - Device call
 	//   return the pair at index idx
 	INLINE_FUNCTION_HD
-	bool getPair(int32 idx, PairType& p)const
+	bool getPair(uint32 idx, PairType& p)const
 	{
 		if(container_.valid_at(idx))
 		{
@@ -148,7 +148,7 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	int32 find(const PairType & p)const
+	uint32 find(const PairType & p)const
 	{
 		if( auto idx = container_.find(p); 
 			idx != Kokkos::UnorderedMapInvalidIndex )
@@ -158,26 +158,26 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	bool isValid(int32 idx)const
+	bool isValid(uint32 idx)const
 	{
 		return container_.valid_at(idx);	
 	}
 
 
 	INLINE_FUNCTION_HD
-	int32 capacity() const
+	uint32 capacity() const
 	{
 		return container_.capacity();
 	}
 
-	int32 loopCount()const
+	uint32 loopCount()const
 	{
 		return container_.capacity();
 	}
 	
 	//use this when the value of size_ is updated
 	INLINE_FUNCTION_H
-	int32 size()const
+	uint32 size()const
 	{
 		return container_.size();
 	}
@@ -190,7 +190,7 @@ public:
 	/// increase the capacity of the container by at-least len 
 	/// the content will be erased. 
 	INLINE_FUNCTION_H
-	void increaseCapacityBy(int32 len)
+	void increaseCapacityBy(uint32 len)
 	{
 		uint newCap = container_.capacity()+len;
 		this->clear();
diff --git a/src/Interaction/contactSearch/ContactSearch/ContactSearch.hpp b/src/Interaction/contactSearch/ContactSearch/ContactSearch.hpp
index d6428064..84fe8c95 100644
--- a/src/Interaction/contactSearch/ContactSearch/ContactSearch.hpp
+++ b/src/Interaction/contactSearch/ContactSearch/ContactSearch.hpp
@@ -22,16 +22,17 @@ Licence:
 #ifndef __ContactSearch_hpp__
 #define __ContactSearch_hpp__
 
-
+#include "contactSearchGlobals.hpp"
 #include "contactSearch.hpp"
 #include "box.hpp"
+#include "particles.hpp"
+#include "geometry.hpp"
 
 namespace pFlow
 {
 
 template<
-	template<class> class BaseMethod,
-	template<class> class WallMapping	
+	class searchMethod
 >
 class ContactSearch
 :
@@ -39,32 +40,19 @@ class ContactSearch
 {
 public:
 	
-	using IdType 			= typename contactSearch::IdType;
+	using IdType 			= uint32;
 
-	using IndexType 		= typename contactSearch::IndexType;
+	using ExecutionSpace 	= DefaultExecutionSpace;
 
-	using ExecutionSpace 	= typename contactSearch::ExecutionSpace;
+	using SearchMethodType = searchMethod;
 
-	using PairContainerType = typename contactSearch::PairContainerType;
-
-	using ParticleContactSearchType = 
-		BaseMethod<
-			ExecutionSpace>;
-
-	using WallMappingType =
-		WallMapping<
-			ExecutionSpace>;
-
-protected:
+private:
 	
-
-	uniquePtr<ParticleContactSearchType> particleContactSearch_ = nullptr;
-
-	uniquePtr<WallMappingType> 			 wallMapping_ = nullptr;
+	uniquePtr<SearchMethodType> 	ppwContactSearch_ = nullptr;
 
 public:
 
-	TypeInfoTemplate2("ContactSearch", ParticleContactSearchType, WallMappingType);
+	TypeInfoTemplate11("ContactSearch", SearchMethodType);
 
 	ContactSearch(
 		const dictionary& csDict,
@@ -74,54 +62,41 @@ public:
 	 	Timers& timers)
 	:
 		contactSearch(csDict, domain, prtcl, geom, timers)
-		
 	{
 
 		auto method = dict().getVal<word>("method");
-		auto wmMethod = dict().getVal<word>("wallMapping");
-		
+				
 		auto nbDict = dict().subDict(method+"Info");
 
 		real minD, maxD;
 		this->Particles().boundingSphereMinMax(minD, maxD);
 		
-		const auto& position = this->Particles().pointPosition().deviceVectorAll();
-		const auto& diam = this->Particles().boundingSphere().deviceVectorAll();
+		const auto& position = this->Particles().pointPosition().deviceViewAll();
+		const auto& flags = this->Particles().dynPointStruct().activePointsMaskDevice();
+		const auto& diam = this->Particles().boundingSphere().deviceViewAll();
 
-		particleContactSearch_ = 
-			makeUnique<ParticleContactSearchType>
+		uint32 wnPoints = this->Geometry().numPoints();
+		uint32 wnTri    = this->Geometry().size();
+		const auto& wPoints = this->Geometry().points().deviceViewAll();
+		const auto& wVertices = this->Geometry().vertices().deviceViewAll();
+
+		ppwContactSearch_ = 
+			makeUnique<SearchMethodType>
 			(
 				nbDict,
-				this->domain(),
+				this->domainBox(),
 				minD,
 				maxD,
 				position,
-				diam
-			);
-		REPORT(2)<<"Contact search algorithm for particle-particle is "<<
-				 greenText(particleContactSearch_().typeName())<<endREPORT;
-
-
-		auto wmDict = dict().subDict(wmMethod+"Info");
-
-		int32 wnPoints = this->Geometry().numPoints();
-		int32 wnTri    = this->Geometry().size();
-
-		const auto& wPoints = this->Geometry().points().deviceVectorAll();
-		const auto& wVertices = this->Geometry().vertices().deviceVectorAll();
-
-		wallMapping_ = 
-			makeUnique<WallMappingType>(
-				wmDict,
-				particleContactSearch_().numLevels(),
-				particleContactSearch_().getCellsLevels(),
+				flags,
+				diam,
 				wnPoints,
-				wnTri, 
+				wnTri,
 				wPoints,
 				wVertices
-				);
-		REPORT(2)<<"Wall mapping algorithm for particle-wall is "<<
-				 greenText(wallMapping_().typeName())<< endREPORT;
+			);
+		REPORT(2)<<"Contact search algorithm for particle-particle is "<<
+				 Green_Text(ppwContactSearch_().typeName())<<END_REPORT;
 
 	}
 
@@ -130,116 +105,60 @@ public:
 		contactSearch,
 		ContactSearch,
 		dictionary);
+
 	
 	bool broadSearch(
-		PairContainerType& ppPairs,
-		PairContainerType& pwPairs,
+		uint32 iter,
+		real t,
+		real dt,
+		csPairContainerType& ppPairs,
+		csPairContainerType& pwPairs,
 		bool force = false) override
 	{
 
+		ppTimer().start();
+
+		const auto& position = Particles().pointPosition().deviceViewAll();
+		const auto& flags = Particles().dynPointStruct().activePointsMaskDevice();
+		const auto& diam = Particles().boundingSphere().deviceViewAll();
 		
-		if(particleContactSearch_)
+		
+		if( !ppwContactSearch_().broadSearch(
+			iter,
+			t,
+			dt,
+			ppPairs, 
+			pwPairs,
+			position, 
+			flags, 
+			diam,
+			force) )
 		{
-			auto activeRange = this->Particles().activeRange();
-
-			sphereSphereTimer_.start();
-
-			if(this->Particles().allActive())
-			{		
-				particleContactSearch_().broadSearch(ppPairs, activeRange, force);
-			}
-			else
-			{		
-				particleContactSearch_().broadSearch(ppPairs, activeRange, this->Particles().activePointsMaskD(), force);
-			}
-
-			sphereSphereTimer_.end();
-
-		}
-		else
+			fatalErrorInFunction;
 			return false;
-		
-		if(wallMapping_)
-		{
-			sphereWallTimer_.start();
-			wallMapping_().broadSearch(pwPairs, particleContactSearch_(), force);
-			sphereWallTimer_.end();
 		}
-		else
-			return false;
+		ppTimer().end();
 
-		
-		
+				
+	
 		return true;
 	}
 
 
-	bool ppEnterBroadSearch()const override
+	bool enterBroadSearch(uint32 iter, real t, real dt)const override
 	{
-		if(particleContactSearch_)
+		if(ppwContactSearch_)
 		{
-			return particleContactSearch_().enterBoadSearch(); 
+			return ppwContactSearch_().performSearch(iter); 
 		}
 		return false;
 	}
 
-	bool pwEnterBroadSearch()const override
+	bool performedBroadSearch()const override
 	{
-		if(wallMapping_)
-		{
-			return wallMapping_().enterBoadSearch();
-		}
-		return false;
+		return ppwContactSearch_().performedSearch();
 	}
 	
-
-	bool ppPerformedBroadSearch()const override
-	{
-		if(particleContactSearch_)
-		{
-			return particleContactSearch_().performedSearch();
-		}
-		return false;
-	}
-
-	
-	bool pwPerformedBroadSearch()const override
-	{
-		if(wallMapping_)
-		{
-			return wallMapping_().performedSearch();
-		}
-		return false;
-	}
-
-	/*bool update(const eventMessage& msg) 
-	{
-		if(msg.isSizeChanged() ) 
-		{
-			auto newSize = this->prtcl().size();
-			if(!particleContactSearch_().objectSizeChanged(newSize))
-			{
-				fatalErrorInFunction<<
-				"erro in changing the size for particleContactSearch_ \n";
-				return false;
-			}
-		}
-
-		if(msg.isCapacityChanged() ) 
-		{
-			auto newSize = this->prtcl().capacity();
-			if(!particleContactSearch_().objectSizeChanged(newSize))
-			{
-				fatalErrorInFunction<<
-				"erro in changing the capacity for particleContactSearch_ \n";
-				return false;
-			}
-		}	
-		
-		return true;
-	}*/
-	
-	
 };
 
 }
diff --git a/src/Interaction/contactSearch/ContactSearch/ContactSearchs.cpp b/src/Interaction/contactSearch/ContactSearch/ContactSearchs.cpp
index 043e9b78..61024220 100644
--- a/src/Interaction/contactSearch/ContactSearch/ContactSearchs.cpp
+++ b/src/Interaction/contactSearch/ContactSearch/ContactSearchs.cpp
@@ -20,11 +20,11 @@ Licence:
 
 #include "ContactSearch.hpp"
 
-#include "cellMapping.hpp"
+//#include "cellMapping.hpp"
 #include "NBS.hpp"
-#include "multiGridNBS.hpp"
-#include "multiGridMapping.hpp"
+//#include "multiGridNBS.hpp"
+//#include "multiGridMapping.hpp"
 
 
-template class pFlow::ContactSearch<pFlow::NBS, pFlow::cellMapping>;
-template class pFlow::ContactSearch<pFlow::multiGridNBS, pFlow::multiGridMapping>;
+template class pFlow::ContactSearch<pFlow::NBS>;
+//template class pFlow::ContactSearch<pFlow::multiGridNBS, pFlow::multiGridMapping>;
diff --git a/src/Interaction/contactSearch/contactSearch/contactSearch.cpp b/src/Interaction/contactSearch/contactSearch/contactSearch.cpp
index 17c1dbd3..5753d4a2 100644
--- a/src/Interaction/contactSearch/contactSearch/contactSearch.cpp
+++ b/src/Interaction/contactSearch/contactSearch/contactSearch.cpp
@@ -19,7 +19,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "contactSearch.hpp"
-
+#include "streams.hpp"
 
 
 pFlow::contactSearch::contactSearch(
@@ -29,11 +29,12 @@ pFlow::contactSearch::contactSearch(
  	const geometry& geom,
  	Timers& timers)
 :
-	interactionBase(prtcl, geom),
-	domain_(domain),
-	dict_(dict),
-	sphereSphereTimer_("particle-particle contact search", &timers),
-	sphereWallTimer_("particle-wall contact search", &timers)
+	domainBox_(domain),
+	particles_(prtcl),
+	geometry_(geom),
+	ppTimer_("particle-particle contact search", &timers),
+	pwTimer_("particle-wall contact search", &timers),
+	dict_(dict)
 {
 
 }
@@ -46,20 +47,16 @@ pFlow::uniquePtr<pFlow::contactSearch> pFlow::contactSearch::create(
  	const geometry& geom,
  	Timers& timers)
 {
+	word baseMethName	= dict.getVal<word>("method");	
 
-	word baseMethName	= dict.getVal<word>("method");
-	word wallMethod 	= dict.getVal<word>("wallMapping");
+	auto model = angleBracketsNames("ContactSearch", baseMethName);
 
-	auto model = angleBracketsNames2("ContactSearch", baseMethName, wallMethod);
-
-
-	REPORT(1)<<"Selecting contact search model . . ."<<endREPORT;
+	REPORT(1)<<"Selecting contact search model . . ."<<END_REPORT;
 	
-
 	if( dictionaryvCtorSelector_.search(model))
 	{
 		auto objPtr = dictionaryvCtorSelector_[model] (dict, domain, prtcl, geom, timers);
-		REPORT(2)<<"Model "<< greenText(model)<<" is created."<<endREPORT;
+		REPORT(2)<<"Model "<< Green_Text(model)<<" is created."<< END_REPORT;
 		return objPtr;
 	}
 	else
diff --git a/src/Interaction/contactSearch/contactSearch/contactSearch.hpp b/src/Interaction/contactSearch/contactSearch/contactSearch.hpp
index 7725f7e6..30f264f3 100644
--- a/src/Interaction/contactSearch/contactSearch/contactSearch.hpp
+++ b/src/Interaction/contactSearch/contactSearch/contactSearch.hpp
@@ -23,43 +23,36 @@ Licence:
 #define __contactSearch_hpp__
 
 
-#include "interactionBase.hpp"
-#include "unsortedPairs.hpp"
-#include "box.hpp"
+#include "contactSearchGlobals.hpp"
 #include "dictionary.hpp"
+#include "virtualConstructor.hpp"
+#include "Timer.hpp"
 
 namespace pFlow
 {
 
+// - forward 
+class box;
+class particles;
+class geometry;
+
 
 class contactSearch
-:
-	public interactionBase
 {
-public:
-	using IdType 			= typename interactionBase::IdType;
+private:
 
-	using IndexType 		= typename interactionBase::IndexType;
+	const box& 	domainBox_;
 
-	using ExecutionSpace 	= typename interactionBase::ExecutionSpace;
+	const particles& 		particles_;
 
-	using PairContainerType   = unsortedPairs<ExecutionSpace, IdType>;
+	const geometry&			geometry_;
 
-protected:
+	Timer 		ppTimer_;
 
-	const box& 			domain_;
+	Timer 		pwTimer_;
 
 	dictionary 	dict_;
 
-	Timer 		sphereSphereTimer_;
-
-	Timer 		sphereWallTimer_;
-
-	auto& dict()
-	{
-		return dict_;
-	}
-	
 public:
 
 	TypeInfo("contactSearch");
@@ -88,35 +81,51 @@ public:
 	 	(dict, domain, prtcl, geom, timers)
 	);
 
-	const auto& domain()const
-	{
-		return domain_;
-	}
-
+	
 	const auto& dict()const
 	{
 		return dict_;
 	}
 
+	const auto& domainBox()const
+	{
+		return domainBox_;
+	}
+
+	const auto& Particles()const
+	{
+		return particles_;
+	}
+
+	const auto& Geometry()const
+	{
+		return geometry_;
+	}
+
+	auto& ppTimer()
+	{
+		return ppTimer_;
+	}
+
+	auto& pwTimer()
+	{
+		return pwTimer_;
+	}
 
 	virtual 
 	bool broadSearch(
-		PairContainerType& ppPairs,
-		PairContainerType& pwPairs,
+		uint32 iter,
+		real t,
+		real dt,
+		csPairContainerType& ppPairs,
+		csPairContainerType& pwPairs,
 		bool force = false) = 0;
 
 	virtual 
-	bool ppEnterBroadSearch()const = 0;
+	bool enterBroadSearch(uint32 iter, real t, real dt)const = 0;
 
 	virtual 
-	bool pwEnterBroadSearch()const = 0;
-
-	virtual 
-	bool ppPerformedBroadSearch()const = 0;
-
-	virtual 
-	bool pwPerformedBroadSearch()const = 0;
-	
+	bool performedBroadSearch()const = 0;
 
 	static 
 	uniquePtr<contactSearch> create(
diff --git a/src/Interaction/contactSearch/contactSearchFunctions.hpp b/src/Interaction/contactSearch/contactSearchFunctions.hpp
index 55879c95..96ee9596 100644
--- a/src/Interaction/contactSearch/contactSearchFunctions.hpp
+++ b/src/Interaction/contactSearch/contactSearchFunctions.hpp
@@ -96,17 +96,6 @@ void indexToCell(const indexType idx, const iBox<cellIndexType>& box, triple<cel
 	cell+= box.minPoint();
 }
 
-
-
-
-
-
-INLINE_FUNCTION_HD
-bool sphereSphereCheck(const realx3& p1, const realx3 p2, real d1, real d2)
-{
-	return length(p2-p1) < 0.5*(d2+d1);
-}
-
 }
 
 #endif //__broadSearchFunctions_hpp__
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/triangleFunctions.hpp b/src/Interaction/contactSearch/contactSearchGlobals.hpp
similarity index 76%
rename from src/phasicFlow/structuredData/trisurfaceStructure/triangleFunctions.hpp
rename to src/Interaction/contactSearch/contactSearchGlobals.hpp
index a78e555c..056ffbf8 100644
--- a/src/phasicFlow/structuredData/trisurfaceStructure/triangleFunctions.hpp
+++ b/src/Interaction/contactSearch/contactSearchGlobals.hpp
@@ -18,22 +18,21 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __triangleFunctions_hpp__
-#define __triangleFunctions_hpp__
-
 #include "types.hpp"
+#include "unsortedPairs.hpp"
 
-namespace pFlow::triangleFunctions
+#ifndef __contactSearchGlobals_hpp__
+#define __contactSearchGlobals_hpp__
+
+namespace pFlow
 {
 
-INLINE_FUNCTION_HD
-real triangleSurface( const realx3& p1, const realx3& p2, const realx3& p3)
-{
-	realx3 V1 = p2 - p1;
-	realx3 V2 = p3 - p1;
-	return abs((cross(V1,V2)).length() / static_cast<real>(2.0));	
-}
+using csExecutionSpace = DefaultExecutionSpace;
+
+using csIdType = uint32;
+
+using csPairContainerType   = unsortedPairs<DefaultExecutionSpace, uint32>;
 
 }
 
-#endif 
+#endif
diff --git a/src/Interaction/contactSearch/methods/NBS.hpp b/src/Interaction/contactSearch/methods/NBS.hpp
deleted file mode 100644
index fb3cc4f8..00000000
--- a/src/Interaction/contactSearch/methods/NBS.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-/*------------------------------- phasicFlow ---------------------------------
-      O        C enter of
-     O O       E ngineering and
-    O   O      M ultiscale modeling of
-   OOOOOOO     F luid flow       
-------------------------------------------------------------------------------
-  Copyright (C): www.cemf.ir
-  email: hamid.r.norouzi AT gmail.com
-------------------------------------------------------------------------------  
-Licence:
-  This file is part of phasicFlow code. It is a free software for simulating 
-  granular and multiphase flows. You can redistribute it and/or modify it under
-  the terms of GNU General Public License v3 or any other later versions. 
- 
-  phasicFlow is distributed to help others in their research in the field of 
-  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
------------------------------------------------------------------------------*/
-
-
-#ifndef __NBS_hpp__
-#define __NBS_hpp__
-
-#include "NBSLevel0.hpp"
-
-namespace pFlow
-{
-
-
-template<typename executionSpace>
-class NBS
-{
-public:
-
-	using NBSLevel0Type	= NBSLevel0<executionSpace>;
-
-	using cellIterator 	= typename NBSLevel0Type::cellIterator;
-
-	using IdType 		= typename NBSLevel0Type::IdType;
-	
-	using IndexType 	= typename NBSLevel0Type::IndexType;
-
-	using Cells 		= typename NBSLevel0Type::Cells;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space 	= typename NBSLevel0Type::execution_space;
-
-	using memory_space 		= typename NBSLevel0Type::memory_space;
-
-
-protected:
-
-	real 		sizeRatio_ = 1.0;
-
-	int32 		updateFrequency_= 1;
-
-	int32 		currentIter_ 	= 0;
-
-	bool 		performedSearch_ = false;
-
-	NBSLevel0Type NBSLevel0_;
-
-private:
-
-	bool performSearch()
-	{
-		if(currentIter_ % updateFrequency_ == 0)
-		{
-			currentIter_++;
-			return true;
-
-		}else
-		{
-			currentIter_++;
-			return false;
-		}
-	}
-
-public:
-
-	TypeInfoNV("NBS");
-
-		NBS(
-			const dictionary& dict,
-			const 	box& domain,
-			real  minSize,
-			real 	maxSize,
-			const 	ViewType1D<realx3, memory_space>& position,
-			const 	ViewType1D<real, memory_space>& diam)
-		:
-			sizeRatio_( 
-				max(
-					dict.getValOrSet<real>("sizeRatio", 1.0),
-					1.0
-					)),
-			updateFrequency_(
-				max( 
-					dict.getValOrSet<int32>("updateFrequency", 1),
-					1
-					)),
-			NBSLevel0_(
-				domain, 
-				maxSize*sizeRatio_,
-				sizeRatio_,
-				position,
-				diam)
-		{}
-			
-		INLINE_FUNCTION_HD
-		NBS(const NBS&) = default;
-
-		INLINE_FUNCTION_HD
-		NBS& operator = (const NBS&) = default;
-
-		INLINE_FUNCTION_HD
-		~NBS()=default;
-
-	//// - Methods 
-
-	bool enterBoadSearch()const
-	{
-		return currentIter_%updateFrequency_==0;
-	}
-
-	bool performedSearch()const
-	{
-		return performedSearch_;
-	}
-
-	Vector<cellIterator> getCellIteratorLevels()
-	{
-		return Vector<cellIterator>("cellIterator", 1, NBSLevel0_.getCellIterator());
-	}
-
-	auto getCellIterator(int32 lvl)const
-	{
-		return NBSLevel0_.getCellIterator();
-	}
-
-	int32 numLevels()const
-	{
-		return 1;
-	}
-
-	Vector<Cells> getCellsLevels()const
-	{
-		return Vector<Cells>("Cells", 1, NBSLevel0_.getCells());
-	}
-
-	auto getCells()const
-	{
-		return NBSLevel0_.getCells();
-	}
-
-	bool objectSizeChanged(int32 newSize)
-	{
-		NBSLevel0_.checkAllocateNext(newSize);
-		return true;
-	}
-
-	// - Perform the broad search to find pairs
-	//	 with force = true, perform broad search regardless of 
-	//   updateFrequency_ value
-	//   on all the points in the range of [0,numPoints_)
-	template<typename PairsContainer>
-	bool broadSearch(PairsContainer& pairs, range activeRange, bool force=false)
-	{
-		
-		if(force) currentIter_ = 0;
-		performedSearch_ = false;
-
-		if( !performSearch() ) return true;
-		
-		
-		NBSLevel0_.build(activeRange);
-		
-		NBSLevel0_.findPairs(pairs);
-		
-		performedSearch_ = true;		
-		return true;
-	}
-
-	// - Perform the broad search to find pairs,
-	//   ignore particles with incld(i) = true,
-	//	 with force = true, perform broad search regardless of 
-	//   updateFrequency_ value
-	template<typename PairsContainer, typename IncludeFunction>
-	bool broadSearch(PairsContainer& pairs, range activeRange, IncludeFunction incld, bool force = false)
-	{
-		if(force) currentIter_ = 0;
-		performedSearch_ = false;
-
-		if( !performSearch() ) return true;
-
-		NBSLevel0_.build(activeRange, incld);
-	
-		NBSLevel0_.findPairs(pairs);
-		
-		performedSearch_ = true;
-		return true;
-	}
-
-};
-
-}
-
-#endif
diff --git a/src/Interaction/contactSearch/methods/NBSCrossLoop.hpp b/src/Interaction/contactSearch/methods/NBSCrossLoop.hpp
deleted file mode 100644
index adce7409..00000000
--- a/src/Interaction/contactSearch/methods/NBSCrossLoop.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/*------------------------------- 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.
-
------------------------------------------------------------------------------*/
-
-
-int32 m = this->head_(i,j,k);
-CellType currentCell(i,j,k);
-int32 n = -1;
-
-while( m > -1 )
-{
-	
-	auto p_m = this->pointPosition_[m];	
-	auto d_m = this->sizeRatio_* this->diameter_[m];
-	
-	int32x3 crossIndex = mapIndexLevels(
-		int32x3(i,j,k),
-		level_, 
-		upperLevel.level());
-
-	
-	for(int32 ii = -1; ii<2; ii++)
-	{
-		for(int32 jj=-1; jj<2; jj++)
-		{
-			int32 kk=-1;
-			while( kk < 2)
-			{
-				int32x3 nghbrCI = crossIndex + int32x3(ii,jj,kk);
-				
-				if( upperLevel.isInRange(nghbrCI) )
-				{
-					n = upperLevel.head_(
-						nghbrCI.x(),
-						nghbrCI.y(),
-						nghbrCI.z());
-
-					while( n >-1)
-					{
-						auto p_n = this->pointPosition_[n];
-						auto d_n = this->sizeRatio_*this->diameter_[n];
-
-						if( sphereSphereCheck(p_m, p_n, d_m, d_n) )
-						{
-							auto ln = n;
-							auto lm = m;
-							if(lm>ln) this->Swap(lm,ln);
-							if( auto res = pairs.insert(lm,ln); res <0)
-							{
-								getFullUpdate++;
-							}
-						}
-
-						n = this->next_[n];
-					}
-
-				}
-
-				kk++;
-			}
-		}
-	}
-
-	m = this->next_[m];
-}
-
diff --git a/src/Interaction/contactSearch/methods/NBSLevel.hpp b/src/Interaction/contactSearch/methods/NBSLevel.hpp
deleted file mode 100644
index f355d566..00000000
--- a/src/Interaction/contactSearch/methods/NBSLevel.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#ifndef __NBSLevel_hpp__
-#define __NBSLevel_hpp__
-
-
-#include "NBSLevel0.hpp"
-
-
-namespace pFlow
-{
-
-INLINE_FUNCTION_HD
-int32x3 mapIndexLevels(const int32x3& ind, int32 lowerLevel, int32 upperLevel);
-
-template<typename executionSpace>
-class
-NBSLevel
-:
-	public NBSLevel0<executionSpace>
-{
-public:
-
-	using NBSLevel0Type	= NBSLevel0<executionSpace>;
-
-	using cellIterator 	= typename NBSLevel0Type::cellIterator;
-
-	using IdType 		= typename NBSLevel0Type::IdType;
-	
-	using IndexType 	= typename NBSLevel0Type::IndexType;
-
-	using Cells 		= typename NBSLevel0Type::Cells;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space 	= typename NBSLevel0Type::execution_space;
-
-	using memory_space 		= typename NBSLevel0Type::memory_space;
-
-	using mdrPolicyFindPairs = typename NBSLevel0Type::mdrPolicyFindPairs;
-
-	using HeadType 			= typename NBSLevel0Type::HeadType;
-
-	using NextType 			= typename NBSLevel0Type::NextType;
-
-	template<typename exeSpace>
-	friend class NBSLevels;
-
-protected:
-
-	int32 									level_ = 0;
-
-	
-public:
-	
-	TypeInfoNV("NBSLevel0");
-
-	INLINE_FUNCTION_HD
-	NBSLevel(){}
-
-	NBSLevel(
-		int32 	lvl,
-		const 	box& domain,
-		real 	cellSize,
-		real 	sizeRatio,
-		const 	ViewType1D<realx3, memory_space>& position,
-		const 	ViewType1D<real, memory_space>& diam)
-	:
-		NBSLevel0Type(
-			domain,
-			cellSize,
-			sizeRatio,
-			position,
-			diam,
-			lvl==0),
-		level_(lvl)
-	{}
-
-	INLINE_FUNCTION_HD
-	NBSLevel(const NBSLevel&) = default;
-	
-	INLINE_FUNCTION_HD
-	NBSLevel& operator = (const NBSLevel&) = default;
-
-	INLINE_FUNCTION_HD
-	~NBSLevel() = default;
-
-	INLINE_FUNCTION_HD
-	auto level()const
-	{
-		return level_;
-	}
-
-	template<typename PairsContainer>	
-	INLINE_FUNCTION_H
-	int32 findPairsCountCross(PairsContainer& pairs, NBSLevel& upperLevel)
-	{
-
-		mdrPolicyFindPairs
-			mdrPolicy(
-				{0,0,0},
-				{this->nx(),this->ny(),this->nz()} );
-
-		int32 notInsertedPairs;
-
-		Kokkos::parallel_reduce	(
-			"NBSLevel::findPairsCountCross",
-			mdrPolicy,
-			CLASS_LAMBDA_HD(int32 i, int32 j, int32 k, int32& getFullUpdate){
-				#include "NBSCrossLoop.hpp"
-			}, notInsertedPairs);
-			
-		return notInsertedPairs;	
-	}
-	 
-	
-};
-
-INLINE_FUNCTION_HD
-int32x3 mapIndexLevels( const int32x3& ind, int32 lowerLevel, int32 upperLevel)
-{
-	int32 a = pow(2, static_cast<int32>(upperLevel-lowerLevel));
-	return ind/a;
-}
-
-
-}
-
-#endif
diff --git a/src/Interaction/contactSearch/methods/NBSLevel0.hpp b/src/Interaction/contactSearch/methods/NBSLevel0.hpp
deleted file mode 100644
index d9ae2f83..00000000
--- a/src/Interaction/contactSearch/methods/NBSLevel0.hpp
+++ /dev/null
@@ -1,240 +0,0 @@
-/*------------------------------- 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 __NBSLevel0_hpp__
-#define __NBSLevel0_hpp__
-
-#include "mapperNBS.hpp"
-
-namespace pFlow
-{
-
-
-template<typename executionSpace>
-class NBSLevel0
-:
-	public mapperNBS<executionSpace>
-{
-public:
-
-	using MapperType 		= mapperNBS<executionSpace>;
-
-	using cellIterator  	= typename MapperType::cellIterator;
-
-	using IdType 			= typename MapperType::IdType;
-	
-	using IndexType 		= typename MapperType::IndexType;
-
-	using Cells 			= typename MapperType::Cells;
-
-	using CellType 			= typename Cells::CellType;
-
-	using execution_space 	= typename MapperType::execution_space;
-
-	using memory_space 		= typename MapperType::memory_space;
-
-	using HeadType 			= typename MapperType::HeadType;
-
-	using NextType 			= typename MapperType::NextType;	
-
-	struct TagFindPairs{};
-
-
-protected:
-
-	real 			sizeRatio_ 		= 1.0;
-
-	// borrowed ownership
-	ViewType1D<real, memory_space>			diameter_;
-
-
-	using mdrPolicyFindPairs = 
-		Kokkos::MDRangePolicy<
-			Kokkos::Rank<3>,
-			Kokkos::Schedule<Kokkos::Dynamic>,
-			execution_space>;
-
-	static INLINE_FUNCTION_HD
-	void Swap(int32& x, int32& y)
-	{
-		int32 tmp = x;
-		x = y;
-		y = tmp;
-	}
-
-public:
-
-	TypeInfoNV("NBSLevel0");
-
-		INLINE_FUNCTION_HD
-		NBSLevel0(){}
-
-		NBSLevel0(
-			const 	box& domain,
-			real 		cellSize,
-			const 	ViewType1D<realx3, memory_space>& position,
-			const 	ViewType1D<real, memory_space>& diam)
-		:
-			MapperType(domain, cellSize, position),
-			diameter_(diam)
-		{}
-
-		NBSLevel0(
-			const 	box& domain,
-			int32 	nx,
-			int32 	ny,
-			int32 	nz,
-			const 	ViewType1D<realx3, memory_space>& position,
-			const 	ViewType1D<real, memory_space>& diam)
-		:
-			MapperType(domain, nx, ny, nz, position),
-			diameter_(diam)
-		{	}
-
-		NBSLevel0(
-			const 	box& domain,
-			real 		cellSize,
-			real 		sizeRatio,
-			const 	ViewType1D<realx3, memory_space>& position,
-			const 	ViewType1D<real, memory_space>& diam,
-			bool 		nextOwner = true)
-		:
-			MapperType(domain, cellSize, position, nextOwner),
-			sizeRatio_(sizeRatio),
-			diameter_(diam)
-		{}
-
-		INLINE_FUNCTION_HD
-		NBSLevel0(const NBSLevel0&) = default;
-
-		INLINE_FUNCTION_HD
-		NBSLevel0& operator = (const NBSLevel0&) = default;
-
-		INLINE_FUNCTION_HD
-		~NBSLevel0()=default;
-
-
-	INLINE_FUNCTION_HD
-	auto sizeRatio()const
-	{
-		return sizeRatio_;
-	}
-
-	INLINE_FUNCTION_HD
-	auto& diameter()
-	{
-		return diameter_;
-	}
-
-	// - Perform the broad search to find pairs
-	//	 with force = true, perform broad search regardless of 
-	//   updateFrequency_ value
-	//   on all the points in the range of [0,numPoints_)
-	template<typename PairsContainer>
-	bool broadSearch(PairsContainer& pairs, range activeRange)
-	{
-		
-		
-		this->build(activeRange);
-		
-		findPairs(pairs);
-			
-		return true;
-	}
-
-	// - Perform the broad search to find pairs,
-	//   ignore particles with incld(i) = true,
-	//	 with force = true, perform broad search regardless of 
-	//   updateFrequency_ value
-	template<typename PairsContainer, typename IncludeFunction>
-	bool broadSearch(PairsContainer& pairs, range activeRange, IncludeFunction incld)
-	{
-		
-		this->build(activeRange, incld);
-	
-		findPairs(pairs);
-		
-		return true;
-	}
-
-	template<typename PairsContainer>	
-	INLINE_FUNCTION_H
-	bool findPairs(PairsContainer& pairs)
-	{
-		
-
-		int32 getFull = 1;
-		
-		
-		// loop until the container size fits the numebr of contact pairs
-		while (getFull > 0)
-		{
-
-			getFull = findPairsCount(pairs);		
-		
-			if(getFull)
-			{
-				// - resize the container
-				//   note that getFull now shows the number of failed insertions.
-				uint32 len = max(getFull,500) ;
-				
-				auto oldCap = pairs.capacity();
-				
-				pairs.increaseCapacityBy(len);
-
-				INFORMATION<< "The contact pair container capacity increased from "<<
-				oldCap << " to "<<pairs.capacity()<<" in NBSLevel0."<<endINFO;
-				
-			}
-
-			Kokkos::fence();
-		}
-		
-		return true;
-	}
-
-	template<typename PairsContainer>	
-	INLINE_FUNCTION_H
-	int32 findPairsCount(PairsContainer& pairs)
-	{
-		mdrPolicyFindPairs
-			mdrPolicy(
-				{0,0,0},
-				{this->nx(),this->ny(),this->nz()} );
-
-		int32 notInsertedPairs;
-			
-		Kokkos::parallel_reduce	(
-			"NBSLevel0::findPairs",
-			mdrPolicy,
-			CLASS_LAMBDA_HD(int32 i, int32 j, int32 k, int32& getFullUpdate){
-				#include "NBSLoop.hpp"
-			}, notInsertedPairs);
-			
-		return notInsertedPairs;
-			
-	}
-
-};
-
-} // pFlow
-
-#endif // __NBSLevel0_hpp__
diff --git a/src/Interaction/contactSearch/methods/NBSLevels.hpp b/src/Interaction/contactSearch/methods/NBSLevels.hpp
deleted file mode 100644
index 30603bd3..00000000
--- a/src/Interaction/contactSearch/methods/NBSLevels.hpp
+++ /dev/null
@@ -1,438 +0,0 @@
-#ifndef __NBSLevels_hpp__
-#define __NBSLevels_hpp__
-
-#include "NBSLevel.hpp"
-#include "NBSLevel0.hpp"
-#include "KokkosTypes.hpp"
-
-namespace pFlow
-{
-
-template<typename executionSpace>
-class NBSLevels
-{
-
-public:
-
-	using NBSLevelType 	= NBSLevel<executionSpace>;
-
-	using cellIterator 	= typename NBSLevelType::cellIterator;
-
-	using IdType 		= typename NBSLevelType::IdType;
-	
-	using IndexType 	= typename NBSLevelType::IndexType;
-
-	using Cells 		= typename NBSLevelType::Cells;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space 	= typename NBSLevelType::execution_space;
-
-	using memory_space 		= typename NBSLevelType::memory_space;
-
-	using realRange 	= kPair<real,real>;
-
-protected:
-	
-	real 		minSize_;
-
-	real 		maxSize_;
-	
-	int32 		numLevels_=1;
-
-	Vector<NBSLevelType> 					nbsLevels_;
-
-	ViewType1D<realRange, memory_space> 	sizeRangeLevels_;
-
-	ViewType1D<realRange, HostSpace> 		sizeRangeLevelsHost_;
-
-	ViewType1D<real, memory_space> 			maxSizeLevels_;
-
-	ViewType1D<real, HostSpace> 			maxSizeLevelsHost_;
-
-	ViewType1D<int8, memory_space> 			particleLevel_;
-
-	range 									activeRange_{0,0};
-
-	using rangePolicyType	=
-		Kokkos::RangePolicy<
-			Kokkos::IndexType<int32>,
-			Kokkos::Schedule<Kokkos::Static>,
-			execution_space>;
-
-	int32 setNumLevels()
-	{
-
-		int32 maxOvermin = static_cast<int32>(maxSize_/minSize_);
-
-		if (maxOvermin <=1)
-			return 1;
-		else if(maxOvermin<=3)
-			return 2;
-		else if(maxOvermin<=7)
-			return 3;
-		else if(maxOvermin<15)
-			return 4;
-		else if(maxOvermin<31)
-			return 5;
-		else if(maxOvermin<63)
-			return 6;
-		else if(maxOvermin <127)
-			return 7;
-		else
-		{
-			fatalErrorInFunction<<
-			"size ratio is not valid for multi-grid NBS "<< maxOvermin<<endl;
-			fatalExit;
-		}
-
-		return -1;
-	}
-
-	bool setDiameterRange(real sizeRatio)
-	{
-		real lvl_maxD  = sizeRatio* maxSize_;
-		real lvl_minD  = lvl_maxD/2.0;		
-
-		for(int32 lvl=numLevels_-1; lvl>=0; lvl--)
-		{
-
-			if(lvl == 0 ) lvl_minD = 0.01*minSize_;
-			
-			sizeRangeLevelsHost_[lvl] = {lvl_minD, lvl_maxD};
-			maxSizeLevelsHost_[lvl] = lvl_maxD;
-			lvl_maxD = lvl_minD;
-			lvl_minD /= 2.0;
-		}
-		
-		copy(sizeRangeLevels_, sizeRangeLevelsHost_);
-		copy(maxSizeLevels_, maxSizeLevelsHost_);
-
-		REPORT(2)<<"Grids with "<< yellowText(numLevels_)<< " levels have been created."<<endREPORT;
-		for(int32 lvl=0; lvl<numLevels_; lvl++)
-		{
-			REPORT(3)<<"Cell gird No "<< yellowText(lvl)<<" with size range ("
-				<<sizeRangeLevelsHost_[lvl].first<<","<<sizeRangeLevelsHost_[lvl].second<<"]."<<endREPORT;
-		}
-		
-		return true;
-	}
-
-	bool initLevels(
-		const 	box& domain,
-		real 	sizeRatio,
-		const 	ViewType1D<realx3, memory_space>& position,
-		const 	ViewType1D<real, memory_space>& diam)
-	{
-		
-
-		for(int32 lvl = 0; lvl<numLevels_; lvl++)
-		{
-			nbsLevels_[lvl] = NBSLevelType(
-				lvl, 
-				domain, 
-				maxSizeLevelsHost_[lvl]*sizeRatio,
-				sizeRatio,
-				position,
-				diam );
-		}
-
-		auto next0 = nbsLevels_[0].next();
-		for(int32 lvl=1; lvl<numLevels_; lvl++)
-		{
-			nbsLevels_[lvl].setNext(next0);
-		}
-
-		return true;
-	}
-
-
-	void manageAllocateNext(range active)
-	{
-		activeRange_ = active;
-
-		if(activeRange_.second > nbsLevels_[0].capacity())
-		{
-			nbsLevels_[0].checkAllocateNext(activeRange_.second);
-
-			auto next0 = nbsLevels_[0].next();
-
-			for(int32 lvl=1; lvl<numLevels_; lvl++)
-			{
-				nbsLevels_[lvl].setNext(next0);
-			}
-		}
-	}
-
-	void nullify( range active)
-	{
-		for(int32 lvl=0; lvl<numLevels_; lvl++)
-		{
-			nbsLevels_[lvl].nullify(active);
-		}
-	}
-
-public:
-
-	NBSLevels(
-		const 	box& domain,
-		real 	minSize,
-		real 	maxSize,
-		real 	sizeRatio,
-		const 	ViewType1D<realx3, memory_space>& position,
-		const 	ViewType1D<real, memory_space>& diam)
-	:
-	minSize_(minSize),
-	maxSize_(maxSize),
-	numLevels_(setNumLevels()),
-	nbsLevels_("nbsLevels", numLevels_, numLevels_, RESERVE()),
-	sizeRangeLevels_("sizeRangeLevels", numLevels_),
-	sizeRangeLevelsHost_("sizeRangeLevelsHost", numLevels_),
-	maxSizeLevels_("maxSizeLevels", numLevels_),
-	maxSizeLevelsHost_("maxSizeLevelsHost", numLevels_)
-	{
-
-		setDiameterRange(sizeRatio);
-
-		initLevels(domain, sizeRatio, position, diam);
-	}
-
-	auto getCellIterator(int32 lvl)const
-	{
-		return nbsLevels_[lvl].getCellIterator();
-	}
-
-	int32 numLevels()const
-	{
-		return numLevels_;
-	}
-
-	Cells getCells(int32 lvl)const
-	{
-		return nbsLevels_[lvl].getCells();
-	}
-
-	template<typename PairsContainer>	
-	INLINE_FUNCTION_H
-	bool findPairs(PairsContainer& pairs)
-	{
-		
-		int32 getFull = 1;
-		
-		// loop until the container size fits the numebr of contact pairs
-		while (getFull > 0)
-		{
-
-			getFull = findPairsCount(pairs);		
-		
-			if(getFull)
-			{
-				// - resize the container
-				//   note that getFull now shows the number of failed insertions.
-				uint32 len = max(getFull,100) ;
-				
-				auto oldCap = pairs.capacity();
-				
-				pairs.increaseCapacityBy(len);
-
-				INFORMATION<< "The contact pair container capacity increased from "<<
-				oldCap << " to "<<pairs.capacity()<<" in NBSLevels."<<endINFO;
-				
-			}
-
-			Kokkos::fence();
-		}
-		
-		return true;
-	}
-
-
-	template<typename PairsContainer>	
-	INLINE_FUNCTION_H
-	int32 findPairsCount(PairsContainer& pairs)
-	{
-
-		int32 notInsertedCount = 0;
-
-		for(int32 lvl=0; lvl<numLevels_; lvl++)
-		{
-			
-			// the same level
-			notInsertedCount+= nbsLevels_[lvl].findPairsCount(pairs);
-			
-			for(int32 crsLvl = lvl+1; crsLvl<numLevels_; crsLvl++)
-			{
-				// cross levels 
-				notInsertedCount+= 
-					nbsLevels_[lvl].findPairsCountCross(pairs, nbsLevels_[crsLvl]);
-				
-			}
-		}
-		
-		return notInsertedCount;
-	}
-
-	INLINE_FUNCTION_H
-	void build(range activeRange)
-	{
-				
-		// nullify next and heads
-		findParticleLevel(activeRange.first, activeRange.second);
-		manageAllocateNext(activeRange);
-		nullify(activeRange);
-		
-		//
-
-		rangePolicyType rPolicy(activeRange.first, activeRange.second);
-		
-		auto nbsLevel0 = nbsLevels_[0];
-		auto pointPosition = nbsLevel0.pointPosition();
-		auto particleLevel = particleLevel_;
-		auto next = nbsLevel0.next();
-		auto head0 = nbsLevel0.head();
-		
-		typename NBSLevelType::HeadType head1, head2, head3, head4, head5, head6;
-
-		if(numLevels_>1) head1 = nbsLevels_[1].head();
-		if(numLevels_>2) head2 = nbsLevels_[2].head();
-		if(numLevels_>3) head3 = nbsLevels_[3].head();
-		if(numLevels_>4) head4 = nbsLevels_[4].head();
-		if(numLevels_>5) head5 = nbsLevels_[5].head();
-		if(numLevels_>6) head6 = nbsLevels_[6].head();
-
-
-		
-		Kokkos::parallel_for(
-			"NBSLevels::build",
-			rPolicy,
-			LAMBDA_HD(int32 i){
-				
-				int8 lvl = particleLevel[i];
-				auto ind = nbsLevel0.pointIndex(pointPosition[i]);
-				ind = mapIndexLevels(ind, 0, lvl);
-				int32 old;
-				if(lvl==0)
-					old =Kokkos::atomic_exchange(&head0(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==1)
-					old =Kokkos::atomic_exchange(&head1(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==2)
-					old =Kokkos::atomic_exchange(&head2(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==3)
-					old =Kokkos::atomic_exchange(&head3(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==4)
-					old =Kokkos::atomic_exchange(&head4(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==5)
-					old =Kokkos::atomic_exchange(&head5(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==6)
-					old =Kokkos::atomic_exchange(&head6(ind.x(), ind.y(), ind.z()),i);
-
-				next(i) = old;
-			});
-
-		Kokkos::fence();
-	}
-
-	template<typename IncludeFunction>
-	INLINE_FUNCTION_H
-	void build(range activeRange, IncludeFunction incld)
-	{
-		// nullify next and heads
-		findParticleLevel(activeRange.first, activeRange.second);
-		manageAllocateNext(activeRange);
-		nullify(activeRange);
-		
-
-		rangePolicyType rPolicy(activeRange.first, activeRange.second);
-
-		auto nbsLevel0 = nbsLevels_[0];
-		auto pointPosition = nbsLevel0.pointPosition();
-		auto particleLevel = particleLevel_;
-		auto next = nbsLevel0.next();
-		auto head0 = nbsLevel0.head();
-
-		typename NBSLevelType::HeadType head1, head2, head3, head4, head5, head6;
-
-		if(numLevels_>1) head1 = nbsLevels_[1].head();
-		if(numLevels_>2) head2 = nbsLevels_[2].head();
-		if(numLevels_>3) head3 = nbsLevels_[3].head();
-		if(numLevels_>4) head4 = nbsLevels_[4].head();
-		if(numLevels_>5) head5 = nbsLevels_[5].head();
-		if(numLevels_>6) head6 = nbsLevels_[6].head();
-
-		Kokkos::parallel_for(
-			"NBSLevels::build",
-			rPolicy,
-			LAMBDA_HD(int32 i){
-				if(!incld(i)) return;
-				
-				int8 lvl = particleLevel[i];
-				auto ind = nbsLevel0.pointIndex(pointPosition[i]);
-				
-				ind = mapIndexLevels(ind, 0, lvl);
-				int32 old;
-				if(lvl==0)
-					old =Kokkos::atomic_exchange(&head0(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==1)
-					old =Kokkos::atomic_exchange(&head1(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==2)
-					old =Kokkos::atomic_exchange(&head2(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==3)
-					old =Kokkos::atomic_exchange(&head3(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==4)
-					old =Kokkos::atomic_exchange(&head4(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==5)
-					old =Kokkos::atomic_exchange(&head5(ind.x(), ind.y(), ind.z()),i);
-				else if(lvl==6)
-					old =Kokkos::atomic_exchange(&head6(ind.x(), ind.y(), ind.z()),i);
-				
-				next(i) = old;
-				
-			});
-
-		Kokkos::fence();
-
-	}
-
-	bool findParticleLevel(int32 first, int32 last)
-	{
-
-		if(last > particleLevel_.size())
-		{
-			reallocNoInit(particleLevel_,last);
-		}
-
-		auto diameter  = nbsLevels_[0].diameter();
-		auto const maxSizes = maxSizeLevels_;
-		auto particleLevel = particleLevel_;
-		auto const sizeRatio = 0.999*nbsLevels_[0].sizeRatio();
-
-		int8 maxLvl = sizeRangeLevels_.size();
-
-		rangePolicyType rPolicy(first, last);
-
-		Kokkos::parallel_for(
-			"NBSLevels::findParticleLevel",
-			rPolicy,
-			LAMBDA_HD(int32 i)
-			{
-				for(int8 lvl = 0; lvl<maxLvl; lvl++)
-				{
-					if( sizeRatio*diameter[i]<= maxSizes[lvl] )
-					{
-						particleLevel[i] = lvl;
-						return;
-					}
-				}
-				particleLevel[i] = static_cast<int8>(-1);
-			});
-		Kokkos::fence();
-
-		return true;
-	}
-
-
-}; //NBSLevels
-
-}
-
-#endif
diff --git a/src/Interaction/contactSearch/methods/NBSLoop.hpp b/src/Interaction/contactSearch/methods/NBSLoop.hpp
deleted file mode 100644
index 8aed3e26..00000000
--- a/src/Interaction/contactSearch/methods/NBSLoop.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*------------------------------- 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.
-
------------------------------------------------------------------------------*/
-
-
-int32 m = this->head_(i,j,k);
-CellType currentCell(i,j,k);
-int32 n = -1;
-
-while( m > -1 )
-{
-	
-	auto p_m = this->pointPosition_[m];	
-	auto d_m = sizeRatio_* diameter_[m];
-	
-	// the same cell
-	n = this->next_(m);
-	
-	while(n >-1)
-	{
-		
-		auto p_n = this->pointPosition_[n];
-		auto d_n = sizeRatio_*diameter_[n];
-		
-		if( sphereSphereCheck(p_m, p_n, d_m, d_n) )
-		{
-			auto ln = n;
-			auto lm = m;
-
-			if(lm>ln) Swap(lm,ln);
-			if( auto res = pairs.insert(lm,ln); res <0)
-			{
-				getFullUpdate++;
-			}
-		}
-		
-		n = this->next_(n);
-	}
-
-	// neighbor cells
-	CellType neighborCell;
-	for(int32 ni=0; ni<13; ni++)
-	{
-		if(ni==0)		neighborCell = currentCell + CellType( 0, 0,-1);
-		else if(ni==1)	neighborCell = currentCell + CellType(-1, 0,-1);
-		else if(ni==2)	neighborCell = currentCell + CellType(-1, 0, 0); 
-		else if(ni==3)	neighborCell = currentCell + CellType(-1, 0, 1); 
-		else if(ni==4)	neighborCell = currentCell + CellType( 0,-1,-1); 
-		else if(ni==5)	neighborCell = currentCell + CellType( 0,-1, 0); 
-		else if(ni==6)	neighborCell = currentCell + CellType( 0,-1, 1); 
-		else if(ni==7)	neighborCell = currentCell + CellType(-1,-1,-1); 
-		else if(ni==8)	neighborCell = currentCell + CellType(-1,-1, 0); 
-		else if(ni==9)	neighborCell = currentCell + CellType(-1,-1, 1);
-		else if(ni==10)	neighborCell = currentCell + CellType( 1,-1,-1);  
-		else if(ni==11)	neighborCell = currentCell + CellType( 1,-1, 0);  
-		else if(ni==12)	neighborCell = currentCell + CellType( 1,-1, 1);  
-		 
-		if( this->isInRange(neighborCell) )
-		{
-			
-			n = this->head_(neighborCell.x(), neighborCell.y(), neighborCell.z());
-			while( n>-1)
-			{
-				
-				auto p_n = this->pointPosition_[n];
-				auto d_n = sizeRatio_*diameter_[n];
-				
-				if(sphereSphereCheck(p_m, p_n, d_m, d_n))
-				{
-					auto ln = n;
-					auto lm = m;
-					if(lm>ln) Swap(lm,ln);
-					if( auto res = pairs.insert(lm,ln); res <0)
-					{
-						getFullUpdate++;
-					}
-				}
-				n = this->next_[n];
-			}
-		}
-
-	}
-	m = this->next_[m];
-}
-
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/NBS.cpp b/src/Interaction/contactSearch/methods/cellBased/NBS/NBS.cpp
new file mode 100644
index 00000000..9c8b3a29
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/NBS.cpp
@@ -0,0 +1,67 @@
+/*------------------------------- 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 "NBS.hpp"
+
+pFlow::NBS::NBS
+(
+    const dictionary& dict,
+	const box& domainBox,
+	real  	minBSSize,
+	real 	maxBSSize,
+	const deviceViewType1D<realx3> &position, 
+	const pFlagTypeDevice &flags, 
+	const deviceViewType1D<real> &diam, 
+	uint32 					nWallPoints,
+	uint32 					nWallElements,
+	const ViewType1D<realx3,memory_space>& 		wallPoints, 
+	const ViewType1D<uint32x3,memory_space>& 	wallVertices
+)
+: 
+    particleWallContactSearchs<NBS>(
+        dict,
+        domainBox,
+        minBSSize,
+        maxBSSize,
+        position,
+        flags,
+        diam),
+    sizeRatio_(max(dict.getVal<real>("sizeRatio"), 1.0)),
+    cellExtent_(max(dict.getVal<real>("cellExtent"), 0.5)),
+    adjustableBox_(dict.getVal<Logical>("adjustableBox")),
+    NBSLevel0_
+	(
+        this->domainBox_,
+        maxBSSize,
+        sizeRatio_,
+        position,
+        flags,
+        adjustableBox_()
+	),
+	cellsWallLevel0_
+	(
+		cellExtent_,
+		nWallPoints,
+		nWallElements,
+		wallPoints,
+		wallVertices
+	)
+{
+}
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/NBS.hpp b/src/Interaction/contactSearch/methods/cellBased/NBS/NBS.hpp
new file mode 100644
index 00000000..f0f83436
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/NBS.hpp
@@ -0,0 +1,148 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+
+#ifndef __NBS_hpp__
+#define __NBS_hpp__
+
+#include "particleWallContactSearchs.hpp"
+#include "NBSLevel0.hpp"
+#include "cellsWallLevel0.hpp"
+#include "Vector.hpp"
+
+namespace pFlow
+{
+
+
+class NBS
+:
+	public particleWallContactSearchs<NBS>
+{
+public:
+
+	using CellIterator 	= typename NBSLevel0::CellIterator;
+
+private:
+	
+	real 		sizeRatio_ = 1.0;
+
+	real 		cellExtent_ = 0.5;
+
+	Logical 	adjustableBox_;
+
+	NBSLevel0 	NBSLevel0_;	
+
+	cellsWallLevel0 cellsWallLevel0_;
+
+protected:
+
+	friend 		particleWallContactSearchs<NBS>;
+	
+	bool impl_broadSearch
+	(
+		csPairContainerType& ppPairs,
+		csPairContainerType& pwPairs,
+		const deviceViewType1D<realx3>& pointPos,
+    	const pFlagTypeDevice& flags,
+    	const deviceViewType1D<real>& diameter
+	)
+	{
+		bool searchBoxChanged;
+		if( !NBSLevel0_.broadSearch(
+			ppPairs, 
+			pointPos, 
+			flags, 
+			diameter, 
+			searchBoxChanged))
+		{
+			fatalErrorInFunction<<
+			"Error in broadSearch for NBS (particle-particle)"<<endl;
+			return false;
+		}
+
+		if(!cellsWallLevel0_.broadSearch(
+			pwPairs,
+			NBSLevel0_.getSearchCells(),
+			NBSLevel0_.getCellIterator()))
+		{
+			fatalErrorInFunction<<
+			"Error in broadSearch for NBS (particle-wall)"<<endl;
+			return false;
+		}
+
+		return true;
+	}
+
+public:
+
+	TypeInfoNV("NBS");
+
+		NBS(
+			const dictionary& dict,
+			const box& domainBox,
+			real  	minBSSize,
+			real 	maxBSSize,
+			const deviceViewType1D<realx3> &position, 
+    		const pFlagTypeDevice &flags, 
+    		const deviceViewType1D<real> &diam, 
+			uint32 					nWallPoints,
+			uint32 					nWallElements,
+			const ViewType1D<realx3,memory_space>& 		wallPoints, 
+			const ViewType1D<uint32x3,memory_space>& 	wallVertices);
+		
+			
+		INLINE_FUNCTION_HD
+		NBS(const NBS&) = default;
+
+		INLINE_FUNCTION_HD
+		NBS(NBS&&) = default;
+
+		INLINE_FUNCTION_HD
+		NBS& operator = (const NBS&) = default;
+
+		INLINE_FUNCTION_HD
+		NBS& operator = (NBS&&) = default;
+
+		INLINE_FUNCTION_HD
+		~NBS()=default;
+
+
+	//// - Methods 
+
+		uint32 numLevels()const
+		{
+			return 1;
+		}
+
+		auto getCellIterator([[maybe_unused]] uint32 lvl)const
+		{
+			return NBSLevel0_.getCellIterator();
+		}
+
+		Vector<cells> getDomainCellsLevels()const
+		{
+			return Vector<cells>("Cells", 1, NBSLevel0_.getDomainCells());
+		}
+
+};
+
+}
+
+#endif
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0.cpp b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0.cpp
new file mode 100644
index 00000000..96e47917
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0.cpp
@@ -0,0 +1,118 @@
+/*------------------------------- 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 "NBSLevel0.hpp"
+#include "streams.hpp"
+
+bool pFlow::NBSLevel0::findPairs
+(
+	csPairContainerType &pairs, 
+	const deviceViewType1D<realx3> &pointPos, 
+	const pFlagTypeDevice &flags, 
+	const deviceViewType1D<real> &diameter
+)
+{
+	uint32 getFull = 1;
+	
+	// loop until the container size fits the numebr of contact pairs
+	while (getFull > 0)
+	{
+
+		getFull = pFlow::NBSLevel0Kernels::findPairsCount
+		(
+			pairs,
+			sizeRatio_,
+			pointPos,
+			flags,
+			diameter, 
+			getCellIterator()
+		);
+	
+		if(getFull)
+		{
+			// - resize the container
+			//   note that getFull now shows the number of failed insertions.
+			uint32 len = max(getFull,500u) ;
+			
+			auto oldCap = pairs.capacity();
+			
+			pairs.increaseCapacityBy(len);
+
+			INFORMATION<< "The contact pair container capacity increased from "<<
+			oldCap << " to "<<pairs.capacity()<<" in NBSLevel0."<<END_INFO;
+			
+		}
+
+		Kokkos::fence();
+	}
+	
+	return true;
+}
+
+
+pFlow::NBSLevel0::NBSLevel0
+(
+    const 	box& domain,
+    real 	cellSize,
+    real  sizeRatio,
+    const deviceViewType1D<realx3>& pointPos,
+    const pFlagTypeDevice& flags,
+    bool 	adjustableBox
+)
+:
+    mapperNBS
+    (
+        domain,
+        cellSize,
+        pointPos,
+        flags,
+        adjustableBox,
+        true
+    ),
+    sizeRatio_(sizeRatio)
+{
+    
+}
+
+bool pFlow::NBSLevel0::broadSearch
+(
+	csPairContainerType &pairs, 
+	const deviceViewType1D<realx3> &pointPos, 
+	const pFlagTypeDevice &flags, 
+	const deviceViewType1D<real> &diameter,
+	bool& searchBoxChanged
+)
+{	
+	if(!build(pointPos, flags, searchBoxChanged))
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+	if(!findPairs(pairs, pointPos, flags, diameter))
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+	return true;
+}
+
+
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0.hpp b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0.hpp
new file mode 100644
index 00000000..2f87c151
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0.hpp
@@ -0,0 +1,98 @@
+/*------------------------------- 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 __NBSLevel0_hpp__
+#define __NBSLevel0_hpp__
+
+#include "NBSLevel0Kernels.hpp"
+#include "mapperNBS.hpp"
+
+namespace pFlow
+{
+
+
+class NBSLevel0
+:
+	public mapperNBS
+{
+public:
+
+	using MapperType 		= mapperNBS;
+
+	using CellIterator  	= typename MapperType::CellIterator;
+
+	using HeadType 			= typename MapperType::HeadType;
+
+	using NextType 			= typename MapperType::NextType;	
+
+	
+private:
+
+	real 		sizeRatio_ = 1.0;
+
+	bool findPairs
+	(
+		csPairContainerType& pairs,
+		const deviceViewType1D<realx3>& pointPos,
+    	const pFlagTypeDevice& flags,
+    	const deviceViewType1D<real>& diameter
+	);
+
+public:
+
+	TypeInfoNV("NBSLevel0");
+
+		INLINE_FUNCTION_HD
+		NBSLevel0() = default;
+
+		NBSLevel0(
+			const 	box& domain,
+			real 	cellSize,
+			real 	sizeRatio,
+			const 	deviceViewType1D<realx3>& pointPos,
+			const 	pFlagTypeDevice& flags,
+			bool 	adjustableBox);
+
+		INLINE_FUNCTION_HD
+		NBSLevel0(const NBSLevel0&) = default;
+
+		INLINE_FUNCTION_HD
+		NBSLevel0& operator = (const NBSLevel0&) = default;
+
+		INLINE_FUNCTION_HD
+		~NBSLevel0()=default;
+
+
+	bool broadSearch(
+		csPairContainerType& pairs,
+		const deviceViewType1D<realx3>& pointPos,
+    	const pFlagTypeDevice& flags,
+    	const deviceViewType1D<real>& diameter,
+		bool& searchBoxChanged);
+		
+	
+	
+
+};
+
+} // pFlow
+
+#endif // __NBSLevel0_hpp__
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0Kernels.hpp b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0Kernels.hpp
new file mode 100644
index 00000000..31df063c
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLevel0Kernels.hpp
@@ -0,0 +1,83 @@
+/*------------------------------- 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 "mapperNBS.hpp"
+#include "contactSearchGlobals.hpp"
+
+#include "streams.hpp"
+
+namespace pFlow::NBSLevel0Kernels
+{
+
+using mdrPolicyFindPairs = 
+		Kokkos::MDRangePolicy<
+			Kokkos::IndexType<uint32>,
+			Kokkos::Rank<3>,
+			Kokkos::Schedule<Kokkos::Dynamic>,
+			DefaultExecutionSpace>;
+
+template<typename T>
+INLINE_FUNCTION_HD
+void Swap(T& x, T& y)
+{
+	T tmp = x;
+	x = y;
+	y = tmp;
+}
+
+INLINE_FUNCTION_HD
+bool sphereSphereCheck(const realx3& p1, const realx3 p2, real d1, real d2)
+{
+	return length(p2-p1) < 0.5*(d2+d1);
+}
+
+inline
+uint32 findPairsCount
+(
+    csPairContainerType& pairs,
+    real 	sizeRatio,
+    const deviceViewType1D<realx3>& pointPos,
+    const pFlagTypeDevice& flags,
+    const deviceViewType1D<real>& diameter,
+    mapperNBS::CellIterator cellIter
+)
+{
+
+	auto nCells = cellIter.numCells();
+	
+	mdrPolicyFindPairs
+			mdrPolicy(
+				{0,0,0},
+				{nCells.x(), nCells.y(), nCells.z()} );
+
+	uint32 notInsertedPairs = 0u;
+	
+		
+	Kokkos::parallel_reduce	(
+		"pFlow::NBSLevel0Kernels::findPairsCount",
+		mdrPolicy,
+		LAMBDA_HD(uint32 i, uint32 j, uint32 k, uint32& getFullUpdate){
+			#include "NBSLoop.hpp"
+		}, notInsertedPairs);
+		
+	return notInsertedPairs;
+}
+
+}
\ No newline at end of file
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLoop.hpp b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLoop.hpp
new file mode 100644
index 00000000..ab3eeea7
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/NBSLoop.hpp
@@ -0,0 +1,100 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+
+uint32 m = cellIter.start(i,j,k);
+int32x3 currentCell(i,j,k);
+uint32 n = mapperNBS::NoPos;
+
+while( m !=  mapperNBS::NoPos)
+{
+	
+	auto p_m = pointPos[m];	
+	auto d_m = sizeRatio* diameter[m];
+	
+	// the same cell
+	n = cellIter.getNext(m);
+	
+	while(n != mapperNBS::NoPos)
+	{
+		auto p_n = pointPos[n];
+		auto d_n = sizeRatio*diameter[n];
+		
+		if( sphereSphereCheck(p_m, p_n, d_m, d_n) )
+		{
+			auto ln = n;
+			auto lm = m;
+
+			if(lm>ln) Swap(lm,ln);
+			if( pairs.insert(lm,ln) == -1)
+			{
+				getFullUpdate++;
+			}
+		}
+		
+		n = cellIter.getNext(n);;
+	}
+
+	// neighbor cells
+	int32x3 neighborCell;
+	for(uint32 ni=0u; ni<13; ni++)
+	{
+		if(ni==0)		neighborCell = currentCell + int32x3( 0, 0,-1);
+		else if(ni==1)	neighborCell = currentCell + int32x3(-1, 0,-1);
+		else if(ni==2)	neighborCell = currentCell + int32x3(-1, 0, 0); 
+		else if(ni==3)	neighborCell = currentCell + int32x3(-1, 0, 1); 
+		else if(ni==4)	neighborCell = currentCell + int32x3( 0,-1,-1); 
+		else if(ni==5)	neighborCell = currentCell + int32x3( 0,-1, 0); 
+		else if(ni==6)	neighborCell = currentCell + int32x3( 0,-1, 1); 
+		else if(ni==7)	neighborCell = currentCell + int32x3(-1,-1,-1); 
+		else if(ni==8)	neighborCell = currentCell + int32x3(-1,-1, 0); 
+		else if(ni==9)	neighborCell = currentCell + int32x3(-1,-1, 1);
+		else if(ni==10)	neighborCell = currentCell + int32x3( 1,-1,-1);  
+		else if(ni==11)	neighborCell = currentCell + int32x3( 1,-1, 0);  
+		else if(ni==12)	neighborCell = currentCell + int32x3( 1,-1, 1);  
+		 
+		if( neighborCell.x()>=0 && neighborCell.y()>=0 && neighborCell.z()>=0 &&
+			neighborCell.x()<nCells.x() && neighborCell.y()<nCells.y() && neighborCell.z()<nCells.z() )
+		{
+			
+			n = cellIter.start(neighborCell.x(), neighborCell.y(), neighborCell.z());
+			while(n != mapperNBS::NoPos)
+			{
+				
+				auto p_n = pointPos[n];
+				auto d_n = sizeRatio*diameter[n];
+				
+				if(sphereSphereCheck(p_m, p_n, d_m, d_n))
+				{
+					auto ln = n;
+					auto lm = m;
+					if(lm>ln) Swap(lm,ln);
+					if( pairs.insert(lm,ln) == -1)
+					{
+						getFullUpdate++;
+					}
+				}
+				n = cellIter.next(n);
+			}
+		}
+	}
+	m = cellIter.next(m);
+}
+
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/cellsWallLevel0.cpp b/src/Interaction/contactSearch/methods/cellBased/NBS/cellsWallLevel0.cpp
new file mode 100644
index 00000000..5d85a118
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/cellsWallLevel0.cpp
@@ -0,0 +1,195 @@
+/*------------------------------- 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 "cellsWallLevel0.hpp"
+#include "streams.hpp"
+
+pFlow::cellsWallLevel0::cellsWallLevel0
+(
+    real cellExtent, 
+    uint32 numPoints, 
+    uint32 numElements, 
+    const ViewType1D<realx3, 
+    memory_space> &points,
+    const ViewType1D<uint32x3, memory_space> &vertices
+)
+:
+    cellExtent_( max(cellExtent, 0.5 ) ),
+    numElements_(numElements),
+    numPoints_(numPoints),
+    vertices_(vertices),
+    points_(points)
+{
+
+    allocateArrays();
+}
+
+bool pFlow::cellsWallLevel0::resetElements
+(
+	uint32 numElements, 
+	uint32 numPoints, 
+	ViewType1D<realx3, memory_space> &points, 
+	ViewType1D<uint32x3, memory_space> &vertices
+)
+{
+
+	numElements_ = numElements;
+	numPoints_ = numPoints;
+	points_ 	= points;
+	vertices_ 	= vertices;
+
+	allocateArrays();
+
+	return true;
+}
+
+bool pFlow::cellsWallLevel0::broadSearch
+(
+	csPairContainerType &pairs,
+	const cells& searchBox,  
+	const mapperNBS::CellIterator &particleMap
+)
+{
+	
+	// map walls onto the cells
+	
+	this->build(searchBox);
+	
+	this->particleWallFindPairs(pairs, particleMap);
+	
+	return true;
+}
+
+bool pFlow::cellsWallLevel0::build(const cells & searchBox)
+{
+	
+	Kokkos::parallel_for(
+		"pFlow::cellsWallLevel0::build",
+		deviceRPolicyStatic(0,numElements_),
+		CLASS_LAMBDA_HD(uint32 i)
+		{
+			auto v = vertices_[i];
+			auto p1 = points_[v.x()];
+			auto p2 = points_[v.y()];
+			auto p3 = points_[v.z()];
+			
+			realx3 minP;
+			realx3 maxP;
+
+			searchBox.extendBox(p1, p2, p3, cellExtent_, minP, maxP);
+			elementBox_[i] = iBoxType(searchBox.pointIndex(minP), searchBox.pointIndex(maxP));
+		});
+	Kokkos::fence();
+
+	return true;
+}
+
+bool pFlow::cellsWallLevel0::particleWallFindPairs
+(
+	csPairContainerType &pairs, 
+	const mapperNBS::CellIterator &particleMap
+)
+{
+
+	uint32 getFull = 1;
+
+	while (getFull)
+	{
+		
+		getFull = findPairsElementRangeCount(pairs, particleMap);
+		
+		if(getFull)
+		{
+			// - resize the container
+			//   note that getFull now shows the number of failed insertions.
+			uint32 len = max(getFull, 50u);
+			auto oldCap = pairs.capacity();
+			pairs.increaseCapacityBy(len);
+
+			INFORMATION<<"Contact pair container capacity increased from "<<
+					oldCap << " to " 
+					<< pairs.capacity() <<" in cellsWallLevel0."<<END_INFO;
+			
+			Kokkos::fence();
+		}
+	}
+	
+	return true;
+}
+
+pFlow::int32 pFlow::cellsWallLevel0::findPairsElementRangeCount
+(
+	csPairContainerType &pairs, 
+	const mapperNBS::CellIterator &particleMap
+)
+{
+	uint32 getFull =0;
+	
+	//const auto pwPairs = pairs;
+	const auto elementBox = elementBox_;
+	
+	
+	Kokkos::parallel_reduce(
+		"pFlow::cellsWallLevel0::findPairsElementRangeCount",
+		tpPWContactSearch(numElements_, Kokkos::AUTO),
+		LAMBDA_HD(
+			const typename tpPWContactSearch::member_type & teamMember,
+			uint32& valueToUpdate){
+			
+			const uint32 iTri = teamMember.league_rank();
+
+			const auto triBox = elementBox[iTri];
+			
+			uint32 getFull2 = 0;
+
+			auto bExtent = boxExtent(triBox);
+			uint32 numCellBox = bExtent.x()*bExtent.y()*bExtent.z();
+
+			Kokkos::parallel_reduce( 
+				Kokkos::TeamThreadRange( teamMember, numCellBox ),
+				[&] ( const uint32 linIndex, uint32 &innerUpdate )
+					{
+						
+						int32x3 cell;
+						indexToCell(linIndex, triBox, cell);
+						
+						uint32 n = particleMap.start(cell.x(),cell.y(),cell.z());
+						
+						while( n != particleMap.NoPos)
+						{
+							// id is wall id the pair is (particle id, wall id)
+							if( pairs.insert(
+								static_cast<csIdType>(n),
+								static_cast<csIdType>(iTri) ) == -1 )
+								innerUpdate++;
+							n = particleMap.next(n);
+						
+						}
+
+					},
+				getFull2
+			);
+
+			if ( teamMember.team_rank() == 0 ) valueToUpdate += getFull2;
+		},
+		getFull
+		);
+	return getFull;
+}
\ No newline at end of file
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/cellsWallLevel0.hpp b/src/Interaction/contactSearch/methods/cellBased/NBS/cellsWallLevel0.hpp
new file mode 100644
index 00000000..2ffb4414
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/cellsWallLevel0.hpp
@@ -0,0 +1,139 @@
+/*------------------------------- 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 __cellsWallLevel0_hpp__
+#define __cellsWallLevel0_hpp__
+
+#include "contactSearchGlobals.hpp"
+#include "contactSearchFunctions.hpp"
+#include "mapperNBS.hpp"
+#include "iBox.hpp"
+
+
+
+namespace pFlow
+{
+
+class cellsWallLevel0
+{
+public:
+
+	using execution_space = csExecutionSpace;
+
+	using memory_space 	= typename execution_space::memory_space;
+
+	using iBoxType 		= iBox<int32>;	
+
+	class TagFindCellRange2{};
+
+private:
+
+	// - box extent
+	real 			cellExtent_ = 0.5;
+
+	// - number of triangle elements 
+	uint32			numElements_ = 0;
+
+	// - number of points
+	uint32 			numPoints_ = 0;
+
+	// - ref to vectices (borrowed)
+	ViewType1D<uint32x3, memory_space> 	vertices_;
+
+	// - ref to points in the trisurface (borrowed)
+	ViewType1D<realx3, memory_space> 	points_;
+
+	// cell range of element/triangle bounding box
+	ViewType1D<iBoxType, memory_space> 	elementBox_;
+	
+
+	using tpPWContactSearch = Kokkos::TeamPolicy<
+			execution_space,
+			Kokkos::Schedule<Kokkos::Dynamic>,
+			Kokkos::IndexType<uint32>>;
+	
+	FUNCTION_H
+	void allocateArrays()
+	{
+		reallocNoInit( elementBox_, numElements_);
+	}
+
+public:
+
+	TypeInfoNV("cellsWallLevel0");
+
+	INLINE_FUNCTION_HD
+	cellsWallLevel0(){}
+
+	FUNCTION_H
+	cellsWallLevel0(
+		real 					cellExtent,
+		uint32 					numPoints,
+		uint32 					numElements,
+		const ViewType1D<realx3,memory_space>& 		points, 
+		const ViewType1D<uint32x3,memory_space>& 	vertices);
+	
+
+	
+	// - host call
+	//   reset triangle elements if they have changed
+	bool resetElements( 
+		uint32 		numElements,
+		uint32      numPoints,
+		ViewType1D<realx3, memory_space>& points, 
+		ViewType1D<uint32x3, memory_space>& vertices);
+	
+
+	INLINE_FUNCTION_HD
+	iBoxType elementBox(uint32 i)const
+	{
+		return elementBox_[i];
+	}
+
+	INLINE_FUNCTION_HD
+	uint32 numElements()const
+	{
+		return numElements_;
+	}
+
+	bool broadSearch(
+		csPairContainerType& pairs,
+		const cells& searchBox, 
+		const mapperNBS::CellIterator& particleMap);
+	
+
+	bool build(const cells& searchBox);
+	
+	bool particleWallFindPairs(
+		csPairContainerType& pairs, 
+		const mapperNBS::CellIterator& particleMap);
+
+	int32 findPairsElementRangeCount(
+		csPairContainerType& pairs, 
+		const mapperNBS::CellIterator& particleMap); 
+	
+
+
+}; // cellsWallLevel0
+
+} // pFlow
+
+
+#endif // __cellsWallLevel0_hpp__
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBS.cpp b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBS.cpp
new file mode 100644
index 00000000..b0f16804
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBS.cpp
@@ -0,0 +1,194 @@
+/*------------------------------- 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 "mapperNBS.hpp"
+#include "mapperNBSKernels.hpp"
+#include "streams.hpp"
+
+pFlow::uint32 pFlow::mapperNBS::checkInterval_ = 1000;
+pFlow::real pFlow::mapperNBS::enlargementFactor_ = 1.1;
+
+bool pFlow::mapperNBS::setSearchBox
+(
+    const deviceViewType1D<realx3> &pointPos, 
+    const pFlagTypeDevice &flags,
+    real cellSize
+)
+{
+    box domainBox = domainCells_.domainBox();
+
+	
+    if(adjustableBox_)
+    {
+        lastCheckForBox_ = buildCount_;
+        
+        realx3 minP;
+        realx3 maxP;
+        pFlow::mapperNBSKernels::findPointExtends
+        (
+            pointPos, 
+            flags, 
+            minP, maxP
+        );
+
+        minP = max( minP - enlargementFactor_*cellSize, domainBox.minPoint());
+        maxP = min( maxP + enlargementFactor_*cellSize, domainBox.maxPoint());       
+        
+        box searchBox = {minP, maxP};
+        searchCells_ = cells(searchBox, cellSize);    
+        INFORMATION<<"Search box for contact search has changed: "<< 
+        "search box is ["<<searchCells_.domainBox().minPoint()<<
+        " "<<searchCells_.domainBox().maxPoint()<<"]"<<END_INFO;
+        
+        return true;
+        
+    }
+    else
+    {
+        searchCells_ = cells(domainBox, cellSize);
+        INFORMATION<<"Search box for contact search is: ["
+        << domainBox.minPoint()<<" "<<domainBox.maxPoint()<<"]"<<END_INFO;
+
+        return false;
+    }
+    
+}
+
+void pFlow::mapperNBS::allocateArrays(rangeU32 nextRng)
+{
+    checkAllocateNext(nextRng);
+    nullifyNext(nextRng);
+    reallocFill(head_, searchCells_.nx(), searchCells_.ny(), searchCells_.nz(), NoPos);
+}
+
+void pFlow::mapperNBS::checkAllocateNext(rangeU32 nextRng)
+{
+
+    auto newCap = nextRng.end();
+    
+    if( nextCapacity_ < newCap)
+    {
+        nextCapacity_ = newCap;	
+        if(!nextOwner_)return;
+        reallocNoInit(next_, nextCapacity_);
+    }
+}
+
+void pFlow::mapperNBS::nullifyHead()
+{
+    fill(head_, NoPos);	
+}
+
+void pFlow::mapperNBS::nullifyNext(rangeU32 nextRng)
+{
+    if(!nextOwner_)return;
+		fill(next_, nextRng, NoPos);
+}
+
+pFlow::mapperNBS::mapperNBS(
+    const box &domain,
+    real cellSize,
+    const deviceViewType1D<realx3> &pointPos,
+    const pFlagTypeDevice &flags,
+    bool adjustableBox,
+    bool nextOwner
+)
+: 
+   	domainCells_(domain, cellSize),
+    searchCells_(domain, cellSize),
+   	adjustableBox_(adjustableBox),
+	nextOwner_(nextOwner)
+{
+    setSearchBox(pointPos, flags, cellSize);
+
+    allocateArrays(flags.activeRange());
+}
+
+bool pFlow::mapperNBS::build
+(
+    const deviceViewType1D<realx3>& pointPos, 
+    const pFlagTypeDevice & flags,
+    bool&  searchBoxChanged
+)
+{
+    auto aRange = flags.activeRange();
+    buildCount_++;
+    if(adjustableBox_ && buildCount_%checkInterval_ == 0)
+    {   
+
+        if(searchBoxChanged = 
+            setSearchBox(pointPos, flags, searchCells_.cellSize());searchBoxChanged)
+        {
+            allocateArrays(aRange);
+        }  
+        
+    }
+    else
+    {
+        checkAllocateNext(aRange);
+        nullifyHead();
+        nullifyNext(aRange);
+    }    
+    
+    if( adjustableBox_ )
+    {
+        if(!pFlow::mapperNBSKernels::buildListsReduce(
+            searchCells_,
+            head_,
+            next_,
+            pointPos,
+            flags) )
+        {
+
+            buildCount_++;           
+            setSearchBox(pointPos, flags, searchCells_.cellSize());
+            
+            searchBoxChanged = true;
+            
+            allocateArrays(flags.activeRange());
+
+            if(!pFlow::mapperNBSKernels::buildListsReduce(
+                searchCells_,
+                head_,
+                next_,
+                pointPos,
+                flags))
+            {
+                fatalErrorInFunction<<"failed to build list in anjustable search box mode!"<<endl;
+                return false;   
+            }
+        }
+    }
+    else
+    {
+        pFlow::mapperNBSKernels::buildLists(
+            searchCells_,
+            head_,
+            next_,
+            pointPos,
+            flags
+        );
+        searchBoxChanged = false;
+    }
+    
+    return true;
+
+}
+
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBS.hpp b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBS.hpp
new file mode 100644
index 00000000..471a1ab9
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBS.hpp
@@ -0,0 +1,212 @@
+/*------------------------------- 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 __mapperNBS_hpp__
+#define __mapperNBS_hpp__
+
+#include "phasicFlowKokkos.hpp"
+#include "pointFlag.hpp"
+#include "cells.hpp"
+//#include "contactSearchFunctions.hpp"
+
+
+namespace pFlow
+{
+
+class mapperNBS
+{
+public:
+
+	using HeadType 			= deviceViewType3D<uint32>;
+
+	using NextType 			= deviceViewType1D<uint32>;	
+
+	
+	static constexpr uint32 NoPos 	= 0xFFFFFFFF;
+
+	class CellIterator
+	{
+	private:
+		HeadType 		head_;
+
+		NextType 		next_;
+
+	public:
+
+		CellIterator(const HeadType& head, const NextType& next)
+		:
+			head_(head),
+			next_(next)
+		{}
+		
+		static constexpr uint32 NoPos = 0xFFFFFFFF;
+
+		INLINE_FUNCTION_HD
+		int32x3 numCells()const {
+			return int32x3(head_.extent(0), head_.extent(1), head_.extent(2));}
+
+		INLINE_FUNCTION_HD
+		uint32 start(int32 i, int32 j, int32 k)const {
+			return head_(i,j,k); }
+
+		INLINE_FUNCTION_HD
+		uint32 getNext(uint32 n)const {
+			if(n == NoPos ) return NoPos;
+			return next_(n); }
+
+		INLINE_FUNCTION_HD
+		uint32 next(uint32 n)const{
+			return next_(n);}
+	};
+
+private:
+	
+	cells  				domainCells_;
+
+	cells 				searchCells_;
+
+	HeadType 			head_{"NBS::head",1,1,1};
+
+	NextType 			next_{"NBS::next", 1};
+
+	uint32 				nextCapacity_ = 0;
+
+	uint32 				lastCheckForBox_ = 0;
+
+	uint32 				buildCount_ = 0;
+
+	bool 				adjustableBox_ = false;
+
+	bool 				nextOwner_ 	= true;
+
+	static uint32 		checkInterval_;	
+
+	static real 		enlargementFactor_;
+
+	bool setSearchBox(
+		const deviceViewType1D<realx3>& pointPos,
+		const pFlagTypeDevice& flags,
+		real cellSize
+	);
+
+	void allocateArrays(rangeU32 nextRng);
+
+	void checkAllocateNext(rangeU32 nextRng);
+	
+	void nullifyHead();
+	
+	void nullifyNext(rangeU32 nextRng);
+	
+public:
+
+	TypeInfoNV("mapperNBS");
+
+		INLINE_FUNCTION_HD
+		mapperNBS() = default;
+
+		mapperNBS(
+			const 	box& domain,
+			real 	cellSize,
+			const deviceViewType1D<realx3>& pointPos,
+			const pFlagTypeDevice& flags,
+			bool 	adjustableBox,
+			bool 	nextOwner = true);
+					
+		INLINE_FUNCTION_HD
+		mapperNBS(const mapperNBS&) = default;
+
+		INLINE_FUNCTION_HD
+		mapperNBS(mapperNBS&&) = default;
+		
+		INLINE_FUNCTION_HD
+		mapperNBS& operator = (const mapperNBS&) = default;
+
+		INLINE_FUNCTION_HD
+		mapperNBS& operator = (mapperNBS&&) = default;
+
+		INLINE_FUNCTION_HD
+		~mapperNBS()=default;
+
+	//// - Methods
+
+		auto getCellIterator()const
+		{
+			return CellIterator(head_, next_);
+		}
+
+		const auto& getDomainCells()const
+		{
+			return domainCells_;
+		}
+
+		const auto& getSearchCells()const
+		{
+			return searchCells_;
+		}
+
+		bool build(
+			const deviceViewType1D<realx3>& pointPos,
+			const pFlagTypeDevice& flags,
+			bool&  searchBoxChanged);
+
+		
+	
+
+};
+
+} // pFlow
+
+#endif // __mapperNBS_hpp__
+
+
+
+
+/*
+INLINE_FUNCTION_HD
+	auto& head()
+	{
+		return head_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto& next()
+	{
+		return next_;
+	}
+
+	INLINE_FUNCTION_HD
+	const auto& head()const
+	{
+		return head_;
+	}
+
+	INLINE_FUNCTION_HD
+	const auto& next()const
+	{
+		return next_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto& pointPosition()
+	{
+		return pointPosition_;
+	}
+*/
\ No newline at end of file
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBSKernels.cpp b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBSKernels.cpp
new file mode 100644
index 00000000..01141eac
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBSKernels.cpp
@@ -0,0 +1,192 @@
+
+
+/*------------------------------- 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 "mapperNBSKernels.hpp"
+
+
+void pFlow::mapperNBSKernels::findPointExtends
+(
+    const deviceViewType1D<realx3>& points,
+    const pFlagTypeDevice& flags,
+    realx3& minPoint,
+    realx3& maxPoint
+)
+{
+    if(flags.numActive() == 0)
+    {
+        minPoint = {0,0,0};
+        maxPoint = {0,0,0};
+        return;
+    }
+
+    real minX;
+    real minY;
+    real minZ;
+    real maxX;
+    real maxY;
+    real maxZ;
+    auto aRange = flags.activeRange();
+    Kokkos::parallel_reduce(
+        "pFlow::mapperNBSKernels::findPointExtends",
+        deviceRPolicyStatic(aRange.start(), aRange.end()),
+        LAMBDA_HD(
+            uint32 i, 
+            real& minXUpdate, 
+            real& minYUpdate, 
+            real& minZUpdate,
+            real& maxXUpdate,
+            real& maxYUpdate,
+            real& maxZUpdate)
+        {
+            if(flags(i))
+            {
+                auto p = points(i);
+                minXUpdate = min(p.x(), minXUpdate);
+                minYUpdate = min(p.y(), minYUpdate);
+                minZUpdate = min(p.z(), minZUpdate);
+                maxXUpdate = max(p.x(), maxXUpdate);
+                maxYUpdate = max(p.y(), maxYUpdate);
+                maxZUpdate = max(p.z(), maxZUpdate);
+            }
+
+        },
+        Kokkos::Min<real>(minX),
+        Kokkos::Min<real>(minY), 
+        Kokkos::Min<real>(minZ),
+        Kokkos::Max<real>(maxX),
+        Kokkos::Max<real>(maxY),
+        Kokkos::Max<real>(maxZ)
+    );
+
+    minPoint = {minX, minY, minZ};
+    maxPoint = {maxX, maxY, maxZ};
+}
+
+bool pFlow::mapperNBSKernels::buildListsReduce
+(
+    const cells &searchCell, 
+    const deviceViewType3D<uint32> &head, 
+    const deviceViewType1D<uint32> &next, 
+    const deviceViewType1D<realx3> &points, 
+    const pFlagTypeDevice &flags
+)
+{
+    uint32 numOut = 0;
+    auto aRange = flags.activeRange();
+
+    if(flags.isAllActive())
+    {
+        Kokkos::parallel_reduce
+        (
+            "pFlow::mapperNBSKernels::buildListsReduce",
+            deviceRPolicyStatic(aRange.start(), aRange.end()),
+            LAMBDA_HD(uint32 i, uint32& valToUpdate)
+            {	
+                int32x3 ind;
+                if( searchCell.pointIndexInDomain(points[i], ind) )
+                {
+                    uint32 old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
+                    next[i] = old;	
+                }
+                else
+                {
+                    valToUpdate++;
+                }
+            },
+            numOut
+        );
+    }
+    else
+    {
+        Kokkos::parallel_reduce
+        (
+            "pFlow::mapperNBSKernels::buildListsReduce",
+            deviceRPolicyStatic(aRange.start(), aRange.end()),
+            LAMBDA_HD(uint32 i, uint32& valToUpdate)
+            {	
+                int32x3 ind;
+                if( flags(i) )
+                {
+                    if( searchCell.pointIndexInDomain(points[i], ind) )
+                    {
+                        uint32 old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
+                        next[i] = old;	
+                    }
+                    else
+                    {
+                        valToUpdate++;
+                    }
+                }
+            },
+            numOut
+        );
+    }
+
+    return numOut == 0u ;
+}
+
+bool pFlow::mapperNBSKernels::buildLists
+(
+    const cells &searchCell, 
+    const deviceViewType3D<uint32> &head, 
+    const deviceViewType1D<uint32> &next, 
+    const deviceViewType1D<realx3> &points, 
+    const pFlagTypeDevice &flags
+)
+{
+    auto aRange = flags.activeRange();
+    if(flags.isAllActive() )
+    {
+        Kokkos::parallel_for
+        (
+            "pFlow::mapperNBSKernels::buildLists",
+            deviceRPolicyStatic(aRange.start(), aRange.end()),
+            LAMBDA_HD(uint32 i)
+            {
+                auto ind = searchCell.pointIndex(points[i]);	
+                uint32 old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
+                next[i] = old;
+            }
+        );
+        Kokkos::fence();    
+    }
+    else
+    {
+       Kokkos::parallel_for
+        (
+            "pFlow::mapperNBSKernels::buildLists",
+            deviceRPolicyStatic(aRange.start(), aRange.end()),
+            LAMBDA_HD(uint32 i)
+            {
+                if( flags(i) )
+                {
+                    auto ind = searchCell.pointIndex(points[i]);	
+                    uint32 old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
+                    next[i] = old;
+                }
+            }
+        );
+        Kokkos::fence();
+    }
+
+    return true;
+}
diff --git a/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBSKernels.hpp b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBSKernels.hpp
new file mode 100644
index 00000000..6730ff22
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/cellBased/NBS/mapperNBSKernels.hpp
@@ -0,0 +1,49 @@
+/*------------------------------- 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 "phasicFlowKokkos.hpp"
+#include "cells.hpp"
+#include "pointFlag.hpp"
+
+
+namespace pFlow::mapperNBSKernels
+{
+
+void findPointExtends(
+    const deviceViewType1D<realx3>& points,
+    const pFlagTypeDevice& flags,
+    realx3& minPoint,
+    realx3& maxPoint);
+
+bool buildListsReduce(
+    const cells& searchCell,
+    const deviceViewType3D<uint32>& head,
+    const deviceViewType1D<uint32>& next,
+    const deviceViewType1D<realx3>& points,
+    const pFlagTypeDevice& flags);
+
+bool buildLists(
+    const cells& searchCell,
+    const deviceViewType3D<uint32>& head,
+    const deviceViewType1D<uint32>& next,
+    const deviceViewType1D<realx3>& points,
+    const pFlagTypeDevice& flags);
+
+}
\ No newline at end of file
diff --git a/src/Interaction/contactSearch/cells.hpp b/src/Interaction/contactSearch/methods/cellBased/cells.hpp
similarity index 62%
rename from src/Interaction/contactSearch/cells.hpp
rename to src/Interaction/contactSearch/methods/cellBased/cells.hpp
index c77b1a69..c4b50813 100644
--- a/src/Interaction/contactSearch/cells.hpp
+++ b/src/Interaction/contactSearch/methods/cellBased/cells.hpp
@@ -28,58 +28,40 @@ Licence:
 namespace pFlow
 {
 
-template<typename indexType>
 class cells
 {
-public:
-	
-	using CellType = triple<indexType>;
-
-protected:
+private:
 
 	// - domain 
-	box 		domain_{realx3(0.0), realx3(1.0)};
+	box 		domainBox_{realx3(0.0), realx3(1.0)};
 
 	// - cell size 
-	realx3 		cellSize_{1,1,1};
-
-	CellType 	numCells_{1,1,1};
+	real 		celldx_{1};
 
+	int32x3 	numCells_{1,1,1};
 	
 	// - protected methods
 	INLINE_FUNCTION_H
 	void calculate()
 	{
-		numCells_ = (domain_.maxPoint()-domain_.minPoint())/cellSize_ + realx3(1.0);
-		numCells_ = max( numCells_ , CellType(static_cast<indexType>(1)) );
+		numCells_ = (domainBox_.maxPoint()-domainBox_.minPoint())/celldx_ + realx3(1.0);
+		numCells_ = max( numCells_ , int32x3(1) );
 	}
 
 public:
 
 	INLINE_FUNCTION_HD
-	cells()
-	{}
+	cells() = default;
 
 	INLINE_FUNCTION_H
 	cells(const box& domain, real cellSize)
 	:
-		domain_(domain),
-		cellSize_(cellSize)
+		domainBox_(domain),
+		celldx_(cellSize)
 	{
 		calculate();
 	}
 
- 
-	INLINE_FUNCTION_H
-	cells(const box& domain, int32 nx, int32 ny, int32 nz)
-	:
-		domain_(domain),
-		cellSize_(
-			(domain_.maxPoint() - domain_.minPoint())/realx3(nx, ny,  nz)
-			),
-		numCells_(nx, ny, nz)
-	{}
-
 	INLINE_FUNCTION_HD
 	cells(const cells&) = default;
 
@@ -100,43 +82,36 @@ public:
 	INLINE_FUNCTION_H
 	void setCellSize(real cellSize)
 	{
-		cellSize_ = cellSize;
-		calculate();
-	}
-
-	INLINE_FUNCTION_H
-	void setCellSize(realx3 cellSize)
-	{
-		cellSize_ = cellSize;
+		celldx_ = cellSize;
 		calculate();
 	}
 
 	INLINE_FUNCTION_HD
-	realx3 cellSize()const
+	real cellSize()const
 	{
-		return cellSize_;
+		return celldx_;
 	}
 
 	INLINE_FUNCTION_HD
-	const CellType& numCells()const
+	const int32x3& numCells()const
 	{
 		return numCells_;
 	}
 
 	INLINE_FUNCTION_HD
-	indexType nx()const
+	int32 nx()const
 	{
 		return numCells_.x();
 	}
 
 	INLINE_FUNCTION_HD
-	indexType ny()const
+	int32 ny()const
 	{
 		return numCells_.y();
 	}
 
 	INLINE_FUNCTION_HD
-	indexType nz()const
+	int32 nz()const
 	{
 		return numCells_.z();
 	}
@@ -149,22 +124,21 @@ public:
 				static_cast<int64>(numCells_.z());
 	}
 
-	const auto& domain()const
+	const auto& domainBox()const
 	{
-		return domain_;
+		return domainBox_;
 	}
 	
 	INLINE_FUNCTION_HD
-	CellType pointIndex(const realx3& p)const
+	int32x3 pointIndex(const realx3& p)const
 	{
-		return CellType( (p - domain_.minPoint())/cellSize_ );
+		return int32x3( (p - domainBox_.minPoint())/celldx_ );
 	}
 
 	INLINE_FUNCTION_HD
-	bool pointIndexInDomain(const realx3 p, CellType& index)const
+	bool pointIndexInDomain(const realx3 p, int32x3& index)const
 	{
-		if( !domain_.isInside(p) ) return false;
-		
+		if(!inDomain(p))return false;
 		index = this->pointIndex(p);
 		return true;
 	}
@@ -172,11 +146,11 @@ public:
 	INLINE_FUNCTION_HD
 	bool inDomain(const realx3& p)const
 	{	
-		return domain_.isInside(p);
+		return domainBox_.isInside(p);
 	}
 
 	INLINE_FUNCTION_HD
-	bool isInRange(const CellType& cell)const
+	bool inCellRange(const int32x3& cell)const
 	{
 		if(cell.x()<0)return false;
 		if(cell.y()<0)return false;
@@ -188,7 +162,7 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	bool isInRange(indexType i, indexType j, indexType k)const
+	bool inCellRange(int32 i, int32 j, int32 k)const
 	{
 		if(i<0)return false;
 		if(j<0)return false;
@@ -199,22 +173,7 @@ public:
 		return true;
 	}
 
-	INLINE_FUNCTION_HD
-	void extendBox(
-		const CellType& p1,
-		const CellType& p2,
-		const CellType& p3,
-		indexType extent,
-		CellType& minP,
-		CellType& maxP)const
-	{
-		minP = min( min( p1, p2), p3)-extent;
-		maxP = max( max( p1, p2), p3)+extent;
-
-		minP = bound(minP);
-		maxP = bound(maxP);
-	}
-
+	
 	INLINE_FUNCTION_HD
 	void extendBox(
 		const realx3& p1,
@@ -224,17 +183,17 @@ public:
 		realx3& minP,
 		realx3& maxP)const
 	{
-		minP = min(min(p1,p2),p3) - extent*cellSize_ ;
-		maxP = max(max(p1,p2),p3) + extent*cellSize_ ;
+		minP = min(min(p1,p2),p3) - extent*celldx_ ;
+		maxP = max(max(p1,p2),p3) + extent*celldx_ ;
 
 		minP = bound(minP);
 		maxP = bound(maxP);
 	}
 
 	INLINE_FUNCTION_HD
-	CellType bound(CellType p)const
+	int32x3 bound(int32x3 p)const
 	{
-		return CellType(
+		return int32x3(
 			min( numCells_.x()-1, max(0,p.x())),
 			min( numCells_.y()-1, max(0,p.y())),
 			min( numCells_.z()-1, max(0,p.z()))
@@ -245,9 +204,9 @@ public:
 	realx3 bound(realx3 p)const
 	{
 		return realx3(
-			min( domain_.maxPoint().x(), max(domain_.minPoint().x(),p.x())),
-			min( domain_.maxPoint().y(), max(domain_.minPoint().y(),p.y())),
-			min( domain_.maxPoint().z(), max(domain_.minPoint().z(),p.z()))
+			min( domainBox_.maxPoint().x(), max(domainBox_.minPoint().x(),p.x())),
+			min( domainBox_.maxPoint().y(), max(domainBox_.minPoint().y(),p.y())),
+			min( domainBox_.maxPoint().z(), max(domainBox_.minPoint().z(),p.z()))
 			);
 	}
 };	
diff --git a/src/Interaction/contactSearch/methods/mapperNBS.hpp b/src/Interaction/contactSearch/methods/mapperNBS.hpp
deleted file mode 100644
index 41b47068..00000000
--- a/src/Interaction/contactSearch/methods/mapperNBS.hpp
+++ /dev/null
@@ -1,389 +0,0 @@
-/*------------------------------- 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 __mapperNBS_hpp__
-#define __mapperNBS_hpp__
-
-#include "cells.hpp"
-#include "contactSearchFunctions.hpp"
-#include "baseAlgorithms.hpp"
-#include "ViewAlgorithms.hpp"
-
-namespace pFlow
-{
-
-template<typename executionSpace>
-class mapperNBS
-:
-	public cells<int32>
-{
-public:
-
-	using IdType 			= int32;
-	
-	using IndexType 	= int32;
-
-	using Cells 			= cells<IndexType>;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space = executionSpace;
-
-	using memory_space 		= typename execution_space::memory_space;
-
-	using HeadType 		= ViewType3D<int32, memory_space>;
-
-	using NextType 		= ViewType1D<int32, memory_space>;	
-
-	class cellIterator
-	{
-	private:
-		HeadType 		head_;
-
-		NextType 		next_;
-
-	public:
-
-		cellIterator(ViewType3D<int32, memory_space> head, ViewType1D<int32, memory_space> next)
-		:
-			head_(head),
-			next_(next)
-		{}
-
-		INLINE_FUNCTION_HD
-		Cells cellsSize()const {
-			return Cells(head_.extent(0), head_.extent(1), head_.extent(2));}
-
-		INLINE_FUNCTION_HD
-		int32 start(IndexType i, IndexType j, IndexType k)const {
-			return head_(i,j,k); }
-
-		INLINE_FUNCTION_HD
-		int32 getNext(int32 n)const {
-			if(n<0) return n;
-			return next_(n); }
-	};
-
-protected:
-
-	int32 									capacity_ = 1;
-
-	ViewType3D<int32, memory_space> 		head_;
-
-	ViewType1D<int32, memory_space> 		next_;
-
-	bool 									nextOwner_ = true;
-
-	// borrowed ownership
-	ViewType1D<realx3, memory_space> 		pointPosition_;
-
-	using rangePolicyType	=
-		Kokkos::RangePolicy<
-			Kokkos::IndexType<int32>,
-			Kokkos::Schedule<Kokkos::Static>,
-			execution_space>;
-	
-	INLINE_FUNCTION_H
-	void nullifyHead()
-	{
-		fill(
-			head_,
-			range(0,this->nx()),
-			range(0,this->ny()),
-			range(0,this->nz()),
-			static_cast<int32>(-1)
-			);
-	}
-
-	void nullifyNext(range nextRng)
-	{
-		if(!nextOwner_)return;
-		fill(
-			next_,
-			nextRng,
-			static_cast<int32>(-1)
-			);
-	}
-
-	void nullify()
-	{
-		nullifyHead();
-
-		nullifyNext(range(0,capacity_));
-	}
-
-	void nullify(range nextRng)
-	{
-		nullifyHead();
-
-		nullifyNext(nextRng);
-	}
-	
-
-	void checkAllocateNext(int newCap)
-	{
-		if( capacity_ < newCap)
-		{
-			capacity_ = newCap;	
-			if(!nextOwner_)return;
-			reallocNoInit(next_, capacity_);
-		}
-	}
-
-	void allocateHead()
-	{
-		reallocNoInit(head_, this->nx(), this->ny(), this->nz());
-	}
-
-
-	
-public:
-
-	TypeInfoNV("mapperNBS");
-
-		INLINE_FUNCTION_HD
-		mapperNBS(){}
-
-		mapperNBS(
-			const 	box& domain,
-			real 	cellSize,
-			const 	ViewType1D<realx3, memory_space>& position,
-			bool 	nextOwner = true)
-		:
-			Cells(domain, cellSize),
-			pointPosition_(position),
-			head_(
-				"mapperNBS::head_",
-				this->nx(),
-				this->ny(),
-				this->nz()
-				), 
-			next_("mapperNBS::next_",1), //,position.size()),
-			nextOwner_(nextOwner)
-		{
-			checkAllocateNext(pointPosition_.size());
-		}
-
-		mapperNBS(
-			const 	box& domain,
-			int32 	nx,
-			int32 	ny,
-			int32 	nz,
-			const 	ViewType1D<realx3, memory_space>& position,
-			bool 	nextOwner = true)
-		:
-			Cells(domain, nx, ny, nz),
-			pointPosition_(position),
-			head_("mapperNBS::head_",nx,ny,nz), 
-			next_("mapperNBS::next_",1),
-			nextOwner_(nextOwner)
-		{
-			checkAllocateNext(pointPosition_.size());
-		}
-
-			
-		INLINE_FUNCTION_HD
-		mapperNBS(const mapperNBS&) = default;
-
-		INLINE_FUNCTION_HD
-		mapperNBS& operator = (const mapperNBS&) = default;
-
-		INLINE_FUNCTION_HD
-		~mapperNBS()=default;
-
-	//// - Methods 
-	INLINE_FUNCTION_HD
-	auto capacity()const
-	{
-		return capacity_;
-	}
-
-	cellIterator getCellIterator()const
-	{
-		return cellIterator(head_, next_);
-	}
-
-	bool particlesCapcityChanged(int32 newCap)
-	{
-		checkAllocateNext(newCap);
-		return true;
-	}
-
-	INLINE_FUNCTION_HD
-	auto& head()
-	{
-		return head_;
-	}
-
-	INLINE_FUNCTION_HD
-	auto& next()
-	{
-		return next_;
-	}
-
-	INLINE_FUNCTION_HD
-	const auto& head()const
-	{
-		return head_;
-	}
-
-	INLINE_FUNCTION_HD
-	const auto& next()const
-	{
-		return next_;
-	}
-
-	INLINE_FUNCTION_HD
-	auto& pointPosition()
-	{
-		return pointPosition_;
-	}
-
-	INLINE_FUNCTION_H
-	void setNext(ViewType1D<int32, memory_space>& next)
-	{
-		if(!nextOwner_)
-		{
-			next_ = next;
-			capacity_ = next.size();
-		}
-	}
-
-	
-
-	// - build based on all points in active range
-	INLINE_FUNCTION_H
-	void build(range activeRange)
-	{
-		checkAllocateNext(activeRange.second);
-		nullify(activeRange);
-		
-		Cells cellIndex = static_cast<Cells>(*this);
-		auto points = pointPosition_;
-		auto next = next_;
-		auto head = head_;
-
-		rangePolicyType rPolicy(activeRange.first, activeRange.second);
-		
-		Kokkos::parallel_for(
-			"mapperNBS::build",
-			rPolicy,
-			LAMBDA_HD(int32 i){
-				CellType ind = cellIndex.pointIndex(points[i]);	
-				int32 old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
-				next[i] = old;
-			});
-		Kokkos::fence();
-	}
-
-
-	template<typename IncludeFunction>
-	INLINE_FUNCTION_H
-	void build(range activeRange, IncludeFunction incld)
-	{
-		checkAllocateNext(activeRange.second);
-		nullify(activeRange);
-
-		Cells cellIndex = static_cast<Cells>(*this);
-		auto points = pointPosition_;
-		auto next = next_;
-		auto head = head_;
-
-		rangePolicyType rPolicy(activeRange.first, activeRange.second);
-
-		Kokkos::parallel_for(
-			"mapperNBS::build_Include",
-			rPolicy,
-			LAMBDA_HD(int32 i){
-				if( incld(i) )
-				{
-					CellType ind = cellIndex.pointIndex(points[i]);
-					auto old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
-					next[i] = old;
-				}
-			});
-		Kokkos::fence();
-
-	}
-
-	
-	INLINE_FUNCTION_H
-	void buildCheckInDomain(range activeRange)
-	{
-		checkAllocateNext(activeRange.second);
-		nullify(activeRange);
-		
-		Cells cellIndex = static_cast<Cells>(*this);
-		auto points = pointPosition_;
-		auto next = next_;
-		auto head = head_;
-
-		rangePolicyType rPolicy(activeRange.first, activeRange.second);
-		
-		Kokkos::parallel_for(
-			"mapperNBS::buildCheckInDomain",
-			rPolicy,
-			LAMBDA_HD(int32 i){	
-				CellType ind;
-				if( cellIndex.pointIndexInDomain(points[i], ind) )
-				{
-					int32 old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
-					next[i] = old;	
-				}
-			});
-
-		Kokkos::fence();
-
-	}
-
-	template<typename IncludeFunction>
-	INLINE_FUNCTION_H
-	void buildCheckInDomain(range activeRange, IncludeFunction incld)
-	{
-		checkAllocateNext(activeRange.second);
-		nullify(activeRange);
-
-		Cells cellIndex = static_cast<Cells>(*this);
-		auto points = pointPosition_;
-		auto next = next_;
-		auto head = head_;
-
-		rangePolicyType rPolicy(activeRange.first, activeRange.second);
-
-		Kokkos::parallel_for(
-			"mapperNBS::buildCheckInDomain_Include",
-			rPolicy,
-			LAMBDA_HD(int32 i){
-				CellType ind;
-				if( incld(i) && cellIndex.pointIndexInDomain(points[i], ind) )
-				{
-					auto old = Kokkos::atomic_exchange(&head(ind.x(), ind.y(), ind.z()), i);
-					next[i] = old;
-				}
-			});
-		Kokkos::fence();
-	}
-
-};
-
-} // pFlow
-
-#endif // __mapperNBS_hpp__
\ No newline at end of file
diff --git a/src/Interaction/contactSearch/methods/multiGridNBS.hpp b/src/Interaction/contactSearch/methods/multiGridNBS.hpp
deleted file mode 100644
index dbce390b..00000000
--- a/src/Interaction/contactSearch/methods/multiGridNBS.hpp
+++ /dev/null
@@ -1,213 +0,0 @@
-/*------------------------------- 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 __multiGridNBS_hpp__
-#define __multiGridNBS_hpp__
-
-#include "NBSLevels.hpp"
-
-namespace pFlow
-{
-
-
-template<typename executionSpace>
-class multiGridNBS
-{
-public:
-
-	using NBSLevelsType	= NBSLevels<executionSpace>;
-
-	using cellIterator 	= typename NBSLevelsType::cellIterator;
-
-	using IdType 		= typename NBSLevelsType::IdType;
-	
-	using IndexType 	= typename NBSLevelsType::IndexType;
-
-	using Cells 		= typename NBSLevelsType::Cells;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space 	= typename NBSLevelsType::execution_space;
-
-	using memory_space 		= typename NBSLevelsType::memory_space;
-
-
-protected:
-
-	real 		sizeRatio_ = 1.0;
-
-	int32 		updateFrequency_= 1;
-
-	int32 		currentIter_ 	= 0;
-
-	bool 		performedSearch_ = false;
-
-	NBSLevelsType NBSLevels_;
-
-private:
-
-	bool performSearch()
-	{
-		if(currentIter_ % updateFrequency_ == 0)
-		{
-			currentIter_++;
-			return true;
-
-		}else
-		{
-			currentIter_++;
-			return false;
-		}
-	}
-
-public:
-
-	TypeInfoNV("multiGridNBS");
-
-		multiGridNBS(
-			const 	dictionary& dict,
-			const 	box& domain,
-			real 	minSize,
-			real 	maxSize,
-			const 	ViewType1D<realx3, memory_space>& position,
-			const 	ViewType1D<real, memory_space>& diam)
-		:
-			sizeRatio_( 
-				max(
-					dict.getVal<real>("sizeRatio"),
-					1.0
-					)),
-			updateFrequency_(
-				max( 
-					dict.getVal<int32>("updateFrequency"),
-					1
-					)),
-			NBSLevels_(
-				domain, 
-				minSize,
-				maxSize,
-				sizeRatio_,
-				position,
-				diam)
-		{}
-			
-		INLINE_FUNCTION_HD
-		multiGridNBS(const multiGridNBS&) = default;
-
-		INLINE_FUNCTION_HD
-		multiGridNBS& operator = (const multiGridNBS&) = default;
-
-		INLINE_FUNCTION_HD
-		~multiGridNBS()=default;
-
-	//// - Methods 
-
-	bool enterBoadSearch()const
-	{
-		return currentIter_%updateFrequency_==0;
-	}
-
-	bool performedSearch()const
-	{
-		return performedSearch_;
-	}
-
-	int32 numLevels()const
-	{
-		return NBSLevels_.numLevels();
-	}
-
-	auto getCellsLevels()const
-	{
-		Vector<Cells> cellsLvl("cells", numLevels(), numLevels(), RESERVE());
-
-		for(int32 lvl=0; lvl<numLevels(); lvl++)
-		{
-			cellsLvl[lvl] = NBSLevels_.getCells(lvl) ;
-		}
-
-		return cellsLvl;
-	}
-
-	auto getCells(int32 lvl)const
-	{
-		return NBSLevels_.getCells(lvl);
-	}
-
-	auto getCellIterator(int32 lvl)const
-	{
-		return NBSLevels_.getCellIterator(lvl);	
-	}
-
-	bool objectSizeChanged(int32 newSize)
-	{
-		NBSLevels_.checkAllocateNext(newSize);
-		return true;
-	}
-
-	// - Perform the broad search to find pairs
-	//	 with force = true, perform broad search regardless of 
-	//   updateFrequency_ value
-	//   on all the points in the range of [0,numPoints_)
-	template<typename PairsContainer>
-	bool broadSearch(PairsContainer& pairs, range activeRange, bool force=false)
-	{
-		
-		if(force) currentIter_ = 0;
-		performedSearch_ = false;
-
-		if( !performSearch() ) return true;
-		
-		
-		NBSLevels_.build(activeRange);
-		
-		NBSLevels_.findPairs(pairs);
-		
-		
-		performedSearch_ = true;		
-		return true;
-	}
-
-	// - Perform the broad search to find pairs,
-	//   ignore particles with incld(i) = true,
-	//	 with force = true, perform broad search regardless of 
-	//   updateFrequency_ value
-	template<typename PairsContainer, typename IncludeFunction>
-	bool broadSearch(PairsContainer& pairs, range activeRange, IncludeFunction incld, bool force = false)
-	{
-		if(force) currentIter_ = 0;
-		performedSearch_ = false;
-
-		if( !performSearch() ) return true;
-
-		NBSLevels_.build(activeRange, incld);
-	
-		NBSLevels_.findPairs(pairs);
-		
-		performedSearch_ = true;
-		return true;
-	}
-
-};
-
-}
-
-#endif
diff --git a/src/Interaction/contactSearch/methods/particleWallContactSearchs.cpp b/src/Interaction/contactSearch/methods/particleWallContactSearchs.cpp
new file mode 100644
index 00000000..25064346
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/particleWallContactSearchs.cpp
@@ -0,0 +1,78 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+
+template <typename method>
+pFlow::particleWallContactSearchs<method>::particleWallContactSearchs
+(
+    const dictionary &dict, 
+    const box &domain, 
+    real minSize, 
+    real maxSize, 
+    const ViewType1D<realx3, memory_space> &position,
+    const pFlagTypeDevice &flags,  
+    const ViewType1D<real, memory_space> &diam
+)
+:
+    domainBox_(domain),
+    updateInterval_
+    (
+        dict.getValOrSet<uint32>("updateInterval", 1)
+    )
+{
+    
+}
+
+template <typename method>
+bool pFlow::particleWallContactSearchs<method>::broadSearch
+	(
+		uint32 iter,
+		real t,
+		real dt,
+		csPairContainerType& ppPairs,
+		csPairContainerType& pwPairs,
+		const deviceViewType1D<realx3>& pointPos,
+		const pFlagTypeDevice& flags,
+		const deviceViewType1D<real>& diameter,
+		bool  force
+	)
+	{
+		
+		performedSearch_ = false;
+		if( !performSearch(iter, force) ) return true;
+
+		if(!getMethod().impl_broadSearch(
+			ppPairs,
+			pwPairs,
+			pointPos,
+			flags,
+			diameter))
+		{
+			fatalErrorInFunction<<
+			"Error in performing particle-particle broadSearch in method"<<
+			getMethod().typeName()<<endl;
+			return false;
+		}
+
+		lastUpdated_ = iter;
+		
+		performedSearch_ = true;		
+		return true;
+	}
\ No newline at end of file
diff --git a/src/Interaction/contactSearch/methods/particleWallContactSearchs.hpp b/src/Interaction/contactSearch/methods/particleWallContactSearchs.hpp
new file mode 100644
index 00000000..d72f9404
--- /dev/null
+++ b/src/Interaction/contactSearch/methods/particleWallContactSearchs.hpp
@@ -0,0 +1,123 @@
+/*------------------------------- 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 __particleWallContactSearchs_hpp__
+#define __particleWallContactSearchs_hpp__
+
+#include "pointFlag.hpp"
+#include "contactSearchGlobals.hpp"
+#include "box.hpp"
+
+namespace pFlow
+{
+template<typename method>
+class particleWallContactSearchs
+{
+public:
+
+	using MethodType 		= method;
+
+	using IndexType 		= uint32;
+
+	using execution_space 	= DefaultExecutionSpace;
+
+	using memory_space 		= typename execution_space::memory_space;
+
+private:
+
+	// friend 
+	friend 	MethodType;
+
+	/// @brief  box enclosing the simulation domain (local to processor)
+	box 		domainBox_;
+
+	/*/// @brief box enclosing the area for contact search (region with points)
+	box 		searchBox_;*/
+
+	/// @brief update interval in terms of iteration numebr 
+	uint32 		updateInterval_= 1;
+
+	/// @brief  last iteration number which contact search has been performed
+	uint32 		lastUpdated_ 	= 0;
+
+	/// @brief performed search? 
+	bool 		performedSearch_ = false;
+
+protected:
+
+	inline
+	auto& getMethod()
+	{
+		return static_cast<MethodType&>(*this);
+	}
+
+	inline
+	const auto& getMethod()const
+	{
+		return static_cast<const MethodType&>(*this);
+	}
+
+public:
+
+	particleWallContactSearchs(
+		const 	dictionary& dict,
+		const 	box& domain,
+		real  	minSize,
+		real 	maxSize,
+		const 	ViewType1D<realx3, memory_space>& position,
+		const 	pFlagTypeDevice &flags, 
+		const 	ViewType1D<real, memory_space>& diam
+	);
+
+	bool broadSearch
+	(
+		uint32 iter,
+		real t,
+		real dt,
+		csPairContainerType& ppPairs,
+		csPairContainerType& pwPairs,
+		const deviceViewType1D<realx3>& pointPos,
+    	const pFlagTypeDevice& flags,
+    	const deviceViewType1D<real>& diameter,
+		bool  force = false
+	);
+		
+	bool performedSearch()const
+	{
+		return performedSearch_;
+	}
+
+	bool performSearch(uint32 iter, bool force = false)const
+	{
+		if((iter-lastUpdated_) % updateInterval_ == 0 || iter == 0 || force )
+		{
+			return true;
+		}
+		return false;		
+	}
+
+};
+
+
+} // pFlow
+
+#include "particleWallContactSearchs.cpp"
+
+#endif //__particleWallContactSearchs_hpp__
\ No newline at end of file
diff --git a/src/Interaction/contactSearch/wallMappings/cellMapping.hpp b/src/Interaction/contactSearch/wallMappings/cellMapping.hpp
deleted file mode 100644
index 5a10c248..00000000
--- a/src/Interaction/contactSearch/wallMappings/cellMapping.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*------------------------------- phasicFlow ---------------------------------
-      O        C enter of
-     O O       E ngineering and
-    O   O      M ultiscale modeling of
-   OOOOOOO     F luid flow       
-------------------------------------------------------------------------------
-  Copyright (C): www.cemf.ir
-  email: hamid.r.norouzi AT gmail.com
-------------------------------------------------------------------------------  
-Licence:
-  This file is part of phasicFlow code. It is a free software for simulating 
-  granular and multiphase flows. You can redistribute it and/or modify it under
-  the terms of GNU General Public License v3 or any other later versions. 
- 
-  phasicFlow is distributed to help others in their research in the field of 
-  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
------------------------------------------------------------------------------*/
-
-#ifndef __cellMapping_hpp__
-#define __cellMapping_hpp__
-
-#include "cellsWallLevel0.hpp"
-#include "dictionary.hpp"
-
-
-namespace pFlow
-{
-
-template<
-	typename executionSpace
-	>
-class cellMapping
-{
-public:
-
-	using cellsWallLevel0Type = cellsWallLevel0<executionSpace>;
-
-	using IdType 			= typename cellsWallLevel0Type::IdType;
-
-	using IndexType 	= typename cellsWallLevel0Type::IndexType;
-
-	using Cells 			= typename cellsWallLevel0Type::Cells;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space = typename cellsWallLevel0Type::execution_space;
-
-	using memory_space 		= typename cellsWallLevel0Type::memory_space;
-
-	using iBoxType = iBox<IndexType>;	
-
-	
-protected:
-
-	// - update frequency 
-	int32 			updateFrequency_=1;
-
-	real 				cellExtent_;
-
-	int32 			currentIter_ = 0;
-
-	/// a broad search has been occured during last pass?
-	bool 				performedSearch_ = false;
-
-	cellsWallLevel0Type  cellsWallLevle_;
-		
-private:
-
-	bool performSearch()
-	{
-		if(currentIter_ % updateFrequency_ == 0)
-		{
-			currentIter_++;
-			return true;
-
-		}else
-		{
-			currentIter_++;
-			return false;
-		}
-	}
-
-public:
-
-	TypeInfoNV("cellMapping");
-
-	cellMapping(
-		const dictionary&  		dict,
-		int32 					numLevels,
-		const Vector<Cells>& 	ppCells,
-		int32 					numPoints,
-		int32 					numElements,
-		const ViewType1D<realx3,memory_space>& 		points, 
-		const ViewType1D<int32x3,memory_space>& 	vertices
-		)
-	:
-		updateFrequency_(
-			max(
-				dict.getValOrSet<int32>(
-					"updateFrequency",
-					1),
-				1)),
-		cellExtent_(
-			max(
-				dict.getValOrSet<real>(
-					"cellExtent", 
-					0.5),
-				0.5)),
-		cellsWallLevle_(
-			ppCells[0],
-			cellExtent_,
-			numPoints,
-			numElements,
-			points,
-			vertices
-			)
-	{}
-
-
-	bool enterBoadSearch()const
-	{
-		return currentIter_%updateFrequency_==0;
-	}
-
-	bool performedSearch()const
-	{
-		return performedSearch_;
-	}
-		
-	template<typename PairsContainer, typename particleMapType>
-	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap, bool force=false)
-	{
-		if(force) currentIter_ = 0;
-		performedSearch_= false;
-		if(!performSearch())return true;
-		
-		cellsWallLevle_.broadSearch(pairs, particleMap);
-
-		performedSearch_ = true;
-		return true;
-	}
-
-}; // cellMapping
-
-} // pFlow
-
-
-#endif 
diff --git a/src/Interaction/contactSearch/wallMappings/cellsWallLevel0.hpp b/src/Interaction/contactSearch/wallMappings/cellsWallLevel0.hpp
deleted file mode 100644
index 65034507..00000000
--- a/src/Interaction/contactSearch/wallMappings/cellsWallLevel0.hpp
+++ /dev/null
@@ -1,285 +0,0 @@
-/*------------------------------- 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 __cellsWallLevel0_hpp__
-#define __cellsWallLevel0_hpp__
-
-#include "types.hpp"
-#include "KokkosTypes.hpp"	
-#include "cells.hpp"
-#include "iBox.hpp"
-
-
-
-namespace pFlow
-{
-
-template<
-	typename executionSpace
-	>
-class cellsWallLevel0
-:
-	public cells<int32>
-{
-public:
-
-	using IdType		= int32;
-
-	using IndexType 	= int32;
-
-	using Cells 		= cells<IndexType>;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space = executionSpace;
-
-	using memory_space 	= typename execution_space::memory_space;
-
-	using iBoxType 		= iBox<IndexType>;	
-
-	class TagFindCellRange2{};
-
-protected:
-
-	// - box extent
-	real 			cellExtent_ = 0.5;
-
-	// - number of triangle elements 
-	int32			numElements_ = 0;
-
-	// - number of points
-	int32 			numPoints_ = 0;
-
-	// - ref to vectices (borrowed)
-	ViewType1D<int32x3, memory_space> 	vertices_;
-
-	// - ref to points in the trisurface (borrowed)
-	ViewType1D<realx3, memory_space> 	points_;
-
-	// cell range of element/triangle bounding box
-	ViewType1D<iBoxType, memory_space> 	elementBox_;
-	
-
-	using tpPWContactSearch = Kokkos::TeamPolicy<
-			execution_space,
-			Kokkos::Schedule<Kokkos::Dynamic>,
-			Kokkos::IndexType<int32>
-			>;
-
-	using rpFindCellRange2Type =
-		Kokkos::RangePolicy<TagFindCellRange2, execution_space, Kokkos::IndexType<int32>>;
-
-	
-	FUNCTION_H
-	void allocateArrays()
-	{
-		reallocNoInit( elementBox_, numElements_);
-	}
-
-public:
-
-	TypeInfoNV("cellsWallLevel0");
-
-	INLINE_FUNCTION_HD
-	cellsWallLevel0(){}
-
-	FUNCTION_H
-	cellsWallLevel0(
-		const Cells& 		ppCells,
-		real 						cellExtent,
-		int32 					numPoints,
-		int32 					numElements,
-		const ViewType1D<realx3,memory_space>& 		points, 
-		const ViewType1D<int32x3,memory_space>& 	vertices
-		)
-	:
-		Cells(ppCells),
-		cellExtent_( max(cellExtent, 0.5 ) ),
-		numElements_(numElements),
-		numPoints_(numPoints),
-		vertices_(vertices),
-		points_(points)
-	{
-
-		allocateArrays();
-	}
-
-	
-	// - host call
-	//   reset triangle elements if they have changed
-	bool resetElements( 
-		int32 			numElements,
-		int32       numPoints,
-		ViewType1D<realx3, memory_space>& points, 
-		ViewType1D<int32x3, memory_space>& vertices	)
-	{
-
-		numElements_ = numElements;
-		numPoints_ = numPoints;
-		points_ 	= points;
-		vertices_ 	= vertices;
-		
-		allocateArrays();
-
-		return true;
-	}
-
-	INLINE_FUNCTION_HD
-	iBoxType elementBox(int32 i)const
-	{
-		return elementBox_[i];
-	}
-
-	INLINE_FUNCTION_HD
-	int32 numElements()const
-	{
-		return numElements_;
-	}
-
-	
-		
-	template<typename PairsContainer, typename particleMapType>
-	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap)
-	{
-	
-		// map walls onto the cells
-		this->build();
-		
-		this->particleWallFindPairs(pairs, particleMap);
-		
-		return true;
-	}
-
-	bool build()
-	{
-		Kokkos::parallel_for(
-			"cellsSimple::findcellrange2",
-			rpFindCellRange2Type(0,numElements_),
-			*this);
-		Kokkos::fence();
-		return true;
-	}
-
-	template<typename PairsContainer, typename particleMapType>
-	bool particleWallFindPairs(PairsContainer& pairs, particleMapType& particleMap)
-	{
-
-		int32 getFull = 1;
-
-		while (getFull)
-		{
-			
-			getFull = findPairsElementRangeCount(pairs, particleMap.getCellIterator(0));
-			
-			if(getFull)
-			{
-				// - resize the container
-				//   note that getFull now shows the number of failed insertions.
-				uint32 len = max(getFull, 50);
-				auto oldCap = pairs.capacity();
-				pairs.increaseCapacityBy(len);
-
-				INFORMATION<<"Contact pair container capacity increased from "<<
-						oldCap << " to " 
-						<< pairs.capacity() <<" in cellsWallLevel0."<<endINFO;
-				
-				Kokkos::fence();
-			}
-		}
-		
-		return true;
-	}
-
-
-	template<typename PairsContainer, typename CellIteratorType>
-	int32 findPairsElementRangeCount(PairsContainer& pairs, CellIteratorType cellIter) 
-	{
-		int32 getFull =0;
-		
-		const auto pwPairs = pairs;
-		const auto elementBox = elementBox_;
-		
-		Kokkos::parallel_reduce(
-			"cellsSimple::findPairsElementRangeModified2",
-			tpPWContactSearch(numElements_, Kokkos::AUTO),
-			LAMBDA_HD(
-				const typename tpPWContactSearch::member_type & teamMember,
-				int32& valueToUpdate){
-				
-				const int32 iTri = teamMember.league_rank();
-
-				const auto triBox = elementBox[iTri];
-				
-				int32 getFull2 = 0;
-
-				auto bExtent = boxExtent(triBox);
-				int32 numCellBox = bExtent.x()*bExtent.y()*bExtent.z();
-
-				Kokkos::parallel_reduce( 
-					Kokkos::TeamThreadRange( teamMember, numCellBox ),
-					[&] ( const int32 linIndex, int32 &innerUpdate )
-						{
-							
-							CellType cell;
-							indexToCell(linIndex, triBox, cell);
-
-							int32 n = cellIter.start(cell.x(),cell.y(),cell.z());
-						
-							while( n>-1)
-							{
-								// id is wall id the pair is (particle id, wall id)
-								if( pairs.insert(static_cast<IdType>(n), iTri) < 0 )
-									innerUpdate++;
-								n = cellIter.getNext(n);
-							}
-
-						},
-					getFull2
-				);
-
-				if ( teamMember.team_rank() == 0 ) valueToUpdate += getFull2;
-			},
-			getFull
-			);
-
-		return getFull;
-	}
-
-	INLINE_FUNCTION_HD
-	void operator()(TagFindCellRange2, int32 i) const
-	{
-		auto v = vertices_[i];
-		auto p1 = points_[v.x()];
-		auto p2 = points_[v.y()];
-		auto p3 = points_[v.z()];
-		
-		realx3 minP, maxP;
-
-		this->extendBox(p1, p2, p3, cellExtent_, minP, maxP);
-		elementBox_[i] = iBoxType(this->pointIndex(minP), this->pointIndex(maxP));
-
-	}
-
-}; // cellsWallLevel0
-
-} // pFlow
-
-
-#endif // __cellsWallLevel0_hpp__
diff --git a/src/Interaction/contactSearch/wallMappings/cellsWallLevels.hpp b/src/Interaction/contactSearch/wallMappings/cellsWallLevels.hpp
deleted file mode 100644
index 9f2c80ec..00000000
--- a/src/Interaction/contactSearch/wallMappings/cellsWallLevels.hpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*------------------------------- phasicFlow ---------------------------------
-      O        C enter of
-     O O       E ngineering and
-    O   O      M ultiscale modeling of
-   OOOOOOO     F luid flow       
-------------------------------------------------------------------------------
-  Copyright (C): www.cemf.ir
-  email: hamid.r.norouzi AT gmail.com
-------------------------------------------------------------------------------  
-Licence:
-  This file is part of phasicFlow code. It is a free software for simulating 
-  granular and multiphase flows. You can redistribute it and/or modify it under
-  the terms of GNU General Public License v3 or any other later versions. 
- 
-  phasicFlow is distributed to help others in their research in the field of 
-  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
------------------------------------------------------------------------------*/
-
-#ifndef __cellsWallLevels_hpp__
-#define __cellsWallLevels_hpp__
-
-#include "cellsWallLevel0.hpp"
-
-namespace pFlow
-{
-
-template<
-	typename executionSpace
-	>
-class cellsWallLevels
-{
-public:
-
-	using cellsWallLevel0Type = cellsWallLevel0<executionSpace>;
-
-	using IdType 			= typename cellsWallLevel0Type::IdType;
-
-	using IndexType 	= typename cellsWallLevel0Type::IndexType;
-
-	using Cells 			= typename cellsWallLevel0Type::Cells;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space = typename cellsWallLevel0Type::execution_space;
-
-	using memory_space 		= typename cellsWallLevel0Type::memory_space;
-
-	using iBoxType = iBox<IndexType>;
-
-protected:
-
-	int32 			numLevles_=1;
-	
-
-	Vector<cellsWallLevel0Type> 			cellsWallLevels_;	
-
-public:
-
-	TypeInfoNV("cellsWallLevels");
-
-	FUNCTION_H
-	cellsWallLevels(
-		int32 					numLevels,
-		const Vector<Cells>&	cellsLevels,
-		real 					cellExtent,
-		int32 					numPoints,
-		int32 					numElements,
-		const ViewType1D<realx3,memory_space>& 		points, 
-		const ViewType1D<int32x3,memory_space>& 	vertices
-		)
-	:
-		numLevles_(numLevels),
-		cellsWallLevels_("cellsWallLevels",numLevels, numLevels, RESERVE())
-	{
-
-		
-
-		for(int32 lvl=0; lvl<numLevles_; lvl++)
-		{
-			cellsWallLevels_[lvl] = 
-				cellsWallLevel0Type(
-					cellsLevels[lvl],
-					cellExtent,
-					numPoints,
-					numElements,
-					points,
-					vertices);
-		}
-
-	}
-	
-		
-	template<typename PairsContainer, typename particleMapType>
-	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap)
-	{
-	
-		// map walls onto the cells
-		for(int32 lvl=0; lvl<numLevles_; lvl++)
-		{
-			cellsWallLevels_[lvl].build();
-		}
-		
-		this->particleWallFindPairs(pairs, particleMap);
-		
-		return true;
-	}
-
-	template<typename PairsContainer, typename particleMapType>
-	bool particleWallFindPairs(PairsContainer& pairs, particleMapType& particleMap)
-	{
-
-		int32 getFull = 1;
-
-		while (getFull)
-		{
-			getFull = 0;
-			for(int32 lvl=0; lvl<numLevles_; lvl++)
-			{
-				getFull += 
-					cellsWallLevels_[lvl].findPairsElementRangeCount(
-						pairs, 
-						particleMap.getCellIterator(lvl));
-			}
-			
-			if(getFull)
-			{
-				// - resize the container
-				//   note that getFull now shows the number of failed insertions.
-				uint32 len = max(getFull, 5000);
-				auto oldCap = pairs.capacity();
-				pairs.increaseCapacityBy(len);
-
-				INFORMATION<<"Contact pair container capacity increased from "<<
-						oldCap << " to " 
-						<< pairs.capacity() <<" in cellsWallLevels."<<endINFO;
-				
-				Kokkos::fence();
-			}
-		}
-		
-		return true;
-	}
-
-
-}; // cellsWallLevels
-
-} // pFlow
-
-
-#endif // __cellsWallLevels_hpp__
diff --git a/src/Interaction/contactSearch/wallMappings/multiGridMapping.hpp b/src/Interaction/contactSearch/wallMappings/multiGridMapping.hpp
deleted file mode 100644
index 3a266f1f..00000000
--- a/src/Interaction/contactSearch/wallMappings/multiGridMapping.hpp
+++ /dev/null
@@ -1,153 +0,0 @@
-/*------------------------------- phasicFlow ---------------------------------
-      O        C enter of
-     O O       E ngineering and
-    O   O      M ultiscale modeling of
-   OOOOOOO     F luid flow       
-------------------------------------------------------------------------------
-  Copyright (C): www.cemf.ir
-  email: hamid.r.norouzi AT gmail.com
-------------------------------------------------------------------------------  
-Licence:
-  This file is part of phasicFlow code. It is a free software for simulating 
-  granular and multiphase flows. You can redistribute it and/or modify it under
-  the terms of GNU General Public License v3 or any other later versions. 
- 
-  phasicFlow is distributed to help others in their research in the field of 
-  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
------------------------------------------------------------------------------*/
-
-#ifndef __multiGridMapping_hpp__
-#define __multiGridMapping_hpp__
-
-#include "cellsWallLevels.hpp"
-#include "dictionary.hpp"
-
-
-namespace pFlow
-{
-
-template<
-	typename executionSpace
-	>
-class multiGridMapping
-{
-public:
-
-	using CellsWallLevelType = cellsWallLevels<executionSpace>;
-
-	using IdType 			= typename CellsWallLevelType::IdType;
-
-	using IndexType 	= typename CellsWallLevelType::IndexType;
-
-	using Cells 			= typename CellsWallLevelType::Cells;
-
-	using CellType 		= typename Cells::CellType;
-
-	using execution_space = typename CellsWallLevelType::execution_space;
-
-	using memory_space 		= typename CellsWallLevelType::memory_space;
-
-	using iBoxType = iBox<IndexType>;	
-
-	
-protected:
-
-	// - update frequency 
-	int32 			updateFrequency_=1;
-
-	real 				cellExtent_;
-
-	int32 			currentIter_ = 0;
-
-	/// a broad search has been occured during last pass?
-	bool 				performedSearch_ = false;
-
-	CellsWallLevelType  cellsWallLevle_;
-		
-private:
-
-	bool performSearch()
-	{
-		if(currentIter_ % updateFrequency_ == 0)
-		{
-			currentIter_++;
-			return true;
-
-		}else
-		{
-			currentIter_++;
-			return false;
-		}
-	}
-
-public:
-
-	TypeInfoNV("multiGridMapping");
-
-	multiGridMapping(
-		const dictionary&  			dict,
-		int32 					numLevels,
-		const Vector<Cells>& 	ppCells,
-		int32 					numPoints,
-		int32 					numElements,
-		const ViewType1D<realx3,memory_space>& 		points, 
-		const ViewType1D<int32x3,memory_space>& 	vertices
-		)
-	:
-		updateFrequency_(
-			max(
-				dict.getVal<int32>("updateFrequency"),
-				1)),
-		cellExtent_(
-			max(
-				dict.getVal<real>("cellExtent"),
-				0.5)),
-		cellsWallLevle_(
-			numLevels,
-			ppCells,
-			cellExtent_,
-			numPoints,
-			numElements,
-			points,
-			vertices
-			)
-	{
-
-		REPORT(3)<<"Multi-grid wall mapping with "<< 
-			yellowText(numLevels)<<" levels has been created."<<endREPORT;
-	}
-
-
-	bool enterBoadSearch()const
-	{
-		return currentIter_%updateFrequency_==0;
-	}
-
-	bool performedSearch()const
-	{
-		return performedSearch_;
-	}
-		
-	template<typename PairsContainer, typename particleMapType>
-	bool broadSearch(PairsContainer& pairs, particleMapType& particleMap, bool force=false)
-	{
-		if(force) currentIter_ = 0;
-		performedSearch_= false;
-		if(!performSearch())return true;
-
-
-		cellsWallLevle_.broadSearch(pairs, particleMap);
-
-
-		performedSearch_ = true;
-		return true;
-	}
-
-}; // multiGridMapping
-
-} // pFlow
-
-
-#endif 
diff --git a/src/Interaction/interaction/interaction.cpp b/src/Interaction/interaction/interaction.cpp
index 8d368c29..ec8938d7 100644
--- a/src/Interaction/interaction/interaction.cpp
+++ b/src/Interaction/interaction/interaction.cpp
@@ -19,7 +19,9 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "interaction.hpp"
-
+#include "particles.hpp"
+#include "vocabs.hpp"
+#include "geometry.hpp"
 
 pFlow::interaction::interaction
 (
@@ -28,26 +30,16 @@ pFlow::interaction::interaction
 	const geometry& geom
 )
 :
-	demInteraction(control, control.caseSetup().path()+interactionFile__),
-	interactionBase(prtcl, geom),
-	fileDict_(control.caseSetup().emplaceObject<dictionary>(
-		objectFile(
-			interactionFile__,
-			"",
-			objectFile::READ_ALWAYS,
-			objectFile::WRITE_NEVER),
-		interactionFile__,
-		true ))
+	property(interactionFile__, &control.caseSetup()),
+	observer
+	(
+		&prtcl.dynPointStruct(),
+		msg_
+	),
+	demComponent("interaction", control),
+	particles_(prtcl),
+	geometry_(geom)
 {
-	this->subscribe(prtcl.pStruct());
-
-	contactSearch_ = contactSearch::create(
-		fileDict_.subDict("contactSearch"),
-		this->control().domain(),
-		prtcl,
-		geom,
-		timers()
-		 );
 
 }
 
@@ -79,14 +71,14 @@ pFlow::uniquePtr<pFlow::interaction> pFlow::interaction::create
 			clType);
 
 
-	REPORT(1)<< "Selecting interaction model..."<<endREPORT;
+	REPORT(1)<< "Selecting interaction model..."<<END_REPORT;
 	if( systemControlvCtorSelector_.search(interactionModel) )
 	{
 		auto objPtr = 
 			systemControlvCtorSelector_[interactionModel]
 			(control, prtcl, geom);
 
-		REPORT(2)<<"Model "<<greenText(interactionModel)<<" is created."<<endREPORT;
+		REPORT(2)<<"Model "<<Green_Text(interactionModel)<<" is created."<<END_REPORT;
 		return objPtr;
 	}
 	else
diff --git a/src/Interaction/interaction/interaction.hpp b/src/Interaction/interaction/interaction.hpp
index 97372bcc..c32f9f4f 100644
--- a/src/Interaction/interaction/interaction.hpp
+++ b/src/Interaction/interaction/interaction.hpp
@@ -21,9 +21,10 @@ Licence:
 #ifndef __interaction_hpp__
 #define __interaction_hpp__
 
-#include "demInteraction.hpp"
-#include "eventObserver.hpp"
-#include "interactionBase.hpp"
+#include "demComponent.hpp"
+#include "property.hpp"
+#include "observer.hpp"
+#include "systemControl.hpp"
 #include "contactSearch.hpp"
 
 
@@ -31,27 +32,26 @@ Licence:
 namespace pFlow
 {
 
+class particles;
+class geometry;
+
 class interaction
 :
-	public demInteraction,
-	public eventObserver,
-	public interactionBase
-{
-public:
+	public property,
+	public observer,
+	public demComponent
 	
-	using IdType 				= typename interactionBase::IdType;
+{
+private:
 
-	using IndexType    			= typename interactionBase::IndexType;
+	/// reference to particles object 
+	const particles& 	particles_;
 
-	using ExecutionSpace 	 	= typename interactionBase::ExecutionSpace;
+	/// reference to geometry object 
+	const geometry& 	geometry_;
 
-protected:
-
-	/// interaction file dictionary 
-	dictionary& 				fileDict_;
-
-	/// contact search object for pp and pw interactions 
-	uniquePtr<contactSearch> 	contactSearch_ = nullptr;
+	static inline
+	const message msg_ = message::ITEM_REARRANGE;
 
 public:
 
@@ -65,11 +65,10 @@ public:
 			const particles& prtcl,
 			const geometry& geom );
 		
+		~interaction() override = default;
 
-	
-		virtual ~interaction() = default;
-
-		create_vCtor(
+		create_vCtor
+		(
 			interaction,
 			systemControl,
 			(
@@ -78,22 +77,8 @@ public:
 				const geometry& geom
 			),
 			(control, prtcl, geom)
-			);
+		);
 	
-	auto& contactSearchPtr()
-	{
-		return contactSearch_;
-	}
-
-	auto& contactSearchRef()
-	{
-		return contactSearch_();
-	}
-
-	const auto& fileDict()const
-	{
-		return fileDict_;
-	}
 
 	static 
 	uniquePtr<interaction> create(
diff --git a/src/Interaction/sphereInteraction/sphereInteraction.cpp b/src/Interaction/sphereInteraction/sphereInteraction.cpp
index 0dacee74..1cb1472e 100644
--- a/src/Interaction/sphereInteraction/sphereInteraction.cpp
+++ b/src/Interaction/sphereInteraction/sphereInteraction.cpp
@@ -18,22 +18,18 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<
-	typename contactForceModel,
-	typename geometryMotionModel,
-	template <class, class, class> class contactListType >
-bool pFlow::sphereInteraction<contactForceModel,geometryMotionModel, contactListType>::
-	createSphereInteraction()
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+bool pFlow::sphereInteraction<cFM,gMM, cLT>::createSphereInteraction()
 {
 	
-	realVector_D rhoD(this->densities());
+	realVector_D rhoD("densities", this->densities());
 
-	auto modelDict = this->fileDict().subDict("model");
+	auto modelDict = this->subDict("model");
 
-	REPORT(1)<<"Createing contact force model . . ."<<endREPORT;
+	REPORT(1)<<"Createing contact force model . . ."<<END_REPORT;
 	forceModel_ = makeUnique<ContactForceModel>(
 		this->numMaterials(),
-		rhoD.deviceVector(),
+		rhoD.deviceView(),
 		modelDict );
 
 
@@ -47,17 +43,9 @@ bool pFlow::sphereInteraction<contactForceModel,geometryMotionModel, contactList
 }
 
 
-
-template<
-	typename contactForceModel,
-	typename geometryMotionModel,
-	template <class, class, class> class contactListType >
-bool pFlow::sphereInteraction<contactForceModel,geometryMotionModel, contactListType>::
-	sphereSphereInteraction()
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+bool pFlow::sphereInteraction<cFM,gMM, cLT>::sphereSphereInteraction()
 {
-	
-
-
 	auto lastItem = ppContactList_().loopCount();
 
 	// create the kernel functor 
@@ -66,17 +54,17 @@ bool pFlow::sphereInteraction<contactForceModel,geometryMotionModel, contactList
 			this->dt(),
 			this->forceModel_(),
 			ppContactList_(), // to be read
-			sphParticles_.diameter().deviceVectorAll(),
-			sphParticles_.propertyId().deviceVectorAll(),
-			sphParticles_.pointPosition().deviceVectorAll(),
-			sphParticles_.velocity().deviceVectorAll(),
-			sphParticles_.rVelocity().deviceVectorAll(),
-			sphParticles_.contactForce().deviceVectorAll(),
-			sphParticles_.contactTorque().deviceVectorAll()
+			sphParticles_.diameter().deviceViewAll(),
+			sphParticles_.propertyId().deviceViewAll(),
+			sphParticles_.pointPosition().deviceViewAll(),
+			sphParticles_.velocity().deviceViewAll(),
+			sphParticles_.rVelocity().deviceViewAll(),
+			sphParticles_.contactForce().deviceViewAll(),
+			sphParticles_.contactTorque().deviceViewAll()
 			);
 	
 	Kokkos::parallel_for(
-		"",
+		"ppInteraction",
 		rpPPInteraction(0,lastItem),
 		ppInteraction
 		);
@@ -87,34 +75,32 @@ bool pFlow::sphereInteraction<contactForceModel,geometryMotionModel, contactList
 }
 
 
-template<
-	typename contactForceModel,
-	typename geometryMotionModel,
-	template <class, class, class> class contactListType >
-bool pFlow::sphereInteraction<contactForceModel,geometryMotionModel, contactListType>::
-	sphereWallInteraction()
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+bool pFlow::sphereInteraction<cFM,gMM, cLT>::sphereWallInteraction()
 {
 	
-	int32 lastItem = pwContactList_().loopCount();
+	uint32 lastItem = pwContactList_().loopCount();
+	uint32 iter = this->currentIter();
 	real t = this->currentTime();
+	real dt = this->dt();
 
 	pFlow::sphereInteractionKernels::pwInteractionFunctor
 		pwInteraction(
-			this->dt(),
+			dt,
 			this->forceModel_(),
 			pwContactList_(),
 			geometryMotion_.getTriangleAccessor(), 
-			geometryMotion_.getModel(t) , 
-			sphParticles_.diameter().deviceVectorAll() ,
-			sphParticles_.propertyId().deviceVectorAll(),
-			sphParticles_.pointPosition().deviceVectorAll(),
-			sphParticles_.velocity().deviceVectorAll(),
-			sphParticles_.rVelocity().deviceVectorAll() ,
-			sphParticles_.contactForce().deviceVectorAll(),
-			sphParticles_.contactTorque().deviceVectorAll() ,
-			geometryMotion_.triMotionIndex().deviceVectorAll(),
-			geometryMotion_.propertyId().deviceVectorAll(),
-			geometryMotion_.contactForceWall().deviceVectorAll()
+			geometryMotion_.getModel(iter, t, dt) , 
+			sphParticles_.diameter().deviceViewAll() ,
+			sphParticles_.propertyId().deviceViewAll(),
+			sphParticles_.pointPosition().deviceViewAll(),
+			sphParticles_.velocity().deviceViewAll(),
+			sphParticles_.rVelocity().deviceViewAll() ,
+			sphParticles_.contactForce().deviceViewAll(),
+			sphParticles_.contactTorque().deviceViewAll() ,
+			geometryMotion_.triMotionIndex().deviceViewAll(),
+			geometryMotion_.propertyId().deviceViewAll(),
+			geometryMotion_.contactForceWall().deviceViewAll()
 		);
 
 	Kokkos::parallel_for(
@@ -127,4 +113,123 @@ bool pFlow::sphereInteraction<contactForceModel,geometryMotionModel, contactList
 	Kokkos::fence();
 
 	return true;
-}
\ No newline at end of file
+}
+
+
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+pFlow::sphereInteraction<cFM,gMM, cLT>::sphereInteraction
+(
+	systemControl& control,
+	const particles& prtcl,
+	const geometry& geom
+)
+:
+	interaction(control, prtcl, geom),
+	geometryMotion_(dynamic_cast<const GeometryMotionModel&>(geom)),
+	sphParticles_(dynamic_cast<const sphereParticles&>(prtcl)),
+	ppInteractionTimer_("sphere-sphere interaction", &this->timers()),
+	pwInteractionTimer_("sphere-wall interaction", &this->timers()),
+	contactListTimer_("contact list management", &this->timers()),
+	contactListTimer0_("contact list clear", &this->timers())
+{
+	contactSearch_ = contactSearch::create(
+	subDict("contactSearch"),
+	prtcl.thisDomain().domainBox(),
+	prtcl,
+	geom,
+	timers());
+
+
+	if(!createSphereInteraction())
+	{
+		fatalExit;
+	}
+}
+
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+bool pFlow::sphereInteraction<cFM,gMM, cLT>::beforeIteration()
+{
+	return true;
+}
+
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
+{
+	
+	auto iter = this->currentIter();
+	auto t = this->currentTime();
+	auto dt = this->dt();
+
+	//output<<"iter, t, dt "<< iter<<" "<< t << " "<<dt<<endl;
+	bool broadSearch = contactSearch_().enterBroadSearch(iter, t, dt);
+
+
+	if(broadSearch)
+	{
+		contactListTimer0_.start();
+		ppContactList_().beforeBroadSearch();
+		pwContactList_().beforeBroadSearch();
+		contactListTimer0_.end();
+	} 
+	
+	if( sphParticles_.numActive()<=0)return true;
+	
+	
+	if( !contactSearch_().broadSearch(
+			iter,
+			t,
+			dt,		
+			ppContactList_(),
+			pwContactList_()) )
+	{
+		fatalErrorInFunction<<
+		"unable to perform broadSearch.\n";
+		fatalExit;
+	}
+	
+
+	
+	if(broadSearch && contactSearch_().performedBroadSearch())
+	{
+		contactListTimer_.start();
+		ppContactList_().afterBroadSearch();
+		pwContactList_().afterBroadSearch();
+		contactListTimer_.end();
+	}
+	
+	ppInteractionTimer_.start();
+		sphereSphereInteraction();
+	ppInteractionTimer_.end();
+
+	
+	pwInteractionTimer_.start();
+		sphereWallInteraction();
+	pwInteractionTimer_.end();
+
+	
+	return true;
+}
+
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+bool pFlow::sphereInteraction<cFM,gMM, cLT>::afterIteration()
+{
+	return true;
+}
+
+template<typename cFM,typename gMM,template <class, class, class> class cLT>
+bool pFlow::sphereInteraction<cFM,gMM, cLT>::hearChanges
+(
+	real t,
+	real dt,
+	uint32 iter,
+	const message& msg, 
+	const anyList& varList
+)
+{
+	if(msg.equivalentTo(message::ITEM_REARRANGE))
+	{
+		notImplementedFunction;
+	}
+	return true;
+}
+
diff --git a/src/Interaction/sphereInteraction/sphereInteraction.hpp b/src/Interaction/sphereInteraction/sphereInteraction.hpp
index b256c452..56c00047 100644
--- a/src/Interaction/sphereInteraction/sphereInteraction.hpp
+++ b/src/Interaction/sphereInteraction/sphereInteraction.hpp
@@ -23,7 +23,6 @@ Licence:
 
 #include "interaction.hpp"
 #include "sphereParticles.hpp"
-
 #include "sphereInteractionKernels.hpp"
 
 namespace pFlow
@@ -43,22 +42,19 @@ public:
 	
 	using ContactForceModel 	= contactForceModel;
 
-	using MotionModel 		= typename geometryMotionModel::MotionModel;
+	using MotionModel 			= typename geometryMotionModel::MotionModel;
 
-	using ModelStorage 		= typename ContactForceModel::contactForceStorage;
+	using ModelStorage 			= typename ContactForceModel::contactForceStorage;
 	
-	using IdType 			= typename interaction::IdType;
+	using IdType 			= uint32;
 
-	using IndexType    		= typename interaction::IndexType;
-
-	using ExecutionSpace 	= typename interaction::ExecutionSpace;
+	using IndexType    		= uint32;
 
 	using ContactListType 	= 
-			contactListType<ModelStorage, ExecutionSpace, IdType>;
+			contactListType<ModelStorage, DefaultExecutionSpace, IdType>;
 
-	using PairsContainerType= typename contactSearch::PairContainerType;
 
-protected:
+private:
 	
 	/// const reference to geometry
 	const GeometryMotionModel& 			geometryMotion_;
@@ -66,15 +62,17 @@ protected:
 	/// const reference to particles 
 	const sphereParticles& 				sphParticles_;
 
+	/// contact search object for pp and pw interactions 
+	uniquePtr<contactSearch> 			contactSearch_ = nullptr;
 
 	/// contact force model 
-	uniquePtr<ContactForceModel>  	forceModel_ 	= nullptr;
+	uniquePtr<ContactForceModel>  		forceModel_ 	= nullptr;
 
 	/// contact list for particle-particle interactoins (keeps the history)
-	uniquePtr<ContactListType> 		ppContactList_ = nullptr;
+	uniquePtr<ContactListType> 			ppContactList_ = nullptr;
 
 	/// contact list for particle-wall interactions (keeps the history)
-	uniquePtr<ContactListType> 		pwContactList_ = nullptr;	
+	uniquePtr<ContactListType> 			pwContactList_ = nullptr;	
 
 	/// timer for particle-particle interaction computations
 	Timer 		ppInteractionTimer_;
@@ -82,42 +80,39 @@ protected:
 	/// timer for particle-wall interaction computations
 	Timer       pwInteractionTimer_;
 
+	Timer 		contactListTimer_;
+
+	Timer 		contactListTimer0_;
+
 	bool createSphereInteraction();
 
-	bool managePPContactLists();
+	bool sphereSphereInteraction();
 
-	bool managePWContactLists();
+	bool sphereWallInteraction();
+
+	//bool managePPContactLists();
+
+	//bool managePWContactLists();
 
 	/// range policy for p-p interaction execution 
 	using rpPPInteraction = 
-		Kokkos::RangePolicy<Kokkos::IndexType<int32>, Kokkos::Schedule<Kokkos::Dynamic>>;
+		Kokkos::RangePolicy<Kokkos::IndexType<uint32>, Kokkos::Schedule<Kokkos::Dynamic>>;
 
 	/// range policy for p-w interaction execution 
 	using rpPWInteraction = rpPPInteraction;
 
 public:
 
-	TypeInfoTemplate3("sphereInteraction", ContactForceModel, MotionModel, ContactListType);
-
-	// constructor
+	TypeInfoTemplate13("sphereInteraction", ContactForceModel, MotionModel, ContactListType);
 
+	/// Constructor from components
 	sphereInteraction(
 		systemControl& control,
 		const particles& prtcl,
-		const geometry& geom)
-	:
-		interaction(control, prtcl, geom),
-		geometryMotion_(dynamic_cast<const GeometryMotionModel&>(geom)),
-		sphParticles_(dynamic_cast<const sphereParticles&>(prtcl)),
-		ppInteractionTimer_("sphere-sphere interaction", &this->timers()),
-		pwInteractionTimer_("sphere-wall interaction", &this->timers())
-	{
-		if(!createSphereInteraction())
-		{
-			fatalExit;
-		}
-	}
+		const geometry& geom);
+	
 
+	/// Add virtual constructor 
 	add_vCtor
 	(
 		interaction,
@@ -125,97 +120,25 @@ public:
 		systemControl
 	);
 
+	/// This is called in time loop, before iterate. (overriden from demComponent)
+	bool beforeIteration() override;
+	
+	/// This is called in time loop. Perform the main calculations 
+	/// when the component should evolve along time. (overriden from demComponent)
+	bool iterate() override; 
+	
+	/// This is called in time loop, after iterate. (overriden from demComponent)
+	bool afterIteration() override;
 
-	bool beforeIteration() override
-	{
-		return true;
-	}
-
-
-	bool iterate() override
-	{
-
-//Info<<"before contact search"<<endInfo;
-		////Info<<"interaction iterrate start"<<endInfo;
-		if(this->contactSearch_)
-		{
-
-			if( this->contactSearch_().ppEnterBroadSearch())
-			{
-				//Info<<" before ppEnterBroadSearch"<<endInfo;
-				ppContactList_().beforeBroadSearch();
-				//Info<<" after ppEnterBroadSearch"<<endInfo;
-			}
-
-			if(this->contactSearch_().pwEnterBroadSearch())
-			{
-				//Info<<" before pwEnterBroadSearch"<<endInfo;
-				pwContactList_().beforeBroadSearch();
-				//Info<<" after pwEnterBroadSearch"<<endInfo;
-			}
-
-			//Info<<" before broadSearch"<<endInfo;
-			if( !contactSearch_().broadSearch(
-					ppContactList_(),
-					pwContactList_()) )
-			{
-				fatalErrorInFunction<<
-				"unable to perform broadSearch.\n";
-				fatalExit;
-			}
-
-			//Info<<" before broadSearch"<<endInfo;
-
-
-			if(this->contactSearch_().ppPerformedBroadSearch())
-			{
-				//Info<<" before afterBroadSearch"<<endInfo;
-				ppContactList_().afterBroadSearch();
-				//Info<<" after afterBroadSearch"<<endInfo;
-			}
-
-			if(this->contactSearch_().pwPerformedBroadSearch())
-			{
-				//Info<<" before pwContactList_().afterBroadSearch()"<<endInfo;
-				pwContactList_().afterBroadSearch();
-				//Info<<" after pwContactList_().afterBroadSearch()"<<endInfo;
-			}
-		}
-//Info<<"after contact search"<<endInfo;
-
-		if( sphParticles_.numActive()<=0)return true;
-//Info<<"before sphereSphereInteraction "<<endInfo;
-		ppInteractionTimer_.start();
-			sphereSphereInteraction();
-		ppInteractionTimer_.end();
-//Info<<"after sphereSphereInteraction "<<endInfo;
-
-//Info<<"before sphereWallInteraction "<<endInfo;
-		pwInteractionTimer_.start();
-			sphereWallInteraction();
-		pwInteractionTimer_.end();
-//Info<<"after sphereWallInteraction "<<endInfo;
-		
-		return true;
-	}
-
-
-	bool afterIteration() override
-	{
-		return true;
-	}
-
-
-	bool update(const eventMessage& msg)override
-	{
-		// it requires not action regarding any changes in the 
-		// point structure 
-		return true;
-	}
-
-	bool sphereSphereInteraction();
-
-	bool sphereWallInteraction();
+	/// Check for changes in the point structures. (overriden from observer)
+	bool hearChanges(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+		const anyList& varList)override;
+	
+	
 };
 
 
diff --git a/src/Interaction/sphereInteraction/sphereInteractionKernels.hpp b/src/Interaction/sphereInteraction/sphereInteractionKernels.hpp
index cef5fa72..c581d598 100644
--- a/src/Interaction/sphereInteraction/sphereInteractionKernels.hpp
+++ b/src/Interaction/sphereInteraction/sphereInteractionKernels.hpp
@@ -42,7 +42,7 @@ struct ppInteractionFunctor
 	ContactListType   tobeFilled_;
 
 	deviceViewType1D<real>  		diam_;
-	deviceViewType1D<int8> 			propId_;
+	deviceViewType1D<uint32> 		propId_;
 	deviceViewType1D<realx3>  		pos_;
 	deviceViewType1D<realx3>  		lVel_;
 	deviceViewType1D<realx3>  		rVel_;
@@ -55,7 +55,7 @@ struct ppInteractionFunctor
 		ContactForceModel 		forceModel,
 		ContactListType 		tobeFilled,
 		deviceViewType1D<real>  		diam,
-		deviceViewType1D<int8> 			propId,
+		deviceViewType1D<uint32> 		propId,
 		deviceViewType1D<realx3>  		pos,
 		deviceViewType1D<realx3>  		lVel,
 		deviceViewType1D<realx3>  		rVel,
@@ -75,7 +75,7 @@ struct ppInteractionFunctor
 	{}
 
 	INLINE_FUNCTION_HD
-	void operator()(const int32 n)const
+	void operator()(const uint32 n)const
 	{
 		
 		if(!tobeFilled_.isValid(n))return;
@@ -181,14 +181,14 @@ struct pwInteractionFunctor
 	MotionModel  			motionModel_;
 
 	deviceViewType1D<real>  	diam_;
-	deviceViewType1D<int8> 		propId_;
+	deviceViewType1D<uint32>	propId_;
 	deviceViewType1D<realx3>  	pos_;
 	deviceViewType1D<realx3>  	lVel_;
 	deviceViewType1D<realx3>  	rVel_;
 	deviceViewType1D<realx3>	cForce_;
 	deviceViewType1D<realx3>	cTorque_;
-	deviceViewType1D<int8> 		wTriMotionIndex_;
-	deviceViewType1D<int8>      wPropId_;
+	deviceViewType1D<uint32> 	wTriMotionIndex_;
+	deviceViewType1D<uint32>    wPropId_;
 	deviceViewType1D<realx3>    wCForce_;
 	
 
@@ -199,14 +199,14 @@ struct pwInteractionFunctor
 		TraingleAccessor		triangles,
 		MotionModel 			motionModel ,
 		deviceViewType1D<real>  	diam ,
-		deviceViewType1D<int8>  	propId,
+		deviceViewType1D<uint32>  	propId,
 		deviceViewType1D<realx3>   	pos ,
 		deviceViewType1D<realx3>   	lVel,
 		deviceViewType1D<realx3>   	rVel,
 		deviceViewType1D<realx3> 	cForce,
 		deviceViewType1D<realx3> 	cTorque ,
-		deviceViewType1D<int8> 		wTriMotionIndex,
-		deviceViewType1D<int8>      wPropId,
+		deviceViewType1D<uint32> 	wTriMotionIndex,
+		deviceViewType1D<uint32>    wPropId,
 		deviceViewType1D<realx3>    wCForce)
 	:
 		dt_(dt),
diff --git a/src/Interaction/sphereInteraction/sphereInteractions.cpp b/src/Interaction/sphereInteraction/sphereInteractions.cpp
index 569fa7ad..1bd0da9c 100644
--- a/src/Interaction/sphereInteraction/sphereInteractions.cpp
+++ b/src/Interaction/sphereInteraction/sphereInteractions.cpp
@@ -28,22 +28,22 @@ Licence:
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::unsortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::sortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::unsortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::sortedContactList>;
 
 template class pFlow::sphereInteraction<
@@ -88,7 +88,7 @@ template class pFlow::sphereInteraction<
 	pFlow::sortedContactList>;
 
 
-template class pFlow::sphereInteraction<
+/*template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedLinearNormalRolling,
 	pFlow::multiRotationAxisMotionGeometry,
 	pFlow::unsortedContactList>;
@@ -106,28 +106,28 @@ template class pFlow::sphereInteraction<
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedLinearNormalRolling,
 	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
+	pFlow::sortedContactList>;*/
 
 /// non-linear models 
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::unsortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::sortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::unsortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::sortedContactList>;
 
 template class pFlow::sphereInteraction<
@@ -171,7 +171,7 @@ template class pFlow::sphereInteraction<
 	pFlow::vibratingMotionGeometry,
 	pFlow::sortedContactList>;
 
-template class pFlow::sphereInteraction<
+/*template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedNonLinearNormalRolling,
 	pFlow::multiRotationAxisMotionGeometry,
 	pFlow::unsortedContactList>;
@@ -189,28 +189,28 @@ template class pFlow::sphereInteraction<
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
 	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
+	pFlow::sortedContactList>;*/
 
 
 // - nonLinearMod models
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::unsortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::sortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::unsortedContactList>;
 
 template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::fixedGeometry,
+	pFlow::stationaryGeometry,
 	pFlow::sortedContactList>;
 
 template class pFlow::sphereInteraction<
@@ -255,7 +255,7 @@ template class pFlow::sphereInteraction<
 	pFlow::sortedContactList>;
 
 
-template class pFlow::sphereInteraction<
+/*template class pFlow::sphereInteraction<
 	pFlow::cfModels::limitedNonLinearModNormalRolling,
 	pFlow::multiRotationAxisMotionGeometry,
 	pFlow::unsortedContactList>;
@@ -274,3 +274,4 @@ template class pFlow::sphereInteraction<
 	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
 	pFlow::multiRotationAxisMotionGeometry,
 	pFlow::sortedContactList>;
+*/
\ No newline at end of file
diff --git a/src/MotionModel/CMakeLists.txt b/src/MotionModel/CMakeLists.txt
index 9438c2ab..b0b084fd 100644
--- a/src/MotionModel/CMakeLists.txt
+++ b/src/MotionModel/CMakeLists.txt
@@ -1,13 +1,19 @@
 
 list(APPEND SourceFiles 
-entities/rotatingAxis/rotatingAxis.cpp
-entities/multiRotatingAxis/multiRotatingAxis.cpp
 entities/timeInterval/timeInterval.cpp
-entities/vibrating/vibrating.cpp
-fixedWall/fixedWall.cpp
+
+entities/rotatingAxis/rotatingAxis.cpp
 rotatingAxisMotion/rotatingAxisMotion.cpp
-multiRotatingAxisMotion/multiRotatingAxisMotion.cpp
+
+entities/vibrating/vibrating.cpp
 vibratingMotion/vibratingMotion.cpp
+
+stationaryWall/stationaryWall.cpp
+entities/stationary/stationary.cpp
+
+#entities/multiRotatingAxis/multiRotatingAxis.cpp
+#multiRotatingAxisMotion/multiRotatingAxisMotion.cpp
+
 )
 
 set(link_libs Kokkos::kokkos phasicFlow)
diff --git a/src/MotionModel/MotionModel/MotionModel.cpp b/src/MotionModel/MotionModel/MotionModel.cpp
new file mode 100644
index 00000000..6a530eaa
--- /dev/null
+++ b/src/MotionModel/MotionModel/MotionModel.cpp
@@ -0,0 +1,147 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+
+template<typename Model, typename Component>
+inline
+bool pFlow::MotionModel<Model, Component>::impl_nameToIndex(const word& name, uint32& indx)const
+{
+	if( auto i = componentNames_.findi(name); i == -1)
+	{
+		return false;
+	}
+	else
+	{
+		indx = static_cast<uint32>(i);
+		return true;
+	}
+	
+}
+
+template<typename Model, typename Component>
+inline
+bool pFlow::MotionModel<Model, Component>::impl_indexToName(uint32 i, word& name)const
+{
+	if(i < numComponents_ )
+	{
+		name = componentNames_[i];
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+template<typename Model, typename Component>
+inline
+bool pFlow::MotionModel<Model, Component>::impl_readDictionary
+(
+	const dictionary& dict
+)
+{
+	
+	auto modelName = dict.getVal<word>("motionModel");
+
+	if(modelName != getTypeName<ModelComponent>())
+	{
+		fatalErrorInFunction<<
+		"  motionModel should be "<< Yellow_Text(getTypeName<ModelComponent>())<<
+		", but found "<< Yellow_Text(modelName)<<endl;
+		return false;
+	}
+
+	auto& motionInfo = dict.subDict(modelName+"Info");
+	auto compNames = motionInfo.dictionaryKeywords();
+	
+	Vector<ModelComponent> components(
+		"Read::modelComponent", 
+		compNames.size()+1, 
+		0, 
+		RESERVE());
+	
+	componentNames_.clear();
+
+		
+	for(auto& cName: compNames)
+	{
+		auto& compDict = motionInfo.subDict(cName);
+		
+		if(auto compPtr = makeUnique<ModelComponent>(compDict); compPtr)
+		{
+			components.push_back(compPtr());
+			componentNames_.push_back(cName);
+		}
+	}
+
+	if( !componentNames_.search("none") )
+	{
+		components.push_back
+		(
+			impl_noneComponent()
+		);
+		componentNames_.push_back("none");	
+	}
+
+	motionComponents_.assign(components);
+	numComponents_ = motionComponents_.size();
+
+	return true;
+}
+
+
+template<typename Model, typename Component>
+inline
+bool pFlow::MotionModel<Model, Component>::impl_writeDictionary
+(
+	dictionary& dict
+)const
+{
+	word modelName = getTypeName<ModelComponent>();
+
+	dict.add("motionModel", modelName );
+
+	auto modelDictName = modelName+"Info";
+
+	auto& motionInfo = dict.subDictOrCreate(modelDictName);
+	auto hostComponents = motionComponents_.hostView();
+
+	ForAll(i, motionComponents_)
+	{
+		
+		auto& axDict = motionInfo.subDictOrCreate(componentNames_[i]);
+		if( !hostComponents[i].write(axDict))
+		{
+			fatalErrorInFunction<<
+			"  error in writing axis "<< componentNames_[i] << " to dicrionary "
+			<< motionInfo.globalName()<<endl;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+template<typename Model, typename Component>
+pFlow::MotionModel<Model, Component>::MotionModel()
+:
+	motionComponents_("motionComponents")
+{}
\ No newline at end of file
diff --git a/src/MotionModel/MotionModel/MotionModel.hpp b/src/MotionModel/MotionModel/MotionModel.hpp
new file mode 100644
index 00000000..6dae3175
--- /dev/null
+++ b/src/MotionModel/MotionModel/MotionModel.hpp
@@ -0,0 +1,246 @@
+/*------------------------------- 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 __MotionModel_hpp__
+#define __MotionModel_hpp__
+
+
+
+#include "VectorSingles.hpp"
+#include "Vector.hpp"
+#include "List.hpp"
+#include "dictionary.hpp"
+
+
+namespace pFlow
+{
+
+/**
+ * @brief Motion model abstract class (CRTP) for all the motion models 
+*/
+template<typename Model, typename Component>
+class MotionModel
+{
+public:
+
+	using ModelType = Model;
+
+	using ModelComponent = Component;
+	
+	using ComponentVector_D = VectorSingle<ModelComponent>;
+
+	/** Motion model class to be passed to computational units/kernels for
+	 *  transfing points and returning velocities at various positions
+	 */
+	class ModelInterface
+	{
+	private:
+		
+		deviceViewType1D<ModelComponent> 	components_;
+
+		uint32 							numComponents_=0;
+
+	public:
+
+		INLINE_FUNCTION_HD
+		ModelInterface
+		(
+			deviceViewType1D<ModelComponent> Comps, 
+			uint32 numComp
+		):
+			components_(Comps),
+			numComponents_(numComp)
+		{}
+
+		INLINE_FUNCTION_HD
+		ModelInterface(const ModelInterface&) = default;
+		
+		INLINE_FUNCTION_HD
+		ModelInterface& operator=(const ModelInterface&) = default;
+
+		INLINE_FUNCTION_HD
+		ModelInterface(ModelInterface&&) noexcept = default;
+
+		INLINE_FUNCTION_HD
+		ModelInterface& operator=(ModelInterface&&) noexcept= default;
+		
+		INLINE_FUNCTION_HD
+		~ModelInterface()=default;
+
+		INLINE_FUNCTION_HD
+		realx3 pointVelocity(uint32 n, const realx3& p)const
+		{
+			return components_[n].linVelocityPoint(p);
+		}
+
+		INLINE_FUNCTION_HD
+		realx3 operator()(uint32 n, const realx3& p)const
+		{
+			return pointVelocity(n,p);
+		}
+
+		INLINE_FUNCTION_HD
+		realx3 transferPoint(uint32 n, const realx3 p, real dt)const
+		{
+			return components_[n].transferPoint(p, dt); 
+		}
+
+		INLINE_FUNCTION_HD 
+		uint32 size()const
+		{
+			return numComponents_;
+		}
+	};
+
+private:
+
+	// friends
+	friend ModelType;
+
+	/// Number of axes components
+	uint32  			numComponents_= 0;
+
+	/// Vector to store motion components 
+	ComponentVector_D 	motionComponents_;
+	
+	/// Names of compoenents
+	wordList  			componentNames_;
+
+protected:
+	
+	/// @brief  obtain a reference to the actual motion model
+	inline
+	auto& getModel()
+	{
+		return static_cast<ModelType&>(*this);
+	}
+
+	/// @brief  Obtain a const reference to the actual motion model 
+	inline
+	const auto& getModel()const
+	{
+		return static_cast<const ModelType&>(*this);
+	}
+
+	/// Return a none object for the motion model 
+	inline
+	auto impl_noneComponent()const
+	{
+		return ModelType::noneComponent();
+	}
+	
+	/// Name of the compoenent to index of the component 
+	bool impl_nameToIndex(const word& name, uint32& idx)const;
+	
+	/// Component index to motion component name
+	bool impl_indexToName(uint32 i, word& name)const;
+
+	/// const reference to the list of component names 
+	inline 
+	const wordList& impl_componentNames()const
+	{
+		return componentNames_;
+	}
+
+	/// Return model interface 
+	auto impl_getModelInterface(uint32 iter, real t, real dt)const
+	{
+		getModel().impl_setTime(iter, t, dt);
+
+		return ModelInterface(
+			motionComponents_.deviceViewAll(), 
+			numComponents_);
+	}
+
+	/// Read from dictionary 
+	bool impl_readDictionary(const dictionary& dict);
+
+	/// Write to dictionary 
+	bool impl_writeDictionary(dictionary& dict)const;
+
+public:
+
+	// - Constructors 
+	
+		/// Empty
+		MotionModel();
+
+		/// Copy constructor 
+		MotionModel(const MotionModel&) = default;
+
+		/// Move constructor 
+		MotionModel(MotionModel&&) = default;
+
+		/// Copy assignment
+		MotionModel& operator=(const MotionModel&) = default;
+
+		/// No move assignment
+		MotionModel& operator=(MotionModel&&) = default;
+
+		/// Destructor 
+		~MotionModel() = default;
+
+	// - Methods
+		
+		/// name of the compoenent to index of the component 
+		bool nameToIndex(const word& name, uint32& idx)const
+		{
+			return getModel().impl_nameToIndex(name, idx);
+		}
+	
+		/// Component index to motion component name 
+		bool indexToName(uint32 idx, word& name)const
+		{
+			return getModel().impl_indexToName(idx, name);
+		}
+
+		/// @brief  Return a const reference to the list of compoenent names 
+		/// @return 
+		const wordList& componentNames()const
+		{
+			return getModel().impl_componentNames();
+		}
+		
+		/// Is the wall assocciated to this motion component moving?
+		bool isMoving()const
+		{
+			return getModel().impl_isMoving();
+		}
+
+		/// Move the component itself
+		bool move(uint32 iter, real t, real dt)
+		{
+			return getModel().impl_move(iter, t, dt);
+		}
+
+		/// Obtain an object to model interface 
+		auto getModelInterface(uint32 iter, real t, real dt)const
+		{
+			return getModel().impl_getModelInterface(iter, t, dt);
+		}
+
+};
+
+} // pFlow
+
+#include "MotionModel.cpp"
+
+
+#endif //__MotionModel_hpp__
diff --git a/src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp b/src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp
index 2f2d81de..c79e87c8 100644
--- a/src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp
+++ b/src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp
@@ -78,7 +78,7 @@ class multiRotatingAxis
 {
 protected:
 
-	/// This is either host/device pointer to all axes
+	/// This is device pointer to all axes
 	multiRotatingAxis*		axisList_;
 
 	/// Index of parent axis
@@ -170,7 +170,7 @@ public:
 		/// Set the pointer to the list of all axes.
 		/// This pointer is device pointer 
 		INLINE_FUNCTION_H
-		void setAxisList(multiRotatingAxis* axisList)
+		void setAxisListPtr(multiRotatingAxis* axisList)
 		{
 			axisList_ = axisList;
 		}
diff --git a/src/MotionModel/entities/rotatingAxis/rotatingAxis.cpp b/src/MotionModel/entities/rotatingAxis/rotatingAxis.cpp
index dbb9206e..d5aa3ca2 100644
--- a/src/MotionModel/entities/rotatingAxis/rotatingAxis.cpp
+++ b/src/MotionModel/entities/rotatingAxis/rotatingAxis.cpp
@@ -28,7 +28,6 @@ pFlow::rotatingAxis::rotatingAxis
 	const dictionary& dict
 )
 {
-
 	if(!read(dict))
 	{
 		fatalErrorInFunction<<
@@ -73,7 +72,7 @@ bool pFlow::rotatingAxis::read
 	if(!timeInterval::read(dict))return false;
 	if(!line::read(dict)) return false;
 		
-	real omega = dict.getValOrSet("omega", static_cast<real>(0.0));
+	real omega = dict.getValOrSet("omega", 0.0);
 	
 	setOmega(omega);
 	return true;
diff --git a/src/MotionModel/entities/rotatingAxis/rotatingAxis.hpp b/src/MotionModel/entities/rotatingAxis/rotatingAxis.hpp
index ee37eba9..7d40f06e 100644
--- a/src/MotionModel/entities/rotatingAxis/rotatingAxis.hpp
+++ b/src/MotionModel/entities/rotatingAxis/rotatingAxis.hpp
@@ -24,13 +24,12 @@ Licence:
 #include "timeInterval.hpp"
 #include "line.hpp"
 
+#include "rotatingAxisFwd.hpp"
+
 namespace pFlow
 {
 
 class dictionary;
-class rotatingAxis;
-
-#include "rotatingAxisFwd.hpp"
 
 /**
  * An axis which rotates around itself at specified speed
@@ -64,7 +63,7 @@ class rotatingAxis
 	public timeInterval,
 	public line
 {
-protected:
+private:
 	
 	/// rotation speed 
 	real 	omega_ = 0;
@@ -76,13 +75,15 @@ public:
 
 	// - Constructor
 
+	TypeInfoNV("rotatingAxis");
+
 	/// Empty constructor
 	FUNCTION_HD
-	rotatingAxis(){}
+	rotatingAxis()=default;
 
 	/// Construct from dictionary
 	FUNCTION_H
-	rotatingAxis(const dictionary& dict);
+	explicit rotatingAxis(const dictionary& dict);
 	
 	/// Construct from components
 	FUNCTION_HD
@@ -92,9 +93,19 @@ public:
 	FUNCTION_HD
 	rotatingAxis(const rotatingAxis&) = default;
 
+	FUNCTION_HD
+	rotatingAxis(rotatingAxis&&) = default;
+
 	/// Copy asssignment
 	rotatingAxis& operator=(const rotatingAxis&) = default;
 
+	/// Copy asssignment
+	rotatingAxis& operator=(rotatingAxis&&) = default;
+
+	/// destructor 
+	~rotatingAxis()=default;
+
+
 	/// Set omega
 	FUNCTION_HD
 	real setOmega(real omega);
@@ -115,7 +126,10 @@ public:
 
 	/// Linear tangential velocity at point p
 	INLINE_FUNCTION_HD
-	realx3 linTangentialVelocityPoint(const realx3 &p)const;
+	realx3 linVelocityPoint(const realx3 &p)const;
+
+	INLINE_FUNCTION_HD
+	realx3 transferPoint(const realx3 p, real dt)const;
 
 	// - IO operation
 
diff --git a/src/MotionModel/entities/rotatingAxis/rotatingAxisFwd.hpp b/src/MotionModel/entities/rotatingAxis/rotatingAxisFwd.hpp
index 8cbfe593..140411c5 100755
--- a/src/MotionModel/entities/rotatingAxis/rotatingAxisFwd.hpp
+++ b/src/MotionModel/entities/rotatingAxis/rotatingAxisFwd.hpp
@@ -18,6 +18,11 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
+namespace pFlow
+{
+
+class rotatingAxis;
+
 INLINE_FUNCTION_HD
 realx3 rotate(const realx3 &p, const line& ln, real theta);
 
@@ -25,10 +30,10 @@ INLINE_FUNCTION_HD
 realx3 rotate(const realx3& p, const rotatingAxis& ax, real dt);
 
 INLINE_FUNCTION_HD
-void rotate(realx3* p, size_t n, const line& ln, real theta);
+void rotate(realx3* p, uint32 n, const line& ln, real theta);
 
 INLINE_FUNCTION_HD
-void rotate(realx3* p, size_t n, const rotatingAxis& ax, real dt);
-
+void rotate(realx3* p, uint32 n, const rotatingAxis& ax, real dt);
 
+}
 
diff --git a/src/MotionModel/entities/rotatingAxis/rotatingAxisI.hpp b/src/MotionModel/entities/rotatingAxis/rotatingAxisI.hpp
index c7563020..10a730cc 100755
--- a/src/MotionModel/entities/rotatingAxis/rotatingAxisI.hpp
+++ b/src/MotionModel/entities/rotatingAxis/rotatingAxisI.hpp
@@ -1,3 +1,4 @@
+#include "rotatingAxis.hpp"
 /*------------------------------- phasicFlow ---------------------------------
       O        C enter of
      O O       E ngineering and
@@ -19,7 +20,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 INLINE_FUNCTION_HD
-pFlow::realx3 pFlow::rotatingAxis::linTangentialVelocityPoint(const realx3 &p)const
+pFlow::realx3 pFlow::rotatingAxis::linVelocityPoint(const realx3 &p)const
 {
 	
 	if(!inTimeRange()) return {0,0,0};
@@ -28,6 +29,12 @@ pFlow::realx3 pFlow::rotatingAxis::linTangentialVelocityPoint(const realx3 &p)co
 	return cross(omega_*unitVector(),L);
 }
 
+INLINE_FUNCTION_HD 
+pFlow::realx3 pFlow::rotatingAxis::transferPoint(const realx3 p, real dt)const
+{
+    return  rotate(p, *this, dt);
+}
+
 INLINE_FUNCTION_HD
 pFlow::realx3 pFlow::rotate(const realx3& p, const rotatingAxis& ax, real dt)
 {
@@ -97,7 +104,7 @@ pFlow::realx3 pFlow::rotate(const realx3 &p, const line& ln, real theta)
 }
 
 INLINE_FUNCTION_HD
-void pFlow::rotate(realx3* p, size_t n, const line& ln, real theta)
+void pFlow::rotate(realx3* p, uint32 n, const line& ln, real theta)
 {
 	realx3 nv = ln.unitVector();
 	real cos_tet = cos(theta);
@@ -110,7 +117,7 @@ void pFlow::rotate(realx3* p, size_t n, const line& ln, real theta)
 	// (a(v2+w2) - u( bv + cw - ux - vy - wz)) (1-cos_tet) + x cos_tet + (- cv + bw - wy + vz) sin_tet 
 	realx3 res;
 
-	for(label i=0; i<n; i++ )
+	for(uint32 i=0; i<n; i++ )
 	{
 		res.x_ = (lp1.x_*(v2 + w2) - (nv.x_*(lp1.y_*nv.y_ + lp1.z_*nv.z_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
 			p[i].x_ * cos_tet +
@@ -133,7 +140,7 @@ void pFlow::rotate(realx3* p, size_t n, const line& ln, real theta)
 }
 
 INLINE_FUNCTION_HD
-void pFlow::rotate(realx3* p, size_t n, const rotatingAxis& ax, real dt)
+void pFlow::rotate(realx3* p, uint32 n, const rotatingAxis& ax, real dt)
 {
 	if(!ax.inTimeRange()) return;
 	
@@ -148,7 +155,7 @@ void pFlow::rotate(realx3* p, size_t n, const rotatingAxis& ax, real dt)
 	// (a(v2+w2) - u( bv + cw - ux - vy - wz)) (1-cos_tet) + x cos_tet + (- cv + bw - wy + vz) sin_tet 
 	realx3 res;
 
-	for(label i=0; i<n; i++ )
+	for(uint32 i=0; i<n; i++ )
 	{
 		res.x_ = (lp1.x_*(v2 + w2) - (nv.x_*(lp1.y_*nv.y_ + lp1.z_*nv.z_ - nv.x_*p[i].x_ - nv.y_*p[i].y_ - nv.z_*p[i].z_)))*(1 - cos_tet) +
 			p[i].x_ * cos_tet +
diff --git a/src/MotionModel/entities/stationary/stationary.cpp b/src/MotionModel/entities/stationary/stationary.cpp
new file mode 100644
index 00000000..def835df
--- /dev/null
+++ b/src/MotionModel/entities/stationary/stationary.cpp
@@ -0,0 +1,57 @@
+/*------------------------------- 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 "stationary.hpp"
+
+
+
+FUNCTION_H
+pFlow::stationary::stationary(const dictionary& dict)
+{
+}
+
+
+
+FUNCTION_H
+bool pFlow::stationary::read(const dictionary& dict)
+{	
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::stationary::write(dictionary& dict) const
+{
+	
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::stationary::read(iIstream& is)
+{
+	
+	notImplementedFunction;
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::stationary::write(iOstream& os)const
+{
+  return true;
+}
\ No newline at end of file
diff --git a/src/MotionModel/entities/stationary/stationary.hpp b/src/MotionModel/entities/stationary/stationary.hpp
new file mode 100644
index 00000000..723ae31f
--- /dev/null
+++ b/src/MotionModel/entities/stationary/stationary.hpp
@@ -0,0 +1,104 @@
+/*------------------------------- 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 __stationary_hpp__
+#define __stationary_hpp__
+
+
+#include "types.hpp"
+#include "typeInfo.hpp"
+#include "streams.hpp"
+
+namespace pFlow
+{
+
+// forward
+class dictionary;
+
+
+/**
+ * stationary model for a wall
+ * 
+ */
+class stationary
+{
+public:
+
+	TypeInfoNV("stationary");
+
+	FUNCTION_HD
+	stationary()=default;
+
+	FUNCTION_H
+	explicit stationary(const dictionary& dict);
+	
+
+	FUNCTION_HD
+	stationary(const stationary&) = default;
+
+	stationary& operator=(const stationary&) = default;
+
+	INLINE_FUNCTION_HD
+	void setTime(real t)
+	{}
+
+	INLINE_FUNCTION_HD
+	realx3 linVelocityPoint(const realx3 &)const
+	{
+		return zero3;
+	}
+
+	INLINE_FUNCTION_HD
+	realx3 transferPoint(const realx3& p, real)const
+	{
+		return p;
+	}
+
+	// - IO operation
+	FUNCTION_H 
+	bool read(const dictionary& dict);
+
+	FUNCTION_H
+	bool write(dictionary& dict) const;
+
+	FUNCTION_H
+	bool read(iIstream& is);
+
+	FUNCTION_H
+	bool write(iOstream& os)const;
+
+};
+
+inline iOstream& operator <<(iOstream& os, const stationary& obj)
+{
+	
+	return os;
+}
+
+inline iIstream& operator >>(iIstream& is, stationary& obj)
+{
+	
+	return is;
+}
+
+}
+
+
+#endif
diff --git a/src/MotionModel/entities/vibrating/vibrating.hpp b/src/MotionModel/entities/vibrating/vibrating.hpp
index 4ece54a2..62241dfa 100644
--- a/src/MotionModel/entities/vibrating/vibrating.hpp
+++ b/src/MotionModel/entities/vibrating/vibrating.hpp
@@ -67,7 +67,7 @@ class vibrating
 	public timeInterval
 {
 
-protected:
+private:
 	
 	// rotation speed 
 	realx3	angularFreq_{0,0,0};
@@ -94,11 +94,13 @@ protected:
 
 public:
 
+	TypeInfoNV("vibrating");
+
 	FUNCTION_HD
-	vibrating(){}
+	vibrating()=default;
 
 	FUNCTION_H
-	vibrating(const dictionary& dict);
+	explicit vibrating(const dictionary& dict);
 	
 
 	FUNCTION_HD
@@ -115,16 +117,16 @@ public:
 	}
 
 	INLINE_FUNCTION_HD
-	realx3 linTangentialVelocityPoint(const realx3 &p)const
+	realx3 linVelocityPoint(const realx3 &)const
 	{
 		return velocity_;
 	}
 
 	INLINE_FUNCTION_HD
-	realx3 transferPoint(const realx3& p, real dt)
+	realx3 transferPoint(const realx3& p, real dt)const
 	{
 		if(!inTimeRange()) return p;
-		return p + static_cast<real>(0.5)*dt*(velocity0_+velocity_);
+		return p + static_cast<real>(0.5*dt)*(velocity0_+velocity_);
 	}
 
 	// - IO operation
diff --git a/src/MotionModel/fixedWall/fixedWall.cpp b/src/MotionModel/fixedWall/fixedWall.cpp
deleted file mode 100644
index 6c3dba2e..00000000
--- a/src/MotionModel/fixedWall/fixedWall.cpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/*------------------------------- 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 "fixedWall.hpp"
-#include "dictionary.hpp"
-#include "vocabs.hpp"
-
-bool pFlow::fixedWall::readDictionary
-(
-	const dictionary& dict
-)
-{
-
-	auto motionModel = dict.getVal<word>("motionModel");
-
-	if(motionModel != "fixedWall")
-	{
-		fatalErrorInFunction<<
-		"  motionModel should be fixedWall, but found " << motionModel <<endl;
-		return false;
-	}
-		
-	return true;
-}
-
-bool pFlow::fixedWall::writeDictionary
-(
-	dictionary& dict
-)const
-{
-	dict.add("motionModel", "fixedWall");
-
-	auto& motionInfo = dict.subDictOrCreate("fixedWallInfo");
-
-	return true;
-}
-
-pFlow::fixedWall::fixedWall()
-{}
-
-pFlow::fixedWall::fixedWall
-(
-	const dictionary& dict
-)
-{
-	if(! readDictionary(dict) )
-	{
-		fatalExit;
-	}
-}
-
-bool pFlow::fixedWall::read
-(
-	iIstream& is
-)
-{
-	// create an empty file dictionary
-	dictionary motionInfo(motionModelFile__, true);
-
-	// read dictionary from stream
-	if( !motionInfo.read(is) )
-	{
-		ioErrorInFile(is.name(), is.lineNumber()) <<
-		"  error in reading dictionray " << motionModelFile__ <<" from file. \n";
-		return false;
-	}
-
-	if( !readDictionary(motionInfo) ) return false;
-	
-	return true;
-}
-
-bool pFlow::fixedWall::write
-(
-	iOstream& os
-)const
-{
-	// create an empty file dictionary
-	dictionary motionInfo(motionModelFile__, true);
-
-	if( !writeDictionary(motionInfo))
-	{
-		return false;
-	}
-
-	if( !motionInfo.write(os) )
-	{
-		ioErrorInFile( os.name(), os.lineNumber() )<<
-		"  error in writing dictionray to file. \n";
-		return false;
-	}
-	return true;
-}
\ No newline at end of file
diff --git a/src/MotionModel/fixedWall/fixedWall.hpp b/src/MotionModel/fixedWall/fixedWall.hpp
deleted file mode 100644
index 5c8b4760..00000000
--- a/src/MotionModel/fixedWall/fixedWall.hpp
+++ /dev/null
@@ -1,206 +0,0 @@
-/*------------------------------- 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 __fixedWall_hpp__
-#define __fixedWall_hpp__
-
-
-#include "types.hpp"
-#include "typeInfo.hpp"
-#include "Vectors.hpp"
-#include "uniquePtr.hpp"
-
-
-
-namespace pFlow
-{
-
-class dictionary;
-
-/**
- * Fixed wall motion model for walls
- * 
- * This class is used for geometries that are fixed during simulation.
- * 
- * 
-\verbatim
-// In geometryDict file, this will defines fixed walls during simulation
-...
-motionModel fixedWall; 
-...
-\endverbatim
- */
-class fixedWall
-{
-public:
-
-	/** Motion model class to be passed to computational units/kernels for
-	 *  transfing points and returning velocities at various positions
-	 */
-	class Model
-	{
-
-	public:
-
-		INLINE_FUNCTION_HD
-		Model(){}
-
-		INLINE_FUNCTION_HD
-		Model(const Model&) = default;
-		
-		INLINE_FUNCTION_HD
-		Model& operator=(const Model&) = default;
-
-
-		INLINE_FUNCTION_HD
-		realx3 pointVelocity(int32 n, const realx3 p)const
-		{
-			return 0.0;
-		}
-
-		INLINE_FUNCTION_HD
-		realx3 operator()(int32 n, const realx3& p)const
-		{
-			return 0.0;
-		}
-
-		INLINE_FUNCTION_HD
-		realx3 transferPoint(int32 n, const realx3 p, real dt)const
-		{
-			return p;
-		}
-
-		INLINE_FUNCTION_HD int32 numComponents()const
-		{
-			return 0;
-		}
-	};
-
-protected:
-	
-	/// Name
-	const word name_ = "none";
-
-
-	/// Read from a dictionary 
-	bool readDictionary(const dictionary& dict);
-
-	/// write to a dictionary
-	bool writeDictionary(dictionary& dict)const;
-
-public:
-	
-	/// Type info
-	TypeInfoNV("fixedWall");
-
-	// - Constructors 
-
-		/// Empty
-		fixedWall();
-
-		/// Constructor with dictionary 
-		fixedWall(const dictionary& dict);
-
-		/// Copy constructor
-		fixedWall(const fixedWall&) = default;
-
-		/// Move constructor
-		fixedWall(fixedWall&&) = default;
-
-		/// Copy assignment
-		fixedWall& operator=(const fixedWall&) = default;
-
-		/// Move assignment 
-		fixedWall& operator=(fixedWall&&) = default;
-
-		/// Destructor 
-		~fixedWall() = default;
-
-	// - Methods 
-
-		/// Return motion model
-		/// t is the current simulation time 
-		Model getModel(real t)const
-		{
-			return Model();
-		}
-
-		/// Name of the motion component to index 
-		int32 nameToIndex(const word& name)const
-		{
-			return 0;
-		}
-
-		/// Index of motion component to name 
-		word indexToName(label i)const
-		{
-			return name_;
-		}
-
-		/// Velocity at point p
-		INLINE_FUNCTION_HD
-		realx3 pointVelocity(label n, const realx3& p)const 
-		{
-			return zero3;
-		}
-
-		
-		/// Transfer point p for dt seconds according to motion component n
-		INLINE_FUNCTION_HD
-		realx3 transferPoint(label n, const realx3 p, real dt)const
-		{
-			return p;
-		}
-
-		/// Transfer a vector of point pVec for dt seconds according to motion
-		/// component n
-		INLINE_FUNCTION_HD
-		bool transferPoint(label n, realx3* pVec, size_t numP, real dt)
-		{
-			return true;		
-		}
-
-		/// Are walls moving 
-		INLINE_FUNCTION_HD
-		bool isMoving()const
-		{
-			return false;
-		}
-
-		/// Move points
-		bool move(real t, real dt)
-		{
-			return true;
-		}
-
-	// - IO operations 
-
-		/// Read from input stream is 
-		FUNCTION_H
-		bool read(iIstream& is);
-
-		/// Write to output stream os 
-		FUNCTION_H
-		bool write(iOstream& os)const;	
-};
-
-} // pFlow
-
-#endif //__fixed_hpp__
diff --git a/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.cpp b/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.cpp
index 9ef21e44..b47e9c30 100644
--- a/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.cpp
+++ b/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.cpp
@@ -19,152 +19,70 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "rotatingAxisMotion.hpp"
-#include "dictionary.hpp"
-#include "vocabs.hpp"
 
-
-bool pFlow::rotatingAxisMotion::readDictionary
+void pFlow::rotatingAxisMotion::impl_setTime
 (
-	const dictionary& dict
-)
-{
-
-	auto motionModel = dict.getVal<word>("motionModel");
-
-	if(motionModel != "rotatingAxisMotion")
-	{
-		fatalErrorInFunction<<
-		"  motionModel should be rotatingAxisMotion, but found "
-		 << motionModel <<endl;
-		return false;
-	}
-
-	auto& motionInfo = dict.subDict("rotatingAxisMotionInfo");
-	auto axisNames = motionInfo.dictionaryKeywords();
-	
-	axis_.reserve(axisNames.size()+1);
-	
-	
-	axis_.clear();
-	axisName_.clear();
-
-		
-	for(auto& aName: axisNames)
-	{
-		auto& axDict = motionInfo.subDict(aName);
-		
-		if(auto axPtr = makeUnique<rotatingAxis>(axDict); axPtr)
-		{
-			axis_.push_back(axPtr());
-			axisName_.push_back(aName);
-		}
-		else
-		{
-			fatalErrorInFunction<<
-			"could not read rotating axis from "<< axDict.globalName()<<endl;
-			return false;
-		}
-	}
-
-
-
-	if( !axisName_.search("none") )
-	{
-		axis_.push_back
-		(
-			rotatingAxis(
-				realx3(0.0,0.0,0.0),
-				realx3(1.0,0.0,0.0),
-				0.0
-				)
-		);
-		axisName_.push_back("none");	
-	}
-
-	axis_.syncViews();
-	numAxis_ = axis_.size();
-
-	return true;
-}
-
-bool pFlow::rotatingAxisMotion::writeDictionary
-(
-	dictionary& dict
+	uint32 iter, 
+	real t, 
+	real dt
 )const
 {
-	dict.add("motionModel", "rotatingAxisMotion");
-
-	auto& motionInfo = dict.subDictOrCreate("rotatingAxisMotionInfo");
-	
-	ForAll(i, axis_)
-	{
-		
-		auto& axDict = motionInfo.subDictOrCreate(axisName_[i]);
-		if( !axis_.hostVectorAll()[i].write(axDict))
-		{
-			fatalErrorInFunction<<
-			"  error in writing axis "<< axisName_[i] << " to dicrionary "
-			<< motionInfo.globalName()<<endl;
-			return false;
-		}
-	}
-
-	return true;
+	auto motion = motionComponents_.deviceViewAll();
+	Kokkos::parallel_for(
+		"rotatingAxisMotion::impl_setTime",
+		deviceRPolicyStatic(0, numComponents_),
+		LAMBDA_HD(uint32 i){
+			motion[i].setTime(t);
+		});
+	Kokkos::fence();
 }
 
-pFlow::rotatingAxisMotion::rotatingAxisMotion()
-{}
-
-pFlow::rotatingAxisMotion::rotatingAxisMotion
-(
-	const dictionary& dict
-)
+pFlow::rotatingAxisMotion::rotatingAxisMotion(
+    const objectFile &objf,
+    repository *owner)
+    : fileDictionary(objf, owner)
 {
-	if(! readDictionary(dict) )
+
+	if(! impl_readDictionary(*this) )
 	{
+		fatalErrorInFunction;
 		fatalExit;
 	}
 }
 
-bool pFlow::rotatingAxisMotion::read
+pFlow::rotatingAxisMotion::rotatingAxisMotion
 (
-	iIstream& is
+	const objectFile &objf, 
+	const dictionary &dict, 
+	repository *owner
 )
+:
+	fileDictionary(objf, dict, owner)
 {
-	// create an empty file dictionary
-	dictionary motionInfo(motionModelFile__, true);
-
-	// read dictionary from stream
-	if( !motionInfo.read(is) )
+	if(!impl_readDictionary(*this) )
 	{
-		ioErrorInFile(is.name(), is.lineNumber()) <<
-		"  error in reading dictionray " << motionModelFile__ <<" from file. \n";
-		return false;
+		fatalErrorInFunction;
+		fatalExit;
 	}
-
-	if( !readDictionary(motionInfo) ) return false;
-	
-	return true;
 }
 
 bool pFlow::rotatingAxisMotion::write
 (
-	iOstream& os
-)const
+	iOstream &os, 
+	const IOPattern &iop
+) const
 {
-	// create an empty file dictionary
-	dictionary motionInfo(motionModelFile__, true);
-
-	if( !writeDictionary(motionInfo))
+	// a global dictionary
+	dictionary newDict(fileDictionary::dictionary::name(), true);
+	if( iop.thisProcWriteData() )
 	{
-		return false;
+		if( !this->impl_writeDictionary(newDict) || 
+			!newDict.write(os))
+		{
+			fatalErrorInFunction<<
+			" error in writing to dictionary "<< newDict.globalName()<<endl;
+			return false;
+		}
 	}
-
-	if( !motionInfo.write(os) )
-	{
-		ioErrorInFile( os.name(), os.lineNumber() )<<
-		"  error in writing dictionray to file. \n";
-		return false;
-	}
-	return true;
-}
\ No newline at end of file
+    return true;
+}
diff --git a/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.hpp b/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.hpp
index eacf7ca3..a46350bd 100644
--- a/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.hpp
+++ b/src/MotionModel/rotatingAxisMotion/rotatingAxisMotion.hpp
@@ -22,32 +22,26 @@ Licence:
 #define __rotatingAxisMotion_hpp__
 
 
-#include "types.hpp"
-#include "typeInfo.hpp"
-#include "VectorDual.hpp"
-#include "Vectors.hpp"
-#include "List.hpp"
+#include "MotionModel.hpp"
 #include "rotatingAxis.hpp"
-
+#include "fileDictionary.hpp"
 
 namespace pFlow
 {
 
-class dictionary;
-
 /**
  * Rotating axis motion model for walls
  * 
  * This class is used for simulaiton that at least one wall components 
  * is moving according to rotatingAxis motion mode. One or more than one
- * motion components can be defined in rotatingAxisMotionInfo dictionary
+ * motion components can be defined in rotatingAxisInfo dictionary
  * 
 \verbatim
 // In geometryDict file, this will defines rotating walls during simulation
 ...
-motionModel rotatingAxisMotion;
+motionModel rotatingAxis;
 
-rotatingAxisMotionInfo
+rotatingAxisInfo
 {
 	rotationAxis1
 	{
@@ -63,185 +57,50 @@ rotatingAxisMotionInfo
  *
  */
 class rotatingAxisMotion
+:
+    public fileDictionary,
+    public MotionModel<rotatingAxisMotion, rotatingAxis>
 {
-public:
-	
-	/** Motion model class to be passed to computational units/kernels for
-	 *  transfing points and returning velocities at various positions
-	 */
-	class Model
-	{
-	protected:
-		
-		deviceViewType1D<rotatingAxis> 	axis_;
-		int32 							numAxis_=0;
-
-	public:
-
-		INLINE_FUNCTION_HD
-		Model(deviceViewType1D<rotatingAxis> axis, int32 numAxis):
-			axis_(axis),
-			numAxis_(numAxis)
-		{}
-
-		INLINE_FUNCTION_HD
-		Model(const Model&) = default;
-		
-		
-		INLINE_FUNCTION_HD
-		Model& operator=(const Model&) = default;
-
-
-		INLINE_FUNCTION_HD
-		realx3 pointVelocity(int32 n, const realx3& p)const
-		{
-			return axis_[n].linTangentialVelocityPoint(p);
-		}
-
-		INLINE_FUNCTION_HD
-		realx3 operator()(int32 n, const realx3& p)const
-		{
-			return pointVelocity(n,p);
-		}
-
-		INLINE_FUNCTION_HD
-		realx3 transferPoint(int32 n, const realx3 p, real dt)const
-		{
-			return rotate(p, axis_[n], dt);	
-		}
-
-		INLINE_FUNCTION_HD int32 numComponents()const
-		{
-			return numAxis_;
-		}
-	};
-
 protected:
 
-	using axisVector_HD = VectorDual<rotatingAxis>;
+	friend MotionModel<rotatingAxisMotion, rotatingAxis>;
 
-	/// Vector to store axes 
-	axisVector_HD 	axis_;
+	/// is the geometry attached to this component moving
+	bool impl_isMoving()const
+	{
+		return true;
+	}
+
+	/// move the component itself
+	bool impl_move(uint32, real, real)const
+	{
+		return true;
+	}
+
+	void impl_setTime(uint32 iter, real t, real dt)const;
 	
-	/// Names of axes
-	wordList  		axisName_;
-
-	/// Number of axes components
-	label  			numAxis_= 0;
-
-	/// Read from dictionary 
-	bool readDictionary(const dictionary& dict);
-
-	/// Write to dictionary
-	bool writeDictionary(dictionary& dict)const;
-
 public:
-	
-	/// Type info
-	TypeInfoNV("rotatingAxisMotion");
 
-	// - Constructors 
-	
-		/// Empty
-		FUNCTION_H
-		rotatingAxisMotion();
+	TypeInfo("rotatingAxisMotion");
 
-		/// Construct with dictionary 
-		FUNCTION_H
-		rotatingAxisMotion(const dictionary& dict);
+	rotatingAxisMotion(const objectFile& objf, repository* owner);
 
-		/// Copy constructor 
-		FUNCTION_H
-		rotatingAxisMotion(const rotatingAxisMotion&) = default;
+	rotatingAxisMotion(
+		const objectFile& objf, 
+		const dictionary& dict, 
+		repository* owner);
 
-		/// No move constructor 
-		rotatingAxisMotion(rotatingAxisMotion&&) = delete;
 
-		/// Copy assignment
-		FUNCTION_H
-		rotatingAxisMotion& operator=(const rotatingAxisMotion&) = default;
-
-		/// No move assignment
-		rotatingAxisMotion& operator=(rotatingAxisMotion&&) = delete;
-
-		/// Destructor 
-		FUNCTION_H
-		~rotatingAxisMotion() = default;
-
-	// - Methods
-		/// Return the motion model at time t 
-		Model getModel(real t)
-		{
-			for(int32 i= 0; i<numAxis_; i++ )
-			{
-				axis_[i].setTime(t);
-			}
-			axis_.modifyOnHost();
-			axis_.syncViews();
-
-			return Model(axis_.deviceVector(), numAxis_);
-		}
-
-		/// Motion component name to index
-		INLINE_FUNCTION_H
-		int32 nameToIndex(const word& name)const
-		{
-			if( auto i = axisName_.findi(name); i == -1)
-			{
-				fatalErrorInFunction<<
-				"axis name " << name << " does not exist. \n";
-				fatalExit;
-				return i;
-			}
-			else
-			{
-				return i;
-			}
-			
-		}
-
-		/// Motion index to motion component name 
-		INLINE_FUNCTION_H
-		word indexToName(label i)const
-		{
-			if(i < numAxis_ )
-				return axisName_[i];
-			else
-			{
-				fatalErrorInFunction<<
-				"out of range access to the list of axes " << i <<endl<<
-				" size of axes_ is "<<numAxis_<<endl;
-				fatalExit;
-				return "";
-			}
-		}
-
-		
-		/// Are walls moving 
-		INLINE_FUNCTION_HD
-		bool isMoving()const
-		{
-			return true;
-		}
-
-		/// Move 
-		INLINE_FUNCTION_H
-		bool move(real t, real dt)
-		{
-			return true;
-		}
-
-	// - IO operation 
-		/// Read from input stream is 
-		FUNCTION_H
-		bool read(iIstream& is);
-
-		/// Write to output stream os
-		FUNCTION_H
-		bool write(iOstream& os)const;
+	bool write(iOstream& os, const IOPattern& iop)const override;
 
+	static
+    auto noneComponent()
+    {
+      return rotatingAxis({0,0,0}, {1,0,0}, 0.0);
+    }
 };
 
 } // pFlow
 
-#endif //__rotatingAxisMotion_hpp__
+
+#endif // __rotatingAxisMotion_hpp__
\ No newline at end of file
diff --git a/src/MotionModel/stationaryWall/stationaryWall.cpp b/src/MotionModel/stationaryWall/stationaryWall.cpp
new file mode 100644
index 00000000..ff581496
--- /dev/null
+++ b/src/MotionModel/stationaryWall/stationaryWall.cpp
@@ -0,0 +1,75 @@
+/*------------------------------- 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 "stationaryWall.hpp"
+
+
+pFlow::stationaryWall::stationaryWall
+(
+	const objectFile &objf, 
+	repository *owner
+)
+:
+	fileDictionary(objf, owner)
+{
+
+	if(!impl_readDictionary(*this) )
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+}
+
+pFlow::stationaryWall::stationaryWall
+(
+	const objectFile &objf, 
+	const dictionary &dict, 
+	repository *owner
+)
+:
+	fileDictionary(objf, dict, owner)
+{
+	if(!impl_readDictionary(*this) )
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+}
+
+bool pFlow::stationaryWall::write
+(
+	iOstream &os, 
+	const IOPattern &iop
+) const
+{
+	// a global dictionary
+	dictionary newDict(fileDictionary::dictionary::name(), true);
+	if( iop.thisProcWriteData() )
+	{
+		if( !this->impl_writeDictionary(newDict) || 
+			!newDict.write(os))
+		{
+			fatalErrorInFunction<<
+			" error in writing to dictionary "<< newDict.globalName()<<endl;
+			return false;
+		}
+	}
+    return true;
+}
diff --git a/src/MotionModel/stationaryWall/stationaryWall.hpp b/src/MotionModel/stationaryWall/stationaryWall.hpp
new file mode 100644
index 00000000..514cba1d
--- /dev/null
+++ b/src/MotionModel/stationaryWall/stationaryWall.hpp
@@ -0,0 +1,99 @@
+/*------------------------------- 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 __stationaryWall_hpp__
+#define __stationaryWall_hpp__
+
+
+#include "MotionModel.hpp"
+#include "stationary.hpp"
+#include "fileDictionary.hpp"
+
+namespace pFlow
+{
+
+
+/**
+ * stationary model for walls
+ * 
+ * This class is used for simulaiton that all wall components 
+ * are fixed.
+ * 
+\verbatim
+// In geometryDict file, this will defines stationary walls
+...
+motionModel stationary;
+
+// this dictionary is optional
+stationaryInfo
+{
+	
+}
+...
+\endverbatim
+ *
+ */
+class stationaryWall
+:
+    public fileDictionary,
+    public MotionModel<stationaryWall, stationary>
+{
+protected:
+
+	friend MotionModel<stationaryWall, stationary>;
+  
+	bool impl_isMoving()const
+	{
+		return false;
+	}
+
+	bool impl_move(uint32, real, real)const
+	{
+		return true;
+	}
+	
+	void impl_setTime(uint32 ,real ,real )const
+	{}
+
+public:
+
+	TypeInfo("stationaryWall");
+
+	stationaryWall(const objectFile& objf, repository* owner);
+
+	stationaryWall(
+		const objectFile& objf, 
+		const dictionary& dict, 
+		repository* owner);
+
+
+	bool write(iOstream& os, const IOPattern& iop)const override;
+
+	static
+    auto noneComponent()
+    {
+      return stationary();
+    }
+};
+
+} // pFlow
+
+
+#endif // __stationaryWall_hpp__
\ No newline at end of file
diff --git a/src/MotionModel/vibratingMotion/vibratingMotion.cpp b/src/MotionModel/vibratingMotion/vibratingMotion.cpp
index 1cc472a8..896a35e0 100644
--- a/src/MotionModel/vibratingMotion/vibratingMotion.cpp
+++ b/src/MotionModel/vibratingMotion/vibratingMotion.cpp
@@ -1,167 +1,66 @@
-/*------------------------------- 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 "vibratingMotion.hpp"
-#include "dictionary.hpp"
-#include "vocabs.hpp"
 
-
-bool pFlow::vibratingMotion::readDictionary
+void pFlow::vibratingMotion::impl_setTime
 (
-	const dictionary& dict
-)
-{
-
-	auto motionModel = dict.getVal<word>("motionModel");
-
-	if(motionModel != "vibratingMotion")
-	{
-		fatalErrorInFunction<<
-		"  motionModel should be vibratingMotion, but found "
-		 << motionModel <<endl;
-		return false;
-	}
-
-	auto& motionInfo = dict.subDict("vibratingMotionInfo");
-	auto compNames = motionInfo.dictionaryKeywords();
-	
-	components_.reserve(compNames.size()+1);
-	
-	
-	components_.clear();
-	componentName_.clear();
-
-		
-	for(auto& cName: compNames)
-	{
-		auto& compDict = motionInfo.subDict(cName);
-		
-		if(auto compPtr = makeUnique<vibrating>(compDict); compPtr)
-		{
-			components_.push_back(compPtr());
-			componentName_.push_back(cName);
-		}
-		else
-		{
-			fatalErrorInFunction<<
-			"could not read vibrating motion from "<< compDict.globalName()<<endl;
-			return false;
-		}
-	}
-
-
-
-	if( !componentName_.search("none") )
-	{
-		components_.push_back
-		(
-			vibrating()
-		);
-		componentName_.push_back("none");	
-	}
-
-	components_.syncViews();
-	numComponents_ = components_.size();
-	
-
-	return true;
-}
-
-bool pFlow::vibratingMotion::writeDictionary
-(
-	dictionary& dict
+	uint32 iter, 
+	real t, 
+	real dt
 )const
 {
-	dict.add("motionModel", "vibratingMotion");
-
-	auto& motionInfo = dict.subDictOrCreate("vibratingMotionInfo");
-	
-	ForAll(i, components_)
-	{
-		
-		auto& compDict = motionInfo.subDictOrCreate(componentName_[i]);
-		if( !components_.hostVectorAll()[i].write(compDict))
-		{
-			fatalErrorInFunction<<
-			"  error in writing motion compoonent "<< componentName_[i] << " to dicrionary "
-			<< motionInfo.globalName()<<endl;
-			return false;
-		}
-	}
-
-	return true;
+	auto motion = motionComponents_.deviceViewAll();
+	Kokkos::parallel_for(
+		"vibratingMotion::impl_setTime",
+		deviceRPolicyStatic(0, numComponents_),
+		LAMBDA_HD(uint32 i){
+			motion[i].setTime(t);
+		});
+	Kokkos::fence();
 }
 
-pFlow::vibratingMotion::vibratingMotion()
-{}
-
 pFlow::vibratingMotion::vibratingMotion
 (
-	const dictionary& dict
-)
+    const objectFile &objf,
+    repository *owner
+) 
+: 
+	fileDictionary(objf, owner)
 {
-	if(! readDictionary(dict) )
+    if(! getModel().impl_readDictionary(*this) )
 	{
+		fatalErrorInFunction;
 		fatalExit;
 	}
 }
 
-bool pFlow::vibratingMotion::read
+pFlow::vibratingMotion::vibratingMotion
 (
-	iIstream& is
+	const objectFile &objf, 
+	const dictionary &dict, 
+	repository *owner
 )
+:
+	fileDictionary(objf,dict,owner)
 {
-	// create an empty file dictionary
-	dictionary motionInfo(motionModelFile__, true);
-
-	// read dictionary from stream
-	if( !motionInfo.read(is) )
+	if(! getModel().impl_readDictionary(*this) )
 	{
-		ioErrorInFile(is.name(), is.lineNumber()) <<
-		"  error in reading dictionray " << motionModelFile__ <<" from file. \n";
-		return false;
+		fatalErrorInFunction;
+		fatalExit;
 	}
-
-	if( !readDictionary(motionInfo) ) return false;
-	
-	return true;
 }
 
-bool pFlow::vibratingMotion::write
-(
-	iOstream& os
-)const
+bool pFlow::vibratingMotion::write(iOstream &os, const IOPattern &iop) const
 {
-	// create an empty file dictionary
-	dictionary motionInfo(motionModelFile__, true);
-
-	if( !writeDictionary(motionInfo))
+    // a global dictionary
+	dictionary newDict(fileDictionary::dictionary::name(), true);
+	if( iop.thisProcWriteData() )
 	{
-		return false;
+		if( !getModel().impl_writeDictionary(newDict) || 
+			!newDict.write(os))
+		{
+			fatalErrorInFunction<<
+			" error in writing to dictionary "<< newDict.globalName()<<endl;
+			return false;
+		}
 	}
-
-	if( !motionInfo.write(os) )
-	{
-		ioErrorInFile( os.name(), os.lineNumber() )<<
-		"  error in writing dictionray to file. \n";
-		return false;
-	}
-	return true;
-}
\ No newline at end of file
+    return true;
+}
diff --git a/src/MotionModel/vibratingMotion/vibratingMotion.hpp b/src/MotionModel/vibratingMotion/vibratingMotion.hpp
index 4392ed09..8c64e3a5 100644
--- a/src/MotionModel/vibratingMotion/vibratingMotion.hpp
+++ b/src/MotionModel/vibratingMotion/vibratingMotion.hpp
@@ -22,20 +22,16 @@ Licence:
 #define __vibratingMotion_hpp__
 
 
-#include "types.hpp"
-#include "typeInfo.hpp"
-#include "VectorDual.hpp"
-#include "Vectors.hpp"
-#include "List.hpp"
+#include "MotionModel.hpp"
 #include "vibrating.hpp"
+#include "fileDictionary.hpp"
+
 
 
 
 namespace pFlow
 {
 
-// forward
-class dictionary;
 
 /**
  * Vibrating motion model for walls
@@ -43,14 +39,14 @@ class dictionary;
  * This class is used for simulaiton that at least one wall components 
  * are moving according to a sinoidal viration defined in class vibrating.
  * One or more than one motion components can be defined in 
- * vibratingMotionInfo dictionary
+ * vibratingInfo dictionary
  * 
 \verbatim
 // In geometryDict file, this will defines vibrating walls during simulation
 ...
-motionModel vibratingMotion;
+motionModel vibrating;
 
-vibratingMotionInfo
+vibratingInfo
 {
 	vibComponent1
 	{
@@ -66,194 +62,54 @@ vibratingMotionInfo
  *
  */
 class vibratingMotion
+:
+    public fileDictionary,
+    public MotionModel<vibratingMotion, vibrating>
 {
-public:
-	
-	/** Motion model class to be passed to computational units/kernels for
-	 *  transfing points and returning velocities at various positions
-	 */
-	class Model
-	{
-	protected:
-		
-		deviceViewType1D<vibrating> 	components_;
-		int32 							numComponents_=0;
-
-	public:
-
-		INLINE_FUNCTION_HD
-		Model(deviceViewType1D<vibrating> comps, int32 numComps):
-			components_(comps),
-			numComponents_(numComps)
-		{}
-
-		INLINE_FUNCTION_HD
-		Model(const Model&) = default;
-		
-		
-		INLINE_FUNCTION_HD
-		Model& operator=(const Model&) = default;
-
-
-		INLINE_FUNCTION_HD
-		realx3 pointVelocity(int32 n, const realx3& p)const
-		{
-			return components_[n].linTangentialVelocityPoint(p);
-		}
-
-		INLINE_FUNCTION_HD
-		realx3 operator()(int32 n, const realx3& p)const
-		{
-			return pointVelocity(n,p);
-		}
-
-		INLINE_FUNCTION_HD
-		realx3 transferPoint(int32 n, const realx3 p, real dt)const
-		{
-			return components_[n].transferPoint(p, dt);	
-		}
-
-		INLINE_FUNCTION_HD int32 numComponents()const
-		{
-			return numComponents_;
-		}
-	};
 
 protected:
-
-	using axisVector_HD = VectorDual<vibrating>;
-
-	/// Vibrating motion components 
-	axisVector_HD 	components_;
 	
-	/// Names of components
-	wordList  		componentName_;
+	friend MotionModel<vibratingMotion, vibrating>;
 
-	/// Number of components
-	label  			numComponents_= 0;
+	bool impl_isMoving()const
+	{
+		return true;
+	}
 
-	/// Read from a dictionary
-	bool readDictionary(const dictionary& dict);
+	/// move the component itself
+	bool impl_move(uint32, real, real)const
+	{
+		return true;
+	}
 
-	/// Write to a dictionary 
-	bool writeDictionary(dictionary& dict)const;
+	void impl_setTime(uint32 iter, real t, real dt)const;
 
 public:
 	
 	/// Type info
-	TypeInfoNV("vibratingMotion");
+	TypeInfo("vibratingMotion");
+	
+	vibratingMotion(const objectFile& objf, repository* owner);
 
-	/// Empty
-	FUNCTION_H
-	vibratingMotion();
-
-	/// Construct with dictionary 
-	FUNCTION_H
-	vibratingMotion(const dictionary& dict);
-
-	/// Copy constructor 
-	FUNCTION_H
-	vibratingMotion(const vibratingMotion&) = default;
-
-	/// No move 
-	vibratingMotion(vibratingMotion&&) = delete;
-
-	/// Copy assignment 
-	FUNCTION_H
-	vibratingMotion& operator=(const vibratingMotion&) = default;
-
-	/// No Move assignment 
-	vibratingMotion& operator=(vibratingMotion&&) = delete;
+	vibratingMotion(
+		const objectFile& objf, 
+		const dictionary& dict, 
+		repository* owner);
 
 	/// Destructor 
-	FUNCTION_H
-	~vibratingMotion() = default;
+	~vibratingMotion()override = default;
 
-	/// Return motion model at time t 
-	Model getModel(real t)
-	{
-		for(int32  i= 0; i<numComponents_; i++ )
-		{
-			components_[i].setTime(t);
-		}
-		components_.modifyOnHost();
-		components_.syncViews();
+    
+	bool write(iOstream& os, const IOPattern& iop)const override;
 
-		return Model(components_.deviceVectorAll(), numComponents_);
-	}
-
-	/// Name to component index 
-	INLINE_FUNCTION_H
-	int32 nameToIndex(const word& name)const
-	{
-		if( auto i = componentName_.findi(name); i == -1)
-		{
-			fatalErrorInFunction<<
-			"component name " << name << " does not exist. \n";
-			fatalExit;
-			return i;
-		}
-		else
-		{
-			return i;
-		}
-		
-	}
-
-	/// Index to name 
-	INLINE_FUNCTION_H
-	word indexToName(label i)const
-	{
-		if(i < numComponents_ )
-			return componentName_[i];
-		else
-		{
-			fatalErrorInFunction<<
-			"out of range access to the list of axes " << i <<endl<<
-			" size of components_ is "<<numComponents_<<endl;
-			fatalExit;
-			return "";
-		}
-	}
-
-	/// velocity at point p according to motion component n	
-	INLINE_FUNCTION_H
-	realx3 pointVelocity(label n, const realx3& p)const 
-	{
-		return components_.hostVectorAll()[n].linTangentialVelocityPoint(p);
-	}
-
-	/// Transfer point p for dt seconds based on motion component n 
-	INLINE_FUNCTION_H
-	realx3 transferPoint(label n, const realx3 p, real dt)const
-	{
-		return components_.hostVectorAll()[n].transferPoint(p, dt);
-	}
-
-	/// Is moving 
-	INLINE_FUNCTION_HD
-	bool isMoving()const
-	{
-		return true;
-	}
-
-	/// Move ponits at time t for dt seconds 
-	INLINE_FUNCTION_H
-	bool move(real t, real dt)
-	{
-		return true;
-	}
-
-	/// Read from input stream is 
-	FUNCTION_H
-	bool read(iIstream& is);
-
-	/// Write to output stream os
-	FUNCTION_H
-	bool write(iOstream& os)const;
+	static
+    auto noneComponent()
+    {
+      return vibrating();
+    }
 
 };
 
 } // pFlow
 
-#endif //__rotatingAxisMotion_hpp__
+#endif //__vibratingMotion_hpp__
diff --git a/src/Particles/CMakeLists.txt b/src/Particles/CMakeLists.txt
index 9c23631f..c1008f82 100644
--- a/src/Particles/CMakeLists.txt
+++ b/src/Particles/CMakeLists.txt
@@ -1,15 +1,19 @@
 
 set(SourceFiles 
 dynamicPointStructure/dynamicPointStructure.cpp
+particles/baseShapeNames.cpp
+particles/shape.cpp
 particles/particles.cpp
 particles/particleIdHandler.cpp
+particles/regularParticleHandler.cpp
 SphereParticles/sphereShape/sphereShape.cpp
 SphereParticles/sphereParticles/sphereParticles.cpp
-Insertion/shapeMixture/shapeMixture.cpp
-Insertion/insertion/insertion.cpp
-Insertion/Insertion/Insertions.cpp
-Insertion/insertionRegion/insertionRegion.cpp
-Insertion/insertionRegion/timeFlowControl.cpp
+SphereParticles/sphereParticles/sphereParticlesKernels.cpp
+#Insertion/shapeMixture/shapeMixture.cpp
+#Insertion/insertion/insertion.cpp
+#Insertion/Insertion/Insertions.cpp
+#Insertion/insertionRegion/insertionRegion.cpp
+#Insertion/insertionRegion/timeFlowControl.cpp
 )
 
 set(link_libs Kokkos::kokkos phasicFlow Integration Property)
diff --git a/src/Particles/SphereParticles/sphereParticles/sphereParticles.cpp b/src/Particles/SphereParticles/sphereParticles/sphereParticles.cpp
index f1d71012..01579677 100644
--- a/src/Particles/SphereParticles/sphereParticles/sphereParticles.cpp
+++ b/src/Particles/SphereParticles/sphereParticles/sphereParticles.cpp
@@ -19,10 +19,13 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "sphereParticles.hpp"
-#include "setFieldList.hpp"
+#include "systemControl.hpp"
+#include "vocabs.hpp"
 #include "sphereParticlesKernels.hpp"
 
-pFlow::uniquePtr<pFlow::List<pFlow::eventObserver*>> 
+
+//#include "setFieldList.hpp"
+/*pFlow::uniquePtr<pFlow::List<pFlow::eventObserver*>> 
 pFlow::sphereParticles::getFieldObjectList()const
 {
 	auto objListPtr = particles::getFieldObjectList();
@@ -78,10 +81,10 @@ bool pFlow::sphereParticles::initializeParticles()
 		static_cast<int32>(shapeName_.size()));
 	
 	return insertSphereParticles(shapeName_, indices, false);
-}
+}*/
 
 
-bool pFlow::sphereParticles::beforeIteration() 
+/*bool pFlow::sphereParticles::beforeIteration() 
 {
 	particles::beforeIteration();
 	
@@ -98,45 +101,19 @@ bool pFlow::sphereParticles::beforeIteration()
 	intPredictTimer_.end();
 
 	return true;
-}
+}*/
 
 
-bool pFlow::sphereParticles::iterate() 
-{
-
-	accelerationTimer_.start();
-	//INFO<<"before accelerationTimer_ "<<endINFO;
-		pFlow::sphereParticlesKernels::acceleration(
-			control().g(),
-			mass().deviceVectorAll(),
-			contactForce().deviceVectorAll(),
-			I().deviceVectorAll(),
-			contactTorque().deviceVectorAll(),
-			pStruct().activePointsMaskD(),
-			accelertion().deviceVectorAll(),
-			rAcceleration().deviceVectorAll()
-			);
-	accelerationTimer_.end();
-	
-	intCorrectTimer_.start();
-	
-		dynPointStruct_.correct(this->dt(), accelertion_);
-	
-		rVelIntegration_().correct(this->dt(), rVelocity_, rAcceleration_);
-	
-	intCorrectTimer_.end();
-	
-	return true;
-}
 
 
-bool pFlow::sphereParticles::afterIteration() 
+
+/*bool pFlow::sphereParticles::afterIteration() 
 {
 	return true;
-}
+}*/
 
 
-bool pFlow::sphereParticles::insertSphereParticles(
+/*bool pFlow::sphereParticles::insertSphereParticles(
 	const wordVector& names,
 	const int32IndexContainer& indices,
 	bool setId
@@ -219,6 +196,63 @@ bool pFlow::sphereParticles::insertSphereParticles(
 
 	return true;
 
+}*/
+
+bool pFlow::sphereParticles::initInertia()
+{
+	
+	using exeSpace = typename realPointField_D::execution_space;
+	using policy = Kokkos::RangePolicy<
+			exeSpace,
+			Kokkos::IndexType<uint32>>;
+	
+	auto [minIndex, maxIndex] = minMax(shapeIndex().internal());		
+
+	if( !spheres_.indexValid(maxIndex) )
+	{
+		fatalErrorInFunction<< 
+		"the maximum value of shapeIndex is "<< maxIndex << 
+		" which is not valid."<<endl;
+		return false;
+	}
+
+	auto aPointsMask 	= dynPointStruct().activePointsMaskDevice();
+	auto aRange 		= aPointsMask.activeRange();
+	
+	auto field_shapeIndex 	= shapeIndex().deviceView();
+	auto field_diameter 	= diameter_.deviceView();
+	auto field_mass 		= mass_.deviceView();
+	auto field_propId 		= propertyId_.deviceView();
+	auto field_I 			= I_.deviceView();
+
+	// get info from spheres shape 
+	realVector_D d("diameter", spheres_.boundingDiameter());
+	realVector_D mass("mass",spheres_.mass());
+	uint32Vector_D propId("propId", spheres_.shapePropertyIds());
+	realVector_D  I("I", spheres_.Inertia());
+
+	auto d_d 		= d.deviceView();
+	auto d_mass 	= mass.deviceView();
+	auto d_propId 	= propId.deviceView();
+	auto d_I 		= I.deviceView();
+		
+	Kokkos::parallel_for(
+		"particles::initInertia",
+		policy(aRange.start(), aRange.end()),
+		LAMBDA_HD(uint32 i)
+		{
+			if(aPointsMask(i))
+			{
+				uint32 index = field_shapeIndex[i];
+				field_I[i] = d_I[index];
+				field_diameter[i] = d_d[index];
+				field_mass[i] = d_mass[index];
+				field_propId[i] = d_propId[index];
+			}
+		});
+	Kokkos::fence();
+	
+	return true;
 }
 
 
@@ -227,78 +261,99 @@ pFlow::sphereParticles::sphereParticles(
 	const property& prop
 )
 :
-	particles(
-		control,
-		control.settingsDict().getValOrSet(
-			"integrationMethod",
-			word("AdamsBashforth3")
-			)
+	particles(control),
+	spheres_
+	(
+		shapeFile__,
+		&control.caseSetup(),
+		prop
+	),
+	propertyId_
+	(
+		objectFile
+		(
+			"propertyId",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_NEVER
 		),
-	property_(prop),
-	shapes_(
-		control.caseSetup().emplaceObjectOrGet<sphereShape>(
-			objectFile(
-				sphereShapeFile__,
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_NEVER
-				)
-			)
+		dynPointStruct(),
+		0u
+	),
+	diameter_
+	(
+		objectFile(
+			"diameter",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_NEVER),
+		dynPointStruct(),
+		0.00000000001
+	),
+	mass_
+	(
+		objectFile(
+			"mass",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_NEVER),
+		dynPointStruct(),
+		0.0000000001
+	),
+	I_
+	(
+		objectFile
+		(
+			"I",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_NEVER
 		),
-	I_(
-		this->time().emplaceObject<realPointField_D>(
-			objectFile(
-				"I",
-				"",
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			static_cast<real>(0.0000000001)
-			)
-		),
-	rVelocity_(
-		this->time().emplaceObject<realx3PointField_D>(
-			objectFile(
-				"rVelocity",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			zero3
-			)
-		),
-	rAcceleration_(
-		this->time().emplaceObject<realx3PointField_D>(
-			objectFile(
-				"rAcceleration",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			zero3
-			)
+		dynPointStruct(),
+		static_cast<real>(0.0000000001)
+	),
+	rVelocity_
+	(
+		objectFile
+		(
+			"rVelocity",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS
 		),
+		dynPointStruct(),
+		zero3
+	),
+	rAcceleration_
+	(
+		objectFile(
+			"rAcceleration",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS
+			),
+		dynPointStruct(),
+		zero3
+	),
 	accelerationTimer_(
 		"Acceleration", &this->timers() ),
 	intPredictTimer_(
 		"Integration-predict", &this->timers() ),
 	intCorrectTimer_(
 		"Integration-correct", &this->timers() )
-
 {
-
-	REPORT(1)<<"Creating integration method "<<greenText(this->integrationMethod())
-		  << " for rotational velocity."<<endREPORT;
+	
+	auto intMethod = control.settingsDict().getVal<word>("integrationMethod");
+	REPORT(1)<<"Creating integration method "<<Green_Text(intMethod)
+		  << " for rotational velocity."<<END_REPORT;
 		  
-	rVelIntegration_ = 
-		integration::create(
+	rVelIntegration_ = integration::create
+		(
 			"rVelocity",
-			this->time().integration(),
-			this->pStruct(),
-			this->integrationMethod());
+			dynPointStruct(),
+			intMethod,
+			rVelocity_.field()
+		);
 
 	if( !rVelIntegration_ )
 	{
@@ -307,37 +362,17 @@ pFlow::sphereParticles::sphereParticles(
 		fatalExit;
 	}
 
-	if(rVelIntegration_->needSetInitialVals())
-	{
-		
-		auto [minInd, maxInd] = pStruct().activeRange();
-		int32IndexContainer indexHD(minInd, maxInd);
+	WARNING<<"setFields for rVelIntegration_"<<END_WARNING;
 	
-		auto n = indexHD.size();
-		auto index = indexHD.indicesHost();
-
-		realx3Vector rvel(n,RESERVE());
-		const auto hrVel = rVelocity_.hostVector();
-
-		for(auto i=0; i<n; i++)
-		{
-			rvel.push_back( hrVel[index(i)]);
-		}
-		
-		REPORT(2)<< "Initializing the required vectors for rotational velocity integratoin\n "<<endREPORT;
-		rVelIntegration_->setInitialVals(indexHD, rvel);
-
-	}
-
-	
-	if(!initializeParticles())
+	if(!initInertia())
 	{
+		fatalErrorInFunction;
 		fatalExit;
 	}
 	
 } 
 
-bool pFlow::sphereParticles::update(const eventMessage& msg) 
+/*bool pFlow::sphereParticles::update(const eventMessage& msg) 
 {
 	
 	if(rVelIntegration_->needSetInitialVals())
@@ -350,7 +385,7 @@ bool pFlow::sphereParticles::update(const eventMessage& msg)
 		auto index = indexHD.indicesHost();
 
 		realx3Vector rvel(n,RESERVE());
-		const auto hrVel = rVelocity_.hostVector();
+		const auto hrVel = rVelocity_.hostView();
 
 		for(auto i=0; i<n; i++)
 		{
@@ -362,9 +397,9 @@ bool pFlow::sphereParticles::update(const eventMessage& msg)
 	}	
 
 	return true;
-}
+}*/
 
-bool pFlow::sphereParticles::insertParticles
+/*bool pFlow::sphereParticles::insertParticles
 (
 	const realx3Vector& position,
  	const wordVector&  shapes,
@@ -419,4 +454,73 @@ bool pFlow::sphereParticles::insertParticles
 
 	return true;
 		
-}
\ No newline at end of file
+}*/
+
+bool pFlow::sphereParticles::beforeIteration()
+{
+	particles::beforeIteration();
+	intPredictTimer_.start();
+		auto dt = this->dt();
+		dynPointStruct().predict(dt, accelertion());
+		rVelIntegration_().predict(dt,rVelocity_, rAcceleration_);
+	intPredictTimer_.end();
+	
+	return true;
+}
+
+bool pFlow::sphereParticles::iterate() 
+{
+
+	particles::iterate();
+	accelerationTimer_.start();
+		pFlow::sphereParticlesKernels::acceleration(
+			control().g(),
+			mass().deviceViewAll(),
+			contactForce().deviceViewAll(),
+			I().deviceViewAll(),
+			contactTorque().deviceViewAll(),
+			dynPointStruct().activePointsMaskDevice(),
+			accelertion().deviceViewAll(),
+			rAcceleration().deviceViewAll()
+			);
+	accelerationTimer_.end();
+	
+	intCorrectTimer_.start();
+	
+		if(!dynPointStruct().correct(dt(), accelertion()))
+		{
+			return false;
+		}
+		if(!rVelIntegration_().correct(
+			dt(), 
+			rVelocity_, 
+			rAcceleration_))
+		{
+			return false;
+		}
+	
+	intCorrectTimer_.end();
+	
+	return true;
+}
+
+
+pFlow::word pFlow::sphereParticles::shapeTypeName()const
+{
+	return "sphere";
+}
+
+const pFlow::shape &pFlow::sphereParticles::getShapes() const
+{
+    return spheres_;
+}
+
+void pFlow::sphereParticles::boundingSphereMinMax
+(
+	real & minDiam, 
+	real& maxDiam
+)const
+{
+	minDiam = spheres_.minBoundingSphere();
+	maxDiam = spheres_.maxBoundingSphere();
+}
diff --git a/src/Particles/SphereParticles/sphereParticles/sphereParticles.hpp b/src/Particles/SphereParticles/sphereParticles/sphereParticles.hpp
index db9ad178..f2ad5e48 100644
--- a/src/Particles/SphereParticles/sphereParticles/sphereParticles.hpp
+++ b/src/Particles/SphereParticles/sphereParticles/sphereParticles.hpp
@@ -44,22 +44,30 @@ class sphereParticles
 :
 	public particles 
 {
-protected:
+public:
+	using ShapeType = sphereShape;
+private:
 
-	/// reference to material properties
-	const property& 	property_;
+		/// reference to shapes 
+	ShapeType 			spheres_;
 
-	/// reference to shapes 
-	sphereShape& 		shapes_;
+	/// property id on device
+	uint32PointField_D 		propertyId_;
+
+	/// diameter / boundig sphere size of particles on device
+	realPointField_D		diameter_;
+
+	/// mass of particles field 
+	realPointField_D 		mass_;
 
 	/// pointField of inertial of particles 
-	realPointField_D&     	I_;
+	realPointField_D     	I_;
 
 	/// pointField of rotational Velocity of particles on device 
-	realx3PointField_D& 	rVelocity_;
+	realx3PointField_D 	rVelocity_;
 
 	/// pointField of rotational acceleration of particles on device  
-	realx3PointField_D& 	rAcceleration_;	
+	realx3PointField_D 	rAcceleration_;	
 
 	/// rotational velocity integrator 
 	uniquePtr<integration>  rVelIntegration_ = nullptr;
@@ -73,9 +81,9 @@ protected:
 	/// timer for integration computations (correction step)
 	Timer 					intCorrectTimer_;
 
-	bool diameterMassInertiaPropId(const word& shName, real& diam, real& mass, real& I, int8& propIdx);
+	bool initInertia();
 
-	bool initializeParticles();
+	/*bool initializeParticles();
 
 	bool insertSphereParticles(
 		const wordVector& names, 
@@ -83,25 +91,17 @@ protected:
 		bool setId = true);
 
 	virtual uniquePtr<List<eventObserver*>> getFieldObjectList()const override;
+	*/
 
 public:
 
 	/// construct from systemControl and property 
-	sphereParticles(systemControl &control, const property& prop);
+	sphereParticles(
+		systemControl &control, 
+		const property& prop);
 
-	/// no copy constructor 
-	sphereParticles(const sphereParticles&) = delete;
 
-	/// move constructor 
-	sphereParticles(sphereParticles&&) = default;
-
-	/// no copy-assignement
-	sphereParticles& operator=(const sphereParticles&) = delete;
-
-	/// move-assignement
-	sphereParticles& operator=(sphereParticles&&) = default;
-
-	virtual ~sphereParticles()=default;
+	~sphereParticles()override=default;
 
 	/**
 	 * Insert new particles in position with specified shapes
@@ -112,17 +112,17 @@ public:
 	 * \param shape shape of new particles
 	 * \param setField initial value of the selected fields for new particles
 	 */
-	bool insertParticles
+	/*bool insertParticles
 	(
 		const realx3Vector& position,
 	 	const wordVector&  shapes,
 	 	const setFieldList& setField
-	) override ;
+	) override ;*/
 
 	/// const reference to shapes object 
-	const auto& shapes()const
+	const auto& spheres()const
 	{
-		return shapes_;
+		return spheres_;
 	}
 
 	/// const reference to inertia pointField
@@ -137,51 +137,75 @@ public:
 		return I_;
 	}
 	
-	const realx3Vector_D rVelocity()const 
+	const auto& rVelocity()const 
 	{	
 		return rVelocity_;
 	}
 
-	const realVector_D& boundingSphere()const override
-	{
-		return this->diameter();
+	auto& rVelocity()
+	{	
+		return rVelocity_;
 	}
 
-	word shapeTypeName() const override
+	bool hearChanges
+	(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+    	const anyList& varList
+	) override
 	{
-		return "sphere";
+		notImplementedFunction;
+		return false;
 	}
 
-	void boundingSphereMinMax(
-		real& minDiam,
-		real& maxDiam )const override
+	
+	const uint32PointField_D& propertyId()const override
 	{
-		shapes_.diameterMinMax(minDiam, maxDiam);
+		return propertyId_;
 	}
-
-	bool update(const eventMessage& msg) override;
 	
 	
-	realx3PointField_D& rAcceleration() override
+	const realPointField_D& diameter()const override
 	{
-		return rAcceleration_;
-	}
-	
-	const realx3PointField_D& rAcceleration() const override
-	{
-		return rAcceleration_;
+		return diameter_;
 	}
 
+
+	const realPointField_D& mass()const override
+	{
+		return mass_;
+	}
+	
 	/// before iteration step 
 	bool beforeIteration() override;
 
 	/// iterate particles 
 	bool iterate() override;	
 
-	/// after iteration step
-	bool afterIteration() override;
 	
+	realx3PointField_D& rAcceleration() override
+	{
+		return rAcceleration_;
+	}
 
+	const realx3PointField_D& rAcceleration() const override
+	{
+		return rAcceleration_;
+	}
+	
+	const realPointField_D& boundingSphere()const override
+	{
+		return diameter();
+	}
+
+	word shapeTypeName()const override;
+	
+	const shape& getShapes()const override;
+
+	
+	void boundingSphereMinMax(real & minDiam, real& maxDiam)const override;
 	
 }; //sphereParticles
 
diff --git a/src/Particles/SphereParticles/sphereParticles/sphereParticlesKernels.cpp b/src/Particles/SphereParticles/sphereParticles/sphereParticlesKernels.cpp
new file mode 100644
index 00000000..5e2def60
--- /dev/null
+++ b/src/Particles/SphereParticles/sphereParticles/sphereParticlesKernels.cpp
@@ -0,0 +1,100 @@
+/*------------------------------- 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 "sphereParticlesKernels.hpp"
+
+using policy = Kokkos::RangePolicy<
+			pFlow::DefaultExecutionSpace,
+			Kokkos::Schedule<Kokkos::Static>,
+			Kokkos::IndexType<pFlow::uint32>>;
+
+void pFlow::sphereParticlesKernels::addMassDiamInertiaProp
+(
+    deviceViewType1D<uint32>    shapeIndex,
+    deviceViewType1D<real>  	mass,
+	deviceViewType1D<real>  	diameter,
+	deviceViewType1D<real>  	I,
+    deviceViewType1D<uint32>  	propertyId,
+    pFlagTypeDevice 		    incld,
+    deviceViewType1D<real>  	src_mass,
+	deviceViewType1D<real>  	src_diameter,
+	deviceViewType1D<real>  	src_I,
+    deviceViewType1D<uint32>  	src_propertyId
+)
+{
+    auto aRange = incld.activeRange();
+
+    Kokkos::parallel_for(
+		"particles::initInertia",
+		policy(aRange.start(), aRange.end()),
+		LAMBDA_HD(uint32 i)
+		{
+			if(incld(i))
+			{
+				uint32 index = shapeIndex[i];
+				I[i] = src_I[index];
+				diameter[i] = src_diameter[index];
+				mass[i] = src_mass[index];
+				propertyId[i] = src_propertyId[index];
+			}
+		});
+
+}
+
+void pFlow::sphereParticlesKernels::acceleration
+( 
+	const realx3&					g,
+	const deviceViewType1D<real>&  	mass,
+	const deviceViewType1D<realx3>& force,
+	const deviceViewType1D<real>&  	I,
+	const deviceViewType1D<realx3>& torque,
+	const pFlagTypeDevice& 		    incld,
+	deviceViewType1D<realx3>  		lAcc,
+	deviceViewType1D<realx3>  		rAcc
+)
+{
+
+	auto activeRange = incld.activeRange();
+	if(incld.isAllActive())
+	{
+		Kokkos::parallel_for(
+		"pFlow::sphereParticlesKernels::acceleration",
+		policy(activeRange.start(), activeRange.end()),
+		LAMBDA_HD(uint32 i){
+				lAcc[i] = force[i]/mass[i] + g;
+				rAcc[i] = torque[i]/I[i];
+		});
+	}
+	else
+	{
+		Kokkos::parallel_for(
+		"pFlow::sphereParticlesKernels::acceleration",
+		policy(activeRange.start(), activeRange.end()),
+		LAMBDA_HD(uint32 i){
+			if(incld(i))
+			{
+				lAcc[i] = force[i]/mass[i] + g;
+				rAcc[i] = torque[i]/I[i];
+			}
+		});
+
+	}
+	
+	Kokkos::fence();
+}
diff --git a/src/Particles/SphereParticles/sphereParticles/sphereParticlesKernels.hpp b/src/Particles/SphereParticles/sphereParticles/sphereParticlesKernels.hpp
index 2edeff2b..628b1c49 100644
--- a/src/Particles/SphereParticles/sphereParticles/sphereParticlesKernels.hpp
+++ b/src/Particles/SphereParticles/sphereParticles/sphereParticlesKernels.hpp
@@ -21,56 +21,36 @@ Licence:
 #ifndef __sphereParticlesKernels_hpp__
 #define __sphereParticlesKernels_hpp__
 
+#include "types.hpp"
+#include "pointFlag.hpp"
+
 namespace pFlow::sphereParticlesKernels
 {
 
-using rpAcceleration = Kokkos::RangePolicy<
-			DefaultExecutionSpace,
-			Kokkos::Schedule<Kokkos::Static>,
-			Kokkos::IndexType<int32>
-			>;
-
-template<typename IncludeFunctionType>
-void acceleration( 
-	realx3		g,
-	deviceViewType1D<real>  	mass,
-	deviceViewType1D<realx3>  	force,
+void addMassDiamInertiaProp(
+    deviceViewType1D<uint32>    shapeIndex,
+    deviceViewType1D<real>  	mass,
+    deviceViewType1D<real>  	diameter,
 	deviceViewType1D<real>  	I,
-	deviceViewType1D<realx3>  	torque,
-	IncludeFunctionType 		incld,
-	deviceViewType1D<realx3> 	lAcc,
-	deviceViewType1D<realx3> 	rAcc
-	)
-{
+    deviceViewType1D<uint32>  	propertyId,
+    pFlagTypeDevice 		    incld,
+    deviceViewType1D<real>  	src_mass,
+	deviceViewType1D<real>  	src_diameter,
+	deviceViewType1D<real>  	src_I,
+    deviceViewType1D<uint32>  	src_propertyId
+);
 
-	auto activeRange = incld.activeRange();
-	if(incld.allActive())
-	{
-		Kokkos::parallel_for(
-		"pFlow::sphereParticlesKernels::acceleration",
-		rpAcceleration(activeRange.first, activeRange.second),
-		LAMBDA_HD(int32 i){
-				lAcc[i] = force[i]/mass[i] + g;
-				rAcc[i] = torque[i]/I[i];
-		});
-	}
-	else
-	{
-		Kokkos::parallel_for(
-		"pFlow::sphereParticlesKernels::acceleration",
-		rpAcceleration(activeRange.first, activeRange.second),
-		LAMBDA_HD(int32 i){
-			if(incld(i))
-			{
-				lAcc[i] = force[i]/mass[i] + g;
-				rAcc[i] = torque[i]/I[i];
-			}
-		});
+void acceleration( 
+	const realx3&					g,
+	const deviceViewType1D<real>&  	mass,
+	const deviceViewType1D<realx3>& force,
+	const deviceViewType1D<real>&  	I,
+	const deviceViewType1D<realx3>& torque,
+	const pFlagTypeDevice& 		    incld,
+	deviceViewType1D<realx3>  		lAcc,
+	deviceViewType1D<realx3>  		rAcc
+);
 
-	}
-	
-	Kokkos::fence();
-}
 
 }
 
diff --git a/src/Particles/SphereParticles/sphereShape/sphereShape.cpp b/src/Particles/SphereParticles/sphereShape/sphereShape.cpp
index 7723f039..fac52d3c 100644
--- a/src/Particles/SphereParticles/sphereShape/sphereShape.cpp
+++ b/src/Particles/SphereParticles/sphereShape/sphereShape.cpp
@@ -19,186 +19,182 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "sphereShape.hpp"
-#include "dictionary.hpp"
-#include "vocabs.hpp"
-#include "streams.hpp"
 
 
-bool pFlow::sphereShape::insertNames
-(
-	const wordVector& names
-)
+bool pFlow::sphereShape::readFromDictionary3()
 {
-	names_.clear();
-	uint32 i=0;
-	for(const auto& nm:names)
-	{
-		if(!names_.insertIf(nm, i))
-		{
-			fatalErrorInFunction<<
-			"  repeated name in the list of sphere names: " << names;
-			return false;
-		}
-		i++;
-	}
-	names_.rehash(0);
-	
-	numShapes_ = names_.size();
-	
-	return true;
-}
 
+	diameters_ = getVal<realVector>("diameters");
 
-bool pFlow::sphereShape::readDictionary
-(
-	const dictionary& dict
-)
-{
-	diameters_ = dict.getVal<realVector>("diameters");
-	materials_ = dict.getVal<wordVector>("materials");
-	auto names = dict.getVal<wordVector>("names");
-
-	if(diameters_.size() != materials_.size() )
+	if(diameters_.size() != numShapes() )
 	{
-		fatalErrorInFunction<<
-		"  number of elements in diameters and properties are not the same in "<< dict.globalName()<<endl;
-		return false;
-	}
-	else if(diameters_.size() != names.size() )
-	{
-		fatalErrorInFunction<<
-		"  number of elements in diameters and names are not the same in "<< dict.globalName()<<endl;
-		return false;
-	}
-
-	if( !insertNames(names) )
-	{
-		fatalErrorInFunction<<
-		"  error in reading dictionary "<< dict.globalName();
+		fatalErrorInFunction<< 
+		" number of elements in diameters in "<< globalName()<<" is not consistent"<<endl;
 		return false;
 	}
 
 	return true;
 }
 
-bool pFlow::sphereShape::writeDictionary
-(
-	dictionary& dict
-)const
+bool pFlow::sphereShape::writeToDict(dictionary& dict)const 
 {
+	
+	if(!shape::writeToDict(dict))return false;
 
-	if( !dict.add("diamters", diameters_) )
+	if( !dict.add("diameters", diameters_) )
 	{
-		fatalErrorInFunction<<  
+		fatalErrorInFunction<<
 		"  Error in writing diameters to dictionary "<< dict.globalName()<<endl;
 		return false;
 	}
 
-	if( !dict.add("properties", materials_) )
-	{
-		fatalErrorInFunction<<
-		"  Error in writing properties to dictionary "<< dict.globalName()<<endl;
-		return false;
-	}
-
-	size_t n = names_.size();
-	wordVector names(n);
-	names.clear();
-	word nm;
-	
-	for(label i=0; i<n; i++)
-	{
-		indexToName(i, nm);
-		names.push_back(nm);
-	}
-
-	if( !dict.add("names", names) )
-	{
-		fatalErrorInFunction<<
-		"  Error in writing names to dictionary "<< dict.globalName()<<endl;
-		return false;
-	}
-
 	return true;
 }
 
-
-
 pFlow::sphereShape::sphereShape
 (
-	const realVector& diameter,
-	const wordVector& property,
-	const wordVector& name
+	const word& fileName,
+	repository* owner,
+	const property& prop
 )
 :
-	diameters_(diameter),
-	materials_(property)
+	shape(fileName, owner, prop)
 {
-	if( !insertNames( name) )
+
+	if(!readFromDictionary3())
 	{
 		fatalExit;
+		fatalErrorInFunction;
 	}
 }
 
-bool pFlow::sphereShape::shapeToDiameter
-(
-	wordVector& names,
-	realVector& diams
-)const
+pFlow::real pFlow::sphereShape::maxBoundingSphere() const
 {
-	diams.clear();
-	uint32 idx;
-	for(const auto& nm:names)
-	{
-		if(!nameToIndex(nm, idx))
-		{
-			fatalErrorInFunction<<
-			"  invalid shape name requested "<< nm <<endl;
-			return false;
-		}
-		diams.push_back(diameters_[idx]);
-	}
-
-	return true;
+    return max(diameters_);
 }
 
-
-bool pFlow::sphereShape::read(iIstream& is)
+pFlow::real pFlow::sphereShape::minBoundingSphere() const
 {
-
-	dictionary sphereDict(sphereShapeFile__, true);
-
-	if( !sphereDict.read(is) )
-	{
-		ioErrorInFile(is.name(), is.lineNumber()) <<
-		"  error in reading dictionray " << sphereShapeFile__ <<" from file. \n";
-		return false;
-	}
-
-	if( !readDictionary(sphereDict) )
-	{
-		return false;
-	}
-
-	return true;
+    return min(diameters_);
 }
 
-bool pFlow::sphereShape::write(iOstream& os)const
+bool pFlow::sphereShape::boundingDiameter(uint32 index, real &bDiam) const
 {
-
-	dictionary sphereDict(sphereShapeFile__, true);
-
-	if( !writeDictionary(sphereDict))
+	if( indexValid(index))
 	{
-		return false;
+		bDiam = diameters_[index];
+		return true;
 	}
-
-	if( !sphereDict.write(os) )
-	{
-		ioErrorInFile( os.name(), os.lineNumber() )<<
-		"  error in writing dictionray to file. \n";
-		return false;
-	}
-
-	return true;
+    return false;
+}
+
+pFlow::real pFlow::sphereShape::boundingDiameter(uint32 index) const
+{
+    if(indexValid(index))
+	{
+		return diameters_[index];
+	}
+	fatalErrorInFunction<<"Invalid index for diameter "<<
+	index<<endl;
+	fatalExit;
+	return 0.0;
+}
+
+pFlow::realVector pFlow::sphereShape::boundingDiameter() const
+{
+    return diameters_;
+}
+
+bool pFlow::sphereShape::mass(uint32 index, real &m) const
+{
+    if( indexValid(index) )
+	{
+		real d = diameters_[index];
+		real rho = indexToDensity(index);
+		m = Pi/6.0*pow(d,3)*rho;
+		return true;
+	}
+	return false;
+}
+
+pFlow::real pFlow::sphereShape::mass(uint32 index) const
+{
+    if(real m; mass(index, m))
+	{
+		return m;
+	}
+	fatalErrorInFunction<<"bad index for mass "<< index<<endl;
+	fatalExit;
+	return 0;
+}
+
+pFlow::realVector pFlow::sphereShape::mass() const
+{
+    return realVector ("mass", Pi/6*pow(diameters_,(real)3.0)*density());
+}
+
+pFlow::realVector pFlow::sphereShape::density()const 
+{
+	auto pids = shapePropertyIds();
+	realVector rho("rho", numShapes());
+	ForAll(i, pids)
+	{
+		rho[i] = properties().density(pids[i]);
+	}
+	return rho;
+}
+
+bool pFlow::sphereShape::Inertia(uint32 index, real &I) const
+{
+	if( indexValid(index) )
+	{
+		I = 0.4 * mass(index) * pow(diameters_[index]/2.0,2.0);
+		return true;
+	}
+    return false;
+}
+
+pFlow::real pFlow::sphereShape::Inertia(uint32 index) const
+{
+	if(real I; Inertia(index, I))
+	{
+		return I;
+	}
+    fatalExit;
+	return 0;
+}
+
+pFlow::realVector pFlow::sphereShape::Inertia() const
+{
+    return realVector("I", (real)0.4*mass()*pow((real)0.5*diameters_,(real)2.0));
+}
+
+bool pFlow::sphereShape::Inertia_xx(uint32 index, real &Ixx) const
+{
+    return Inertia(index,Ixx);
+}
+
+pFlow::real pFlow::sphereShape::Inertial_xx(uint32 index) const
+{
+    return Inertia(index);
+}
+
+bool pFlow::sphereShape::Inertia_yy(uint32 index, real &Iyy) const
+{
+    return Inertia(index,Iyy);
+}
+
+pFlow::real pFlow::sphereShape::Inertial_yy(uint32 index) const
+{
+    return Inertia(index);
+}
+
+bool pFlow::sphereShape::Inertia_zz(uint32 index, real &Izz) const
+{
+    return Inertia(index,Izz);
+}
+
+pFlow::real pFlow::sphereShape::Inertial_zz(uint32 index) const
+{
+    return Inertia(index);
 }
diff --git a/src/Particles/SphereParticles/sphereShape/sphereShape.hpp b/src/Particles/SphereParticles/sphereShape/sphereShape.hpp
index f6357558..b59625ce 100644
--- a/src/Particles/SphereParticles/sphereShape/sphereShape.hpp
+++ b/src/Particles/SphereParticles/sphereShape/sphereShape.hpp
@@ -21,154 +21,76 @@ Licence:
 #ifndef __sphereShape_hpp__
 #define __sphereShape_hpp__
 
-#include "Vectors.hpp"
-#include "hashMap.hpp"
+#include "shape.hpp"
 
 namespace pFlow
 {
 
-class dictionary;
-
 class sphereShape
+:
+	public shape
 {
-protected:
+private:
 	
 	// - diameter of spheres
 	realVector 			diameters_;
 	
-	// - property name of spheres
-	wordVector 			materials_;
+	bool readFromDictionary3();
 
-	// - hashed list of spheres names
-	wordHashMap<uint32> names_;
+protected:
 
-	size_t 				numShapes_;
-
-
-	bool insertNames(const wordVector& names);
-
-	bool readDictionary(const dictionary& dict);
-
-	bool writeDictionary(dictionary& dict)const;
+	bool writeToDict(dictionary& dict)const override;
 
 public:
 
 	// - type info
-	TypeInfoNV("sphereShape");
+	TypeInfo("shape<sphere>");
 
+	sphereShape(
+		const word& fileName,
+		repository* owner,
+		const property& prop);
 
-		sphereShape(){}
-
-		sphereShape(
-			const realVector& diameter,
-			const wordVector& property,
-			const wordVector& name
-			);
-
-		sphereShape(const sphereShape&) = default;
-
-		sphereShape(sphereShape&&) = default;
-
-		sphereShape& operator=(const sphereShape&) = default;
-
-		sphereShape& operator=(sphereShape&&) = default;
-
-		auto clone()const
-		{
-			return makeUnique<sphereShape>(*this);
-		}
-
-		sphereShape* clonePtr()const
-		{
-			return new sphereShape(*this);
-		}
-
-		~sphereShape() = default;
+	
+	~sphereShape() override = default;
 
 	//// - Methods
-		const auto& names()const{
-			return names_;
-		}
 
-		const auto& diameters()const{
-			return diameters_;
-		}
+	real maxBoundingSphere()const override;
 
-		const auto& materials()const{
-			return materials_;
-		}
+    real minBoundingSphere()const override;
 
-		const auto diameter(label i)const{
-			return diameters_[i];
-		}
+	bool boundingDiameter(uint32 index, real& bDiam)const override;
 
-		const auto material(label i)const{
-			return materials_[i];
-		}
+	real boundingDiameter(uint32 index)const override;
 
+	realVector boundingDiameter()const override;
 
-		// name to index
-		bool nameToIndex(const word& name, uint32& index)const
-		{
-			if(auto[iter, found] = names_.findIf(name); found )
-			{
-				index = iter->second;
-				return true;
-			}
-			else
-			{
-				index = 0;
-				return false;
-			}
-		}
+	bool mass(uint32 index, real& m)const override;
 
-		uint32 nameToIndex(const word& name)const
-		{
-			return names_.at(name);
-		}
+	real mass(uint32 index) const override;
 
-		bool indexToName(uint32 i, word& name)const
-		{
-			for(auto& nm: names_)
-			{
-				if(nm.second == i)
-				{
-					name = nm.first;
-					return true;
-				}
-			}
-			name = "";
-			return false;
-		}
+	realVector mass()const override;
 
-		bool shapeToDiameter(wordVector& names, realVector& diams)const;
+    realVector density() const override;
 
-		void diameterMinMax(real& minD, real& maxD)const
-		{
-			minD = min(diameters_);
-			maxD = max(diameters_);
-		}
+	bool Inertia(uint32 index, real& I)const override;
 
-	//// - IO operatoin 
+	real Inertia(uint32 index)const override;
 
-		// - read from stream/file
-		bool read(iIstream& is);
+	realVector Inertia()const override;
+	 
+    bool Inertia_xx(uint32 index, real& Ixx)const override;
 
-		// - write to stream/file
-		bool write(iOstream& os)const;
+    real Inertial_xx(uint32 index)const override;
+	
+    bool Inertia_yy(uint32 index, real& Iyy)const override;
 
-		// - read from dictionary 
-		bool read(const dictionary& dict)
-		{
-			return readDictionary(dict);
-		}
+    real Inertial_yy(uint32 index)const override;
 
-		// - write to dictionary 
-		bool write(dictionary& dict)const
-		{
-			return writeDictionary(dict);
-		}
+    bool Inertia_zz(uint32 index, real& Izz)const override;
 
+    real Inertial_zz(uint32 index)const override;
 
 };
 
diff --git a/src/Particles/dynamicPointStructure/dynamicPointStructure.cpp b/src/Particles/dynamicPointStructure/dynamicPointStructure.cpp
index 16e5b849..593ca168 100644
--- a/src/Particles/dynamicPointStructure/dynamicPointStructure.cpp
+++ b/src/Particles/dynamicPointStructure/dynamicPointStructure.cpp
@@ -19,57 +19,40 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "dynamicPointStructure.hpp"
-
+#include "systemControl.hpp"
 
 pFlow::dynamicPointStructure::dynamicPointStructure
 (
-	Time& time,
-	const word& integrationMethod
+	systemControl& control
 )
 :
-	time_(time),
-	integrationMethod_(integrationMethod),
-	pStruct_(
-		time_.emplaceObject<pointStructure>(
-			objectFile(
-				pointStructureFile__,
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS			
-				)
-			)
-		),
-	velocity_(
-		time_.emplaceObject<realx3PointField_D>(
-			objectFile(
-				"velocity",
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			zero3
-			)
-		)
-
+	pointStructure(control),
+	velocity_
+	(
+		objectFile(
+			"velocity",
+			"",
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_ALWAYS
+			),
+		*this,
+		zero3
+	),
+	integrationMethod_
+	(
+		control.settingsDict().getVal<word>("integrationMethod")
+	)
 {
-
-	this->subscribe(pStruct());
-
 	REPORT(1)<< "Creating integration method "<<
-		greenText(integrationMethod_)<<" for dynamicPointStructure."<<endREPORT;
+		Green_Text(integrationMethod_)<<" for dynamicPointStructure."<<END_REPORT;
 
-	integrationPos_ = integration::create(
+	integrationPos_ = integration::create
+	(
 		"pStructPosition",
-		time_.integration(),
-		pStruct(),
-		integrationMethod_);
-	
-	integrationVel_ = integration::create(
-		"pStructVelocity",
-		time_.integration(),
-		pStruct(),
-		integrationMethod_);
+		*this,
+		integrationMethod_,
+		pointPosition()
+	);
 
 	if( !integrationPos_ )
 	{
@@ -77,6 +60,14 @@ pFlow::dynamicPointStructure::dynamicPointStructure
 		"  error in creating integration object for dynamicPointStructure (position). \n";
 		fatalExit;
 	}
+	
+	integrationVel_ = integration::create
+	(
+		"pStructVelocity",
+		*this,
+		integrationMethod_,
+		velocity_.field()
+	);
 
 	if( !integrationVel_ )
 	{
@@ -85,48 +76,49 @@ pFlow::dynamicPointStructure::dynamicPointStructure
 		fatalExit;
 	}
 
-	
-	if(!integrationPos_->needSetInitialVals()) return;
-
-	
-		
-	auto [minInd, maxInd] = pStruct().activeRange();
-	int32IndexContainer indexHD(minInd, maxInd);
-	
-	auto n = indexHD.size();
-	auto index = indexHD.indicesHost();
-
-	realx3Vector pos(n,RESERVE());
-	realx3Vector vel(n,RESERVE());
-	const auto hVel = velocity().hostVector();
-	const auto hPos = pStruct().pointPosition().hostVector();
-
-	for(auto i=0; i<n; i++)
-	{
-		pos.push_back( hPos[index(i)]);
-		vel.push_back( hVel[index(i)]);
-	}
-
-	//output<< "pos "<< pos<<endl;
-	//output<< "vel "<< vel<<endl;
-
-	REPORT(2)<< "Initializing the required vectors for position integratoin "<<endREPORT;
-	integrationPos_->setInitialVals(indexHD, pos);
-
-	REPORT(2)<< "Initializing the required vectors for velocity integratoin\n "<<endREPORT;
-	integrationVel_->setInitialVals(indexHD, vel);
 }
 
-bool pFlow::dynamicPointStructure::predict
-(
-	real dt,
-	realx3PointField_D& acceleration
-)
+/*bool pFlow::dynamicPointStructure::beforeIteration()
 {
-	auto& pos = pStruct().pointPosition();
+	pointStructure::beforeIteration();
+	auto& acc = time().lookupObject<realx3PointField_D>("acceleration");
+    return predict(dt(), acc);
+}*/
 
-	if(!integrationPos_().predict(dt, pos.VectorField(), velocity_.VectorField() ))return false;
-	if(!integrationVel_().predict(dt, velocity_.VectorField(), acceleration.VectorField()))return false;
+/*bool pFlow::dynamicPointStructure::iterate()
+{
+	pointStructure::iterate();
+	auto& acc = time().lookupObject<realx3PointField_D>("acceleration");
+    return correct(dt(), acc);
+    
+}*/
+
+bool pFlow::dynamicPointStructure::beforeIteration()
+{
+	return pointStructure::beforeIteration();
+	/*real dt = this->dt();
+
+    auto& acc = time().lookupObject<realx3PointField_D>("acceleration");
+	return predict(dt, acc);*/
+}
+
+bool pFlow::dynamicPointStructure::iterate()
+{
+	return pointStructure::iterate();
+	
+	/*real dt = this->dt();
+
+    auto& acc = time().lookupObject<realx3PointField_D>("acceleration");
+    return correct(dt, acc);*/
+}
+
+bool pFlow::dynamicPointStructure::predict(
+    real dt,
+    realx3PointField_D &acceleration)
+{
+	
+	if(!integrationPos_().predict(dt, pointPosition(), velocity_ ))return false;
+	if(!integrationVel_().predict(dt, velocity_, acceleration))return false;
 
 	return true;
 }
@@ -137,11 +129,11 @@ bool pFlow::dynamicPointStructure::correct
 	realx3PointField_D& acceleration
 )
 {
-	auto& pos = pStruct().pointPosition();
+	//auto& pos = pStruct().pointPosition();
 	
-	if(!integrationPos_().correct(dt, pos.VectorField(), velocity_.VectorField() ))return false;
+	if(!integrationPos_().correct(dt, pointPosition(), velocity_) )return false;
 	
-	if(!integrationVel_().correct(dt, velocity_.VectorField(), acceleration.VectorField()))return false;
+	if(!integrationVel_().correct(dt, velocity_, acceleration))return false;
 
 	return true;	
 }
@@ -160,7 +152,7 @@ pFlow::uniquePtr<pFlow::int32IndexContainer> pFlow::dynamicPointStructure::inser
 
 	if(!integrationPos_().needSetInitialVals()) return newIndicesPtr;
 
-	auto hVel = velocity_.hostVector();
+	auto hVel = velocity_.hostView();
 	auto n = newIndicesPtr().size();
 	auto index = newIndicesPtr().indicesHost();
 
@@ -178,7 +170,7 @@ pFlow::uniquePtr<pFlow::int32IndexContainer> pFlow::dynamicPointStructure::inser
 }*/
 
 
-bool pFlow::dynamicPointStructure::update(
+/*bool pFlow::dynamicPointStructure::update(
 	const eventMessage& msg) 
 {
 	if( msg.isInsert())
@@ -197,8 +189,8 @@ bool pFlow::dynamicPointStructure::update(
 
 		realx3Vector pos(n,RESERVE());
 		realx3Vector vel(n,RESERVE());
-		const auto hVel = velocity().hostVector();
-		const auto hPos = pStruct().pointPosition().hostVector();
+		const auto hVel = velocity().hostView();
+		const auto hPos = pStruct().pointPosition().hostView();
 
 		for(auto i=0; i<n; i++)
 		{
@@ -215,4 +207,4 @@ bool pFlow::dynamicPointStructure::update(
 	}
 
 	return true;
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/src/Particles/dynamicPointStructure/dynamicPointStructure.hpp b/src/Particles/dynamicPointStructure/dynamicPointStructure.hpp
index 843a3c46..1195f389 100644
--- a/src/Particles/dynamicPointStructure/dynamicPointStructure.hpp
+++ b/src/Particles/dynamicPointStructure/dynamicPointStructure.hpp
@@ -30,98 +30,70 @@ Licence:
 namespace pFlow
 {
 
+class systemControl;
+
 class dynamicPointStructure
 :
-	//public pointStructure
-public eventObserver
+	public pointStructure
 {
-protected:
+private:
 
-	Time& time_;
+	realx3PointField_D  	velocity_;
 
-	word 			integrationMethod_;
+	uniquePtr<integration>  integrationPos_ = nullptr;
 
-	pointStructure& 	pStruct_;
+	uniquePtr<integration>  integrationVel_ = nullptr;
 
-	realx3PointField_D&  	velocity_;
-
-	uniquePtr<integration>  integrationPos_;
-
-	uniquePtr<integration>  integrationVel_;
+	/// @brief integration method for velocity and position
+	word 					integrationMethod_;
 
 public:
 
 	TypeInfo("dynamicPointStructure");
 
-	dynamicPointStructure(Time& time, const word& integrationMethod);
-
-	dynamicPointStructure(const dynamicPointStructure& ps) = default;
+	explicit dynamicPointStructure(systemControl& control);
 
+	dynamicPointStructure(const dynamicPointStructure& ps) = delete;
 		
-		// - no move construct 
+	// - no move construct 
 	dynamicPointStructure(dynamicPointStructure&&) = delete;
 
-	// - copy assignment 
-	//
-	//   should be changed, may causs undefined behavior 
-	//////////////////////////////////////////////////////////////
-	dynamicPointStructure& operator=(const dynamicPointStructure&) = default;
+	/// 
+	dynamicPointStructure& operator=(const dynamicPointStructure&) = delete;
 
 	// - no move assignment 
 	dynamicPointStructure& operator=(dynamicPointStructure&&) = delete;
 
 	// - destructor 
-	virtual ~dynamicPointStructure() = default;
+	~dynamicPointStructure() override = default;
 
 
-	inline pointStructure& pStruct() 
-	{
-		return pStruct_;
-	}
-
-	inline const pointStructure& pStruct() const
-	{
-		return pStruct_;
-	}
-
-	inline const realx3PointField_D& velocity()const
+	inline 
+	const realx3PointField_D& velocity()const
 	{
 		return velocity_;
 	}
 
-	inline auto velocityHostAll()
+	inline 
+	realx3PointField_D& velocity()
 	{
-		return velocity_.hostVectorAll();
+		return velocity_;
 	}
 
-	inline auto pointPositionHostAll()
-	{
-		return pStruct_.pointPositionHostAll();
-	}
+	/// 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;
+	
+		
 
-	auto markDeleteOutOfBox(const box& domain)
-	{
-		return pStruct_.markDeleteOutOfBox(domain);
-	}
 
 	bool predict(real dt, realx3PointField_D& acceleration);
 
 	bool correct(real dt, realx3PointField_D& acceleration);
 
-
-	// - update data structure by inserting/setting new points 
-	//   Notifies all the fields in the registered list of data structure
-	//   and exclude the fields that re in the exclusionList
-	//   retrun nullptr if it fails 
-	/*FUNCTION_H
-	virtual uniquePtr<int32IndexContainer> insertPoints(
-		const realx3Vector& pos,
-		const List<eventObserver*>& exclusionList={nullptr}
-	)override;*/
-
-	bool update(const eventMessage& msg) override;
-	
-
 };
 
 }
diff --git a/src/Particles/particles/baseShapeNames.cpp b/src/Particles/particles/baseShapeNames.cpp
new file mode 100644
index 00000000..eaef39cb
--- /dev/null
+++ b/src/Particles/particles/baseShapeNames.cpp
@@ -0,0 +1,122 @@
+/*------------------------------- 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 "baseShapeNames.hpp"
+
+bool pFlow::baseShapeNames::createHashNames()
+{
+	hashNames_.clear();
+	hashes_.clear();
+
+	std::hash<word> hasher;
+
+	uint32 i=0;
+	for(const auto& nm:shapeNames_)
+	{
+		if(!hashNames_.insertIf(nm, i))
+		{
+			fatalErrorInFunction<<
+			"  repeated name in the list of shape names: " << shapeNames_;
+			return false;
+		}
+		hashes_.push_back(hasher(nm));
+		i++;
+	}
+	hashNames_.rehash(0);
+	
+	return true;
+}
+
+
+bool pFlow::baseShapeNames::readFromDictionary1()
+{
+	
+	shapeNames_ = getVal<wordVector>("names");
+	numShapes_ = shapeNames_.size();
+
+	return true;
+}
+
+
+pFlow::baseShapeNames::baseShapeNames
+(
+    const word &fileName, 
+    repository *owner
+)
+:
+    fileDictionary
+    (
+        objectFile
+        (
+            fileName,
+            "",
+            objectFile::READ_ALWAYS,
+            objectFile::WRITE_ALWAYS
+        ),
+        owner
+    )
+{
+	
+	if( !readFromDictionary1() )
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+
+	if( !createHashNames())
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+
+}
+
+
+bool pFlow::baseShapeNames::writeToDict(dictionary &dict)const
+{
+	
+	if( !dict.add("names", shapeNames_) )
+	{
+		fatalErrorInFunction<<
+		"  Error in writing names to dictionary "<< dict.globalName()<<endl;
+		return false;
+	}
+
+	return true;
+}
+
+bool pFlow::baseShapeNames::write(iOstream &os) const
+{
+	dictionary newDict(fileDictionary::dictionary::name(), true);
+
+	if( !writeToDict(newDict) )
+	{
+		return false;
+	}
+
+	if( !newDict.write(os) )
+	{
+		fatalErrorInFunction<<"Error in writing dictionary "<< globalName()<<
+		"to stream "<< os.name()<<endl; 
+		return false;
+	}
+
+	return true;
+}
diff --git a/src/Particles/particles/baseShapeNames.hpp b/src/Particles/particles/baseShapeNames.hpp
new file mode 100644
index 00000000..bc513b06
--- /dev/null
+++ b/src/Particles/particles/baseShapeNames.hpp
@@ -0,0 +1,153 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+#ifndef __baseShapeNames_hpp__
+#define __baseShapeNames_hpp__
+
+#include "fileDictionary.hpp"
+#include "Vectors.hpp"
+#include "hashMap.hpp"
+
+
+namespace pFlow
+{
+
+class repository;
+
+class baseShapeNames
+:
+	public fileDictionary
+{
+private:
+
+	size_t 				numShapes_ = 0;
+
+	// - hashed list of spheres names
+	wordHashMap<uint32> hashNames_;
+
+	/// list of shape names 
+	wordVector 			shapeNames_{"shapeNames"};
+
+	/// hash for names 
+	Vector<size_t> 		hashes_{"hashes"};
+	
+	bool createHashNames();
+
+	bool readFromDictionary1();	
+
+	using hasher 	= typename wordHashMap<uint32>::hasher;
+
+protected:
+
+	virtual
+	bool writeToDict(dictionary& dict)const;
+
+public:
+    
+    TypeInfo("baseShapeNames");
+
+	baseShapeNames(
+		const word& fileName,
+		repository* owner);
+
+    ~baseShapeNames() override=default;
+	
+
+    inline
+    const wordVector& shapeNames()const
+	{
+		return shapeNames_;
+	}
+
+	inline 
+	wordList shapeNameList()const
+	{
+		wordList wl;
+		wl.insert(wl.begin(), shapeNames_.begin(), shapeNames_.end());
+		return wl;
+	}
+
+	inline
+	const auto& hashes()const
+	{
+		return hashes_;
+	}
+
+    inline
+    size_t numShapes()const
+	{
+		return numShapes_;
+	}
+
+	// name to index
+	inline
+	bool shapeNameToIndex(const word& name, uint32& index)const
+	{
+		if(auto[iter, found] = hashNames_.findIf(name); found )
+		{
+			index = iter->second;
+			return true;
+		}
+		else
+		{
+			index = 0;
+			return false;
+		}
+	}
+
+	inline
+	bool indexToShapeName(uint32 i, word& name)const
+	{
+		if( i < numShapes_)
+		{
+			name = shapeNames_[i];
+			return true;
+		}
+		return false;
+	}
+
+	inline bool hashToIndex(const size_t& hs, uint32& idx)
+	{
+		for(auto i=0; i<hashes_.size(); i++)
+		{
+			if(hashes_[i]==hs)
+			{
+				idx = i;
+				return true;
+			}
+		}
+		idx = -1;
+		return false;
+	}
+
+	inline
+	bool indexValid(uint32 index)const
+	{
+		return index < numShapes_;
+	}
+
+	// - IO
+
+	bool write(iOstream& os)const override;
+
+};
+
+}
+
+#endif //__shapeNames_hpp__
\ No newline at end of file
diff --git a/src/Particles/particles/particleIdHandler.cpp b/src/Particles/particles/particleIdHandler.cpp
index 71dec22a..c5bae004 100644
--- a/src/Particles/particles/particleIdHandler.cpp
+++ b/src/Particles/particles/particleIdHandler.cpp
@@ -20,39 +20,36 @@ Licence:
 
 #include "particleIdHandler.hpp"
 
-
-
-pFlow::particleIdHandler::particleIdHandler(int32PointField_HD & id)
+pFlow::particleIdHandler::particleIdHandler(uint32PointField_D &id)
+:
+	id_(id)
 {
-	int32 maxID = maxActive<DeviceSide>(id);
+}
 
-	if( maxID != -1 	 && id.size() == 0 )
+pFlow::uniquePtr<pFlow::particleIdHandler> 
+	pFlow::particleIdHandler::create(uint32PointField_D &id)
+{
+    word idHType = angleBracketsNames(
+        "particleIdHandler", 
+        pFlowProcessors().localRunTypeName());
+
+
+	if( pointFieldvCtorSelector_.search(idHType) )
 	{
-		nextId_ = 0;
-	}
-	else if( maxID == -1 && id.size()>0 )
-	{
-
-		nextId_ = 0; 
-		id.modifyOnHost();
-
-		ForAll(i,id)
-		{
-			if(id.isActive(i))
-			{
-				id[i] = getNextId();	
-			}
-		}
-
-		id.syncViews();
-	}
-	else if( maxID >= static_cast<int32>(id.size()) )
-	{
-		nextId_ = maxID + 1;
+		REPORT(1)<<"Creating particle id handler "<< 
+			Green_Text(idHType)<<END_REPORT;
+		return pointFieldvCtorSelector_[idHType] (id);
 	}
 	else
 	{
-		nextId_ = id.size();
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< idHType << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			pointFieldvCtorSelector_
+		);
+		fatalExit;
 	}
+	return nullptr;
 }
-
diff --git a/src/Particles/particles/particleIdHandler.hpp b/src/Particles/particles/particleIdHandler.hpp
index d93e6b1f..9ec528de 100644
--- a/src/Particles/particles/particleIdHandler.hpp
+++ b/src/Particles/particles/particleIdHandler.hpp
@@ -29,20 +29,44 @@ namespace pFlow
 
 class particleIdHandler
 {
-protected:
-	int32 nextId_=0;
-public:
-	particleIdHandler(int32PointField_HD & id);
+private:
 	
-	int32 getNextId()
+  uint32PointField_D&    id_;
+
+protected:
+
+	auto& id()
 	{
-		return nextId_++;
+		return id_;
 	}
 
-	int32 nextId() const
-	{
-		return nextId_;
-	}
+public:
+	
+	TypeInfo("particleIdHandler");
+
+	explicit particleIdHandler(uint32PointField_D & id);
+
+	create_vCtor
+	(
+		particleIdHandler,
+		pointField,
+		(uint32PointField_D & id),
+		(id)
+	);
+
+	virtual 
+	~particleIdHandler()=default;
+
+	virtual
+	Pair<uint32, uint32> getIdRange(uint32 nNewParticles)=0;
+
+	virtual 
+	bool initialIdCheck()=0;
+
+	static
+	uniquePtr<particleIdHandler> create(
+		uint32PointField_D & id);
+	
 };
 
 }
diff --git a/src/Particles/particles/particles.cpp b/src/Particles/particles/particles.cpp
index d5c3bb45..7b3a41d6 100644
--- a/src/Particles/particles/particles.cpp
+++ b/src/Particles/particles/particles.cpp
@@ -24,179 +24,97 @@ Licence:
 
 pFlow::particles::particles
 (
-	systemControl& control,
-	const word& integrationMethod
+    systemControl &control
 )
-:
-	demParticles(control),
-	time_(control.time()),
-	integrationMethod_(integrationMethod),
-	/*dynPointStruct_(
-		time_.emplaceObject<dynamicPointStructure>(
-			objectFile(
-				pointStructureFile__,
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS			
-				),
-			control.time(),
-			integrationMethod
-			)
-		),*/
-	dynPointStruct_(
-		control.time(),
-		integrationMethod),
-	shapeName_(
-		control.time().emplaceObject<wordPointField>(
-			objectFile(
-				"shapeName",
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_ALWAYS,
-				false
-				),
-			pStruct(),
-			word("NO_NAME_SHAPE")
-			)
+: 
+	observer(defaultMessage_),
+	demComponent("particles", control),
+	dynPointStruct_(control),
+	id_
+	(
+		objectFile
+		(
+			"id",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS
 		),
-	id_(
-		control.time().emplaceObject<int32PointField_HD>(
-			objectFile(
-				"id",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			static_cast<int32>(-1)
-			)
-		),
-	propertyId_(
-		control.time().emplaceObject<int8PointField_D>(
-			objectFile(
-				"propertyId",
-				"",
-				objectFile::READ_NEVER,
-				objectFile::WRITE_NEVER
-				),
-			pStruct(),
-			static_cast<int8>(0)
-			)
-		),
-	diameter_(
-		control.time().emplaceObject<realPointField_D>(
-			objectFile(
-				"diameter",
-				"",
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			static_cast<real>(0.00000000001)
-			)
-		),
-	mass_(
-		control.time().emplaceObject<realPointField_D>(
-			objectFile(
-				"mass",
-				"",
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			static_cast<real>(0.0000000001)
-			)
-		),
-	accelertion_(
-		control.time().emplaceObject<realx3PointField_D>(
-			objectFile(
-				"accelertion",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			zero3
-			)
+		dynPointStruct_,
+		static_cast<uint32>(-1),
+		static_cast<uint32>(-1)
+	),
+	shapeIndex_
+	(
+		objectFile
+		(
+			"shapeIndex",
+			"",
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_ALWAYS
 		),
+		dynPointStruct_,
+		0
+	),
+	accelertion_
+	(
+		objectFile(
+			"accelertion",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS),
+		dynPointStruct_,
+		zero3
+	),
 	contactForce_(
-		control.time().emplaceObject<realx3PointField_D>(
-			objectFile(
-				"contactForce",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			zero3
-			)
-		),
+		objectFile(
+			"contactForce",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS),
+		dynPointStruct_,
+		zero3),
 	contactTorque_(
-		control.time().emplaceObject<realx3PointField_D>(
-			objectFile(
-				"contactTorque",
-				"",
-				objectFile::READ_IF_PRESENT,
-				objectFile::WRITE_ALWAYS
-				),
-			pStruct(),
-			zero3
-			)
-		),
-	idHandler_(id_)
+		objectFile(
+			"contactTorque",
+			"",
+			objectFile::READ_IF_PRESENT,
+			objectFile::WRITE_ALWAYS),
+		dynPointStruct_,
+		zero3),
+	idHandler_(particleIdHandler::create(id_))
 {
-	
-	this->subscribe(pStruct());
+	this->addToSubscriber(dynPointStruct_);
+
+	idHandler_().initialIdCheck();
 
 }
 
 bool pFlow::particles::beforeIteration() 
 {
-	auto domain = this->control().domain();
-
-	auto numMarked = dynPointStruct_.markDeleteOutOfBox(domain);
 	
-	if(time_.sortTime())
-	{
-		real min_dx, max_dx;
-		boundingSphereMinMax(min_dx, max_dx);
-		Timer t;
-		t.start();
-		REPORT(0)<<"Performing morton sorting on particles ...."<<endREPORT;
-		if(!pStruct().mortonSortPoints(domain, max_dx))
-		{
-			fatalErrorInFunction<<"Morton sorting was not successful"<<endl;
-			return false;
-		}
-		t.end();
-		REPORT(1)<<"Active range is "<< pStruct().activeRange()<<endREPORT;
-		REPORT(1)<<"It took "<< yellowText(t.totalTime())<<" seconds."<<endREPORT;
-	}
+	zeroForce();
+	zeroTorque();
 
-	this->zeroForce();
-	this->zeroTorque();
-
-	return true;
+	return dynPointStruct_.beforeIteration();
 }
 
-pFlow::uniquePtr<pFlow::List<pFlow::eventObserver*>> 
-pFlow::particles::getFieldObjectList()const
+bool pFlow::particles::iterate()
 {
-	auto objListPtr = makeUnique<pFlow::List<pFlow::eventObserver*>>();
-	objListPtr().push_back(
-		static_cast<eventObserver*>(&id_) );
-		
-	objListPtr().push_back(
-		static_cast<eventObserver*>(&propertyId_) );
-
-	objListPtr().push_back(
-		static_cast<eventObserver*>(&diameter_) );
-
-	objListPtr().push_back(
-		static_cast<eventObserver*>(&mass_) );
-	
-	objListPtr().push_back(
-		static_cast<eventObserver*>(&shapeName_) );
-	
-	return objListPtr;
+	return dynPointStruct_.iterate();
 }
+
+bool pFlow::particles::afterIteration() 
+{
+	return dynPointStruct_.afterIteration();
+}
+
+void pFlow::particles::boundingSphereMinMax
+(
+	real &minDiam, 
+	real &maxDiam
+) const
+{
+	auto& shp = getShapes();
+	minDiam = shp.minBoundingSphere();
+	maxDiam = shp.maxBoundingSphere();
+}
\ No newline at end of file
diff --git a/src/Particles/particles/particles.hpp b/src/Particles/particles/particles.hpp
index 7b207c50..8ba1cfce 100644
--- a/src/Particles/particles/particles.hpp
+++ b/src/Particles/particles/particles.hpp
@@ -23,57 +23,44 @@ Licence:
 #define __particles_hpp__
 
 #include "dynamicPointStructure.hpp"
+#include "demComponent.hpp"
+#include "shape.hpp"
 #include "particleIdHandler.hpp"
-#include "demParticles.hpp"
+
 namespace pFlow
 {
 
-class setFieldList;
-
 class particles
 :
-	public eventObserver,
-	public demParticles
+	public observer,
+	public demComponent
 {
-protected:
+private:
 	
-	// owner repository 
-	Time& time_;
-
-	const word integrationMethod_;
-
-	// dynamic point structure for particles 
+	/// dynamic point structure for particles center mass
 	dynamicPointStructure 	dynPointStruct_;
 
-	// - name of shapes - this is managed by particles 
-	wordPointField&  		shapeName_;
-
-	// id of particles on host
-	int32PointField_HD&		id_;
-
-	// property id on device
-	int8PointField_D& 		propertyId_;
-
-	// diameter / boundig sphere size of particles on device
-	realPointField_D&		diameter_;
-
-	// mass on device
-	realPointField_D& 		mass_;
-
-	// - acceleration on device
-	realx3PointField_D& 	accelertion_;
-
-
-	realx3PointField_D&     contactForce_;
-
-
-	realx3PointField_D&     contactTorque_;	
+	/// id of particles on host
+	uint32PointField_D		id_;
 
 	
-	// - object handling particle id
-	particleIdHandler		idHandler_;
+	uint32PointField_D 		shapeIndex_;
 
-	virtual uniquePtr<List<eventObserver*>> getFieldObjectList()const;
+	/// acceleration on device
+	realx3PointField_D 		accelertion_;
+
+	/// contact force field
+	realx3PointField_D     contactForce_;
+
+	/// contact torque field
+	realx3PointField_D     contactTorque_;
+
+	uniquePtr<particleIdHandler> idHandler_ = nullptr;
+
+	static inline
+	const message defaultMessage_{message::DEFAULT}; 
+	
+	
 
 	void zeroForce()
 	{
@@ -85,173 +72,150 @@ protected:
 		contactTorque_.fill(zero3);
 	}
 
-public:
-
-	// type info
-	TypeInfo("particles");
-
-	particles(systemControl& control, const word& integrationMethod);
-
-	inline const auto& time()const {
-		return time_;
-	}
-
-	inline auto& time() {
-		return time_;
-	}
-	
-	inline auto integrationMethod()const
-	{
-		return integrationMethod_;
-	}
-
-	inline const auto& dynPointStruct()const 
-	{
-		return dynPointStruct_;
-	}
+protected:
 
 	inline auto& dynPointStruct()
 	{
 		return dynPointStruct_;
 	}
 
-	inline const auto& pStruct()const{
-		return dynPointStruct_.pStruct();
+	inline auto& pointPosition()
+	{
+		return dynPointStruct_.pointPosition();	
 	}
 
-	inline auto& pStruct(){
-		return dynPointStruct_.pStruct();
+	/*inline 
+	auto& velocity()
+	{
+		return dynPointStruct_.velocity();
+	}*/
+
+	inline 
+	auto& shapeIndex()
+	{
+		return shapeIndex_;
+	}
+
+public:
+
+	// type info
+	TypeInfo("particles");
+
+	explicit particles(systemControl& control);
+
+
+	inline 
+	const auto& dynPointStruct()const 
+	{
+		return dynPointStruct_;
+	}
+
+	inline
+	const pointStructure& pStruct()const
+	{
+		return dynPointStruct_;
+	}
+
+	inline
+	const auto& simDomain()const
+	{
+		return dynPointStruct_.simDomain();
+	}
+
+	inline 
+	const auto& thisDomain()const
+	{
+		return dynPointStruct_.thisDomain();
 	}
 
 	inline auto size()const{
-		return pStruct().size();
+		return dynPointStruct_.size();
 	}
 
 	inline auto capacity() const{
-		return pStruct().capacity();
-	}
-
-	inline auto activePointsMaskD()const{
-		return pStruct().activePointsMaskD();
-	}
-
-	inline auto numActive()const
-	{
-		return pStruct().numActive();
+		return dynPointStruct_.capacity();
 	}
 	
-	inline bool allActive()const{
-		return pStruct().allActive();
-	}
-
-	inline auto activeRange()const{
-		return pStruct().activeRange();
-	}
-
-	inline auto activePointsMaskH()const{
-		return pStruct().activePointsMaskH();
-	}
-
-	inline const auto& pointPosition()const{
-		return pStruct().pointPosition();
-	}
-
-	inline const auto& position()const
+	inline auto numActive()const
 	{
-		return pStruct().pointPosition();	
+		return dynPointStruct_.numActive();
+	}
+	
+	inline bool isAllActive()const
+	{
+		return dynPointStruct_.isAllActive();
 	}
 
-	inline const auto& pointVelocity()const{
-		return dynPointStruct().velocity();
+	inline 
+	const auto& pointPosition()const
+	{
+		return dynPointStruct_.pointPosition();
 	}
 
-	inline const auto& velocity()const{
-		return dynPointStruct().velocity();
+	inline 
+	const auto& velocity()const
+	{
+		return dynPointStruct_.velocity();
 	}
 
-	inline const auto& id()const{
-		return id_;
-	}
-
-	inline auto& id(){
-		return id_;
-	}
-
-	inline const auto& diameter()const{
-		return diameter_;
-	}
-
-	inline auto& diameter(){
-		return diameter_;
-	}
-
-	inline const auto& mass()const{
-		return mass_;
-	}
-
-	inline auto& mass()	{
-		return mass_;
-	}
-
-	inline const auto& accelertion()const{
-		return accelertion_;
-	}
-
-	inline auto& accelertion(){
+	inline 
+	const auto& accelertion()const
+	{
 		return accelertion_;
 	}
 
 	inline 
-	realx3PointField_D& contactForce() 
+	auto& accelertion()
+	{
+		return accelertion_;
+	}
+
+	inline 
+	auto& contactForce() 
 	{
 		return contactForce_;
 	}
 
 	inline
-	const realx3PointField_D& contactForce() const
+	const auto& contactForce() const
 	{
 		return contactForce_;
 	}
 
 	inline
-	realx3PointField_D& contactTorque()
+	auto& contactTorque()
 	{
 		return contactTorque_;
 	}
 
 	inline
-	const realx3PointField_D& contactTorque() const 
+	const auto& contactTorque() const 
 	{
 		return contactTorque_;
 	}
 
-	inline const auto& propertyId()const{
-		return propertyId_;
-	}
-
-	inline auto& propertyId(){
-		return propertyId_;
-	}
-
-	inline const auto& shapeName()const{
-		return shapeName_;
-	}
-
-	inline auto& shapName(){
-		return shapeName_;
-	}
-
 	bool beforeIteration() override;
 
-	virtual
+	bool iterate()override;
+
+	bool afterIteration() override;
+
+	/*virtual
 	bool insertParticles
 	(
 		const realx3Vector& position,
 	 	const wordVector&  shapes,
 	 	const setFieldList& setField
-	 ) = 0;
+	 ) = 0;*/
 
+	virtual 
+	const uint32PointField_D& propertyId()const = 0;
 	
+	virtual
+	const realPointField_D& diameter()const = 0;
+
+	virtual 
+	const realPointField_D& mass()const = 0;		
 
 	virtual
 	realx3PointField_D& rAcceleration() = 0;
@@ -260,11 +224,14 @@ public:
 	const realx3PointField_D& rAcceleration() const = 0;
 
 	virtual
-	const realVector_D& boundingSphere()const = 0;
+	const realPointField_D& boundingSphere()const = 0;
 
 	virtual 
 	word shapeTypeName()const = 0;
 
+	virtual
+	const shape& getShapes()const = 0;
+
 	virtual
 	void boundingSphereMinMax(real & minDiam, real& maxDiam)const = 0;
 
diff --git a/src/Particles/particles/regularParticleHandler.cpp b/src/Particles/particles/regularParticleHandler.cpp
new file mode 100644
index 00000000..429ac0b2
--- /dev/null
+++ b/src/Particles/particles/regularParticleHandler.cpp
@@ -0,0 +1,50 @@
+#include "regularParticleHandler.hpp"
+
+
+
+pFlow::regularParticleHandler::regularParticleHandler
+(
+    uint32PointField_D & id
+)
+:
+    particleIdHandler(id)
+{
+}
+
+pFlow::Pair<pFlow::uint32, pFlow::uint32> 
+    pFlow::regularParticleHandler::getIdRange(uint32 nNewParticles)
+{
+    uint32 startId;
+    if(maxId_==-1)
+    {
+        startId = 0;
+    }
+    else
+    {
+        startId = maxId_+1;
+    }
+    uint32 endId = startId+nNewParticles-1;
+    maxId_ = endId;
+    return {startId, endId};
+}
+
+bool pFlow::regularParticleHandler::initialIdCheck()
+{
+    /// empty point structure / no particles in simulation
+    if( id().pStruct().empty() ) return true;
+
+    uint32 maxId = max(id());
+    
+    /// particles should get ids from 0 to size-1
+    if(maxId == -1)
+    {
+        fillSequence(id(),0u);
+        maxId_ = id().size()-1;
+    }
+    else
+    {
+        maxId_ = maxId;
+    }
+
+    return true;
+}
diff --git a/src/Particles/particles/regularParticleHandler.hpp b/src/Particles/particles/regularParticleHandler.hpp
new file mode 100644
index 00000000..9c4ee1dd
--- /dev/null
+++ b/src/Particles/particles/regularParticleHandler.hpp
@@ -0,0 +1,60 @@
+/*------------------------------- 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 __regularParticleHandler_hpp__
+#define __regularParticleHandler_hpp__
+
+#include "particleIdHandler.hpp"
+
+namespace pFlow
+{
+
+class regularParticleHandler
+:
+    public particleIdHandler
+{
+private:
+    
+    uint32 maxId_ = -1;
+
+public:
+
+    TypeInfo("particleIdHandler<regular>");
+
+    explicit regularParticleHandler(uint32PointField_D & id);
+
+    ~regularParticleHandler()override = default;
+
+	add_vCtor
+	(
+		particleIdHandler,
+		regularParticleHandler,
+		pointField
+	);
+
+    Pair<uint32, uint32> getIdRange(uint32 nNewParticles)override;
+
+	bool initialIdCheck()override;
+
+};
+
+}
+
+
+#endif //__regularParticleHandler_hpp__
\ No newline at end of file
diff --git a/src/Particles/particles/shape.cpp b/src/Particles/particles/shape.cpp
new file mode 100644
index 00000000..bcf66e74
--- /dev/null
+++ b/src/Particles/particles/shape.cpp
@@ -0,0 +1,77 @@
+#include "shape.hpp"
+
+
+bool pFlow::shape::findPropertyIds()
+{	
+	shapePropertyIds_.resize(numShapes());
+
+	ForAll( i, materialNames_)
+	{	
+		if(uint32 propId; property_.nameToIndex(materialNames_[i], propId) )
+		{
+			shapePropertyIds_[i] = propId;
+		}
+		else
+		{
+			fatalErrorInFunction<<"Material name "<< materialNames_[i]<< 
+			" is not valid in dictionary "<<globalName()<<endl;
+			return false;
+		}
+	}
+    return true;
+}
+
+bool pFlow::shape::readFromDictionary2()
+{
+
+	materialNames_ = getVal<wordVector>("materials");
+
+	if(materialNames_.size() != numShapes() )
+	{
+		fatalErrorInFunction<<
+		"  number of elements in materials and names are not the same in "<< globalName()<<endl;
+		return false;
+	}
+
+	return true;
+}
+
+
+pFlow::shape::shape
+(
+    const word &fileName, 
+    repository *owner, 
+    const property &prop
+)
+:
+   baseShapeNames(fileName,owner),
+    property_(prop)
+{
+	
+	if( !readFromDictionary2() )
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+
+	if(!findPropertyIds())
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+
+}
+
+bool pFlow::shape::writeToDict(dictionary &dict)const
+{
+	if(!baseShapeNames::writeToDict(dict))return false;
+
+	if( !dict.add("materials", materialNames_) )
+	{
+		fatalErrorInFunction<<
+		"  Error in writing materials to dictionary "<< dict.globalName()<<endl;
+		return false;
+	}
+
+	return true;
+}
\ No newline at end of file
diff --git a/src/Particles/particles/shape.hpp b/src/Particles/particles/shape.hpp
new file mode 100644
index 00000000..1ce5d8ce
--- /dev/null
+++ b/src/Particles/particles/shape.hpp
@@ -0,0 +1,183 @@
+/*------------------------------- 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 __shape_hpp__
+#define __shape_hpp__
+
+#include "baseShapeNames.hpp"
+#include "property.hpp"
+
+namespace pFlow
+{
+
+
+class shape
+:
+	public baseShapeNames
+{
+private:
+
+	/// property of materials 
+  	const property& 	property_; 
+
+	/// list of property ids of shapes (index)
+	uint32Vector			shapePropertyIds_;
+
+	/// list of material names 
+	wordVector 			materialNames_;
+		
+	
+	bool findPropertyIds();
+
+	bool readFromDictionary2();	
+
+protected:
+
+	
+	bool writeToDict(dictionary& dict)const override;
+
+public:
+    
+    TypeInfo("shape");
+
+	shape(
+		const word& fileName,
+		repository* owner,
+		const property& prop);
+
+    ~shape() override=default;
+
+	inline 
+	const auto& properties()const
+	{
+		return property_;
+	}
+
+    
+	inline
+    const wordVector& materialNames()const
+	{
+		return materialNames_;
+	}
+
+	inline
+	const auto& shapePropertyIds()const
+	{
+		return shapePropertyIds_;
+	}
+
+    
+	
+    inline
+    bool shapeNameToPropId(const word& name, int8& propId)const
+	{	
+		if(uint32 index; shapeNameToIndex(name, index))
+		{
+			propId = shapePropertyIds_[index];
+			return true;
+		}
+		return false;
+	}
+
+	inline
+    bool propIdValid(uint32 propId)const
+	{
+		return static_cast<uint32>(propId) < property_.numMaterials();
+	}
+
+
+	inline
+    bool indexToDensity(uint32 index, real& rho)const
+	{
+		if(indexValid(index))
+			return property_.density(shapePropertyIds_[index], rho);
+		return false;
+	}
+
+    inline
+    real indexToDensity(uint32 index)const
+	{
+		if(indexValid(index))
+		{
+			return property_.density(shapePropertyIds_[index]);
+		}
+		
+		fatalExit;
+		return 0.0;
+	}
+
+	virtual 
+    real maxBoundingSphere()const = 0;
+
+    virtual 
+    real minBoundingSphere()const = 0;
+
+    virtual 
+    bool boundingDiameter(uint32 index, real& bDiam)const =0;
+
+    virtual
+    real boundingDiameter(uint32 index)const = 0;
+
+	virtual
+	realVector boundingDiameter()const = 0;
+
+    virtual 
+    bool mass(uint32 index, real& m)const = 0;
+
+    virtual 
+    real mass(uint32 index) const =0;
+
+	virtual
+	realVector mass()const =0;
+
+	virtual
+	realVector density()const =0;
+
+    virtual 
+    bool Inertia(uint32 index, real& I)const = 0;
+
+    virtual
+    real Inertia(uint32 index)const = 0;
+
+	virtual 
+	realVector Inertia()const=0;
+
+    virtual 
+    bool Inertia_xx(uint32 index, real& Ixx)const = 0;
+
+    virtual
+    real Inertial_xx(uint32 index)const =0;
+	
+    virtual 
+    bool Inertia_yy(uint32 index, real& Iyy)const = 0;
+
+    virtual 
+    real Inertial_yy(uint32 index)const = 0;
+
+    virtual 
+    bool Inertia_zz(uint32 index, real& Izz)const = 0;
+
+    virtual 
+    real Inertial_zz(uint32 index)const = 0;
+
+};
+
+}
+
+#endif //__shape_hpp__
\ No newline at end of file
diff --git a/src/Property/property.cpp b/src/Property/property.cpp
index b2745e10..d6af1f47 100644
--- a/src/Property/property.cpp
+++ b/src/Property/property.cpp
@@ -18,55 +18,42 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
 #include "property.hpp"
 #include "dictionary.hpp"
 
-bool pFlow::property::readDictionary
-(
-	const dictionary& dict
-)
+bool pFlow::property::readDictionary()
 {
 	
-	materials_ = dict.getVal<wordVector>("materials");
+	materials_ = getVal<wordVector>("materials");
 	
-	densities_ = dict.getVal<realVector>("densities");
+	densities_ = getVal<realVector>("densities");
 
 	if(materials_.size() != densities_.size() )
 	{
 		fatalErrorInFunction<<
 		"  number of elements in material ("<<materials_.size()<<
 		") is not equal to number of elements in densities ("<<densities_.size()<<
-		") in dictionary "<< dict.globalName()<<endl;
+		") in dictionary "<< globalName()<<endl;
 		return false;
 	}
 
-	if(!makeNameIndex())
-	{
-		fatalErrorInFunction<<
-		"  error in dictionary "<< dict.globalName()<<endl;
-		return false;
-	}
 	return true;
 }
 
-bool pFlow::property::writeDictionary
-(
-	dictionary& dict
-)const
+bool pFlow::property::writeDictionary()
 {
 
-	if(!dict.add("materials", materials_))
+	if(!add("materials", materials_))
 	{
 		fatalErrorInFunction<<
-		"  error in writing materials to dictionary "<< dict.globalName()<<endl;
+		"  error in writing materials to dictionary "<< globalName()<<endl;
 		return false;
 	}
 
-	if(!dict.add("densities", densities_))
+	if(!add("densities", densities_))
 	{
 		fatalErrorInFunction<<
-		"  error in writing densities to dictionary "<< dict.globalName()<<endl;
+		"  error in writing densities to dictionary "<< globalName()<<endl;
 		return false;
 	}
 
@@ -77,79 +64,120 @@ bool pFlow::property::makeNameIndex()
 {
 	nameIndex_.clear();
 
+
 	uint32 i=0;
-	for(auto& nm:materials_)
+	for(auto const& nm:materials_)
 	{
-		if(!nameIndex_.insertIf(nm, i++))
+		if(!nameIndex_.insertIf(nm, i))
 		{
 			fatalErrorInFunction<<
 			"  repeated material name in the list of materials: " << materials_;
 			return false;
 		}
+		i++;
 	}
 	nameIndex_.rehash(0);
-	numMaterials_ = materials_.size();
+	numMaterials_ = static_cast<uint32>(materials_.size());
 	return true;
 }
 
 
 pFlow::property::property
 (
+	const word& fileName, 
 	const wordVector& materials,
-	const realVector& densities
+	const realVector& densities,
+	repository* owner
 )
 :
+	fileDictionary
+	(
+		objectFile
+		(
+			fileName,
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_NEVER
+		),
+		owner
+	),
 	materials_(materials),
 	densities_(densities)
 {
+	
+	if(!writeDictionary())
+	{
+		fatalExit;
+	}
+
 	if(!makeNameIndex())
 	{
 		fatalErrorInFunction<<
-		"  error in the input parameters of constructor. \n";
+		"error in the input parameters of constructor. \n";
 		fatalExit;
 	}
 }
 
 pFlow::property::property
 (
-const fileSystem& file
+	const word& fileName,
+	repository* owner
 )
 :
-	dict_
+	fileDictionary
 	(
-		makeUnique<dictionary>
-		("property", true)
-	)
-{
-	iFstream dictStream(file);
-
-	if(!dict_().read(dictStream))
-	{
-		ioErrorInFile(dictStream.name(), dictStream.lineNumber());
-		fatalExit;
-	}
-
-	if(!readDictionary(dict_()))
-	{
-		fatalExit;
-	}
-
-}
-
-pFlow::property::property
-(
-	const dictionary& dict
-)
-:
-	dict_
-	(
-		makeUnique<dictionary>(dict)
+		objectFile
+		(
+			fileName,
+			"",
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_NEVER
+		),
+		owner
 	)
 {
 	
-	if(!readDictionary(dict_()))
+	if(!readDictionary())
 	{
 		fatalExit;
 	}
+
+	if(!makeNameIndex())
+	{
+		fatalErrorInFunction<<
+		"error in dictionary "<< globalName()<<endl;
+		fatalExit;
+	}
+
 }
 
+pFlow::property::property
+(
+	const word &fileName, 
+	const fileSystem &dir
+)
+:
+	fileDictionary
+	(
+		objectFile
+		(
+			fileName,
+			dir,
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_NEVER
+		),
+		nullptr
+	)
+{
+	if(!readDictionary())
+	{
+		fatalExit;
+	}
+
+	if(!makeNameIndex())
+	{
+		fatalErrorInFunction<<
+		"error in dictionary "<< globalName()<<endl;
+		fatalExit;
+	}
+}
diff --git a/src/Property/property.hpp b/src/Property/property.hpp
index e7633e8e..e7539b04 100644
--- a/src/Property/property.hpp
+++ b/src/Property/property.hpp
@@ -22,15 +22,12 @@ Licence:
 
 #include "Vectors.hpp"
 #include "hashMap.hpp"
-#include "fileSystem.hpp"
+#include "fileDictionary.hpp"
 #include "iFstream.hpp"
 
 namespace pFlow
 {
 
-// forward 
-class dictionary;
-
 /** 
  * property holds the pure properties of materials.
  * 
@@ -38,14 +35,13 @@ class dictionary;
  * used in the simulation: for walls and particles.  
  */
 class property
+:
+	public fileDictionary
 {
-protected:
+private:
 
 	// - protected data members
 
-		/// pointer to the dictionary, if it is constructed from a file/dictionary
-		uniquePtr<dictionary> dict_ = nullptr;
-
 		/// list of name of materials
 		wordVector 		materials_;
 
@@ -55,6 +51,7 @@ protected:
 		/// rapid mapping from name to index
 		wordHashMap<uint32>		nameIndex_;
 
+
 		/// number of materials
 		uint32 			numMaterials_ = 0;
 
@@ -62,10 +59,10 @@ protected:
 	// - protected member functions
 
 		/// read from dict
-		bool readDictionary(const dictionary& dict);
+		bool readDictionary();
 
 		/// write to dict
-		bool writeDictionary(dictionary& dict)const;
+		bool writeDictionary();
 
 		/// creates a mapp
 		bool makeNameIndex();
@@ -73,22 +70,24 @@ protected:
 public:
 
 	/// Type info
-	TypeInfoNV("property");
+	TypeInfo("property");
 
-	
 	// - Constructors 
 
-		/// Emptry constructor, used for reading from a file 
-		property(){}
+		explicit 
+		property(
+			const word& fileName, 
+			repository* owner=nullptr);
 
-		/// Constructe from materials and densities 
-		property(const wordVector& materials, const realVector& densities);
-
-		/// Construct from file
-		property(const fileSystem& file);	
-
-		/// Construct from dictionary dict
-		property(const dictionary& dict);
+		property(
+			const word& fileName,
+			const fileSystem& dir
+		);
+		
+		property(const word& fileName, 
+				const wordVector& materials,
+				const realVector& densities,
+				repository* owner=nullptr);
 
 		/// Default copy
 		property(const property& ) = default;
@@ -103,17 +102,11 @@ public:
 		property& operator= (property&&) = default;
 
 		/// Default destructor 
-		~property() = default;
+		~property() override = default;
 
 	
 	// - Methods 
 
-		/// Return dictionary
-		inline const auto& dict()const
-		{
-			return dict_();
-		}
-
 		/// Return number of materials 
 		inline auto numMaterials()const
 		{
@@ -189,21 +182,9 @@ public:
 				return false;
 			}	
 		}
+
+		
 		
-	//// - IO operatoins
-
-		/// Read from dictionary 
-		bool read(const dictionary& dict)
-		{
-			return readDictionary(dict);
-		}
-
-		/// Write to dictionary 
-		bool write(dictionary& dict)const
-		{
-			return writeDictionary(dict);
-		}
-
 };
 
 }
diff --git a/src/phasicFlow/CMakeLists-old.txt b/src/phasicFlow/CMakeLists-old.txt
new file mode 100644
index 00000000..b6b68815
--- /dev/null
+++ b/src/phasicFlow/CMakeLists-old.txt
@@ -0,0 +1,87 @@
+
+list(APPEND SourceFiles 
+types/basicTypes/bTypesFunctions.cpp
+types/basicTypes/Logical.cpp
+types/types.cpp
+
+globals/error.cpp
+
+streams/token/tokenIO.cpp
+streams/token/token.cpp
+streams/iStream/IOstream.cpp
+streams/iStream/iIstream.cpp
+streams/iStream/iOstream.cpp
+streams/Stream/Istream.cpp
+streams/Stream/Ostream.cpp
+streams/Fstream/iFstream.cpp
+streams/Fstream/oFstream.cpp
+streams/Fstream/fileStream.cpp 
+streams/TStream/iTstream.cpp
+streams/TStream/oTstream.cpp
+streams/streams.cpp 
+
+dictionary/dictionary.cpp
+dictionary/entry/iEntry.cpp
+dictionary/entry/dataEntry.cpp 
+dictionary/twoPartEntry/twoPartEntry.cpp
+
+fileSystem/fileSystem.cpp
+
+commandLine/commandLine.cpp
+
+random/randomReal/randomReal.cpp
+random/randomReal/randomReals.cpp
+
+Timer/Timer.cpp
+Timer/Timers.cpp
+
+repository/Time/Time.cpp
+repository/Time/timeControl.cpp
+repository/systemControl/systemControl.cpp
+repository/systemControl/dynamicLinkLibs.cpp
+repository/repository/repository.cpp
+repository/IOobject/objectFile.cpp
+repository/IOobject/IOobject.cpp
+repository/IOobject/IOfileHeader.cpp
+
+structuredData/box/box.cpp
+structuredData/cells/cells.cpp
+structuredData/cylinder/cylinder.cpp
+structuredData/sphere/sphere.cpp
+structuredData/iBox/iBoxs.cpp
+structuredData/line/line.cpp
+structuredData/zAxis/zAxis.cpp
+structuredData/pointStructure/pointStructure.cpp
+structuredData/pointStructure/mortonIndexing.cpp
+structuredData/pointStructure/selectors/pStructSelector/pStructSelector.cpp
+structuredData/pointStructure/selectors/selectBox/selectBox.cpp
+structuredData/pointStructure/selectors/selectRange/selectRange.cpp 
+structuredData/pointStructure/selectors/selectRandom/selectRandom.cpp
+structuredData/trisurfaceStructure/triSurface.cpp
+structuredData/trisurfaceStructure/multiTriSurface.cpp
+structuredData/trisurfaceStructure/stlFile.cpp
+structuredData/peakableRegion/sphereRegion/sphereRegion.cpp
+structuredData/peakableRegion/cylinderRegion/cylinderRegion.cpp
+structuredData/peakableRegion/boxRegion/boxRegion.cpp
+structuredData/peakableRegion/peakableRegion/peakableRegion.cpp
+structuredData/peakableRegion/peakableRegions.cpp
+
+containers/Vector/Vectors.cpp
+containers/Field/Fields.cpp
+containers/symArrayHD/symArrays.cpp
+containers/triSurfaceField/triSurfaceFields.cpp
+containers/bitsetHD/bitsetHDs.cpp
+containers/indexContainer/indexContainer.cpp
+
+setFieldList/setFieldList.cpp
+setFieldList/setFieldEntry.cpp
+
+eventSubscriber/eventSubscriber.cpp
+eventSubscriber/eventObserver.cpp)
+
+set(link_libs Kokkos::kokkos tbb)
+
+pFlow_add_library_install(phasicFlow SourceFiles link_libs)
+
+target_include_directories(phasicFlow PUBLIC ./Kokkos ./algorithms ./globals)
+
diff --git a/src/phasicFlow/CMakeLists.txt b/src/phasicFlow/CMakeLists.txt
index b6b68815..67ade22e 100644
--- a/src/phasicFlow/CMakeLists.txt
+++ b/src/phasicFlow/CMakeLists.txt
@@ -6,82 +6,142 @@ types/types.cpp
 
 globals/error.cpp
 
+processors/processors.cpp
+processors/localProcessors.cpp
+processors/pFlowProcessors.cpp
+
 streams/token/tokenIO.cpp
 streams/token/token.cpp
 streams/iStream/IOstream.cpp
-streams/iStream/iIstream.cpp
 streams/iStream/iOstream.cpp
-streams/Stream/Istream.cpp
+streams/iStream/iIstream.cpp
 streams/Stream/Ostream.cpp
-streams/Fstream/iFstream.cpp
-streams/Fstream/oFstream.cpp
-streams/Fstream/fileStream.cpp 
+streams/Stream/Istream.cpp
+streams/processorOstream/processorOstream.cpp
+streams/masterOstream/masterOstream.cpp
 streams/TStream/iTstream.cpp
 streams/TStream/oTstream.cpp
+streams/Fstream/iFstream.cpp
+streams/Fstream/oFstream.cpp
+streams/Fstream/fileStream.cpp
 streams/streams.cpp 
 
+fileSystem/fileSystem.cpp
+
 dictionary/dictionary.cpp
+dictionary/fileDictionary.cpp
 dictionary/entry/iEntry.cpp
 dictionary/entry/dataEntry.cpp 
 dictionary/twoPartEntry/twoPartEntry.cpp
 
-fileSystem/fileSystem.cpp
+repository/IOobject/objectFile.cpp
+repository/IOobject/IOfileHeader.cpp
+repository/IOobject/IOobject.cpp
+repository/IOobject/IOPattern.cpp
+repository/repository/repository.cpp
+repository/Time/Time.cpp
+repository/Time/timeControl.cpp
+repository/Time/baseTimeControl.cpp
+repository/systemControl/systemControl.cpp
+repository/systemControl/dynamicLinkLibs.cpp
 
 commandLine/commandLine.cpp
 
-random/randomReal/randomReal.cpp
-random/randomReal/randomReals.cpp
+eventManagement/subscriber.cpp
+eventManagement/observer.cpp
+
+demComponent/demComponent.cpp
 
 Timer/Timer.cpp
 Timer/Timers.cpp
 
-repository/Time/Time.cpp
-repository/Time/timeControl.cpp
-repository/systemControl/systemControl.cpp
-repository/systemControl/dynamicLinkLibs.cpp
-repository/repository/repository.cpp
-repository/IOobject/objectFile.cpp
-repository/IOobject/IOobject.cpp
-repository/IOobject/IOfileHeader.cpp
 
-structuredData/box/box.cpp
-structuredData/cells/cells.cpp
-structuredData/cylinder/cylinder.cpp
-structuredData/sphere/sphere.cpp
-structuredData/iBox/iBoxs.cpp
-structuredData/line/line.cpp
+containers/Vector/Vectors.cpp
+containers/VectorHD/VectorSingles.cpp
+containers/Field/Fields.cpp
+containers/symArrayHD/symArrays.cpp
+containers/List/anyList/anyList.cpp
+
+structuredData/pointStructure/internalPointsKernels.cpp
+structuredData/pointStructure/internalPoints.cpp
+
 structuredData/zAxis/zAxis.cpp
+structuredData/box/box.cpp
+structuredData/line/line.cpp
+structuredData/infinitePlane/infinitePlane.cpp
+structuredData/plane/plane.cpp
+structuredData/domain/domain.cpp
+structuredData/domain/simulationDomain.cpp
+structuredData/domain/regularSimulationDomain.cpp
+structuredData/boundaries/boundaryBase/boundaryBase.cpp
+structuredData/boundaries/boundaryBase/boundaryBaseKernels.cpp
+structuredData/boundaries/boundaryExit/boundaryExit.cpp
+structuredData/boundaries/boundaryNone/boundaryNone.cpp
+structuredData/boundaries/boundaryPeriodic/boundaryPeriodic.cpp
+structuredData/boundaries/boundaryList.cpp
 structuredData/pointStructure/pointStructure.cpp
-structuredData/pointStructure/mortonIndexing.cpp
 structuredData/pointStructure/selectors/pStructSelector/pStructSelector.cpp
 structuredData/pointStructure/selectors/selectBox/selectBox.cpp
 structuredData/pointStructure/selectors/selectRange/selectRange.cpp 
 structuredData/pointStructure/selectors/selectRandom/selectRandom.cpp
-structuredData/trisurfaceStructure/triSurface.cpp
-structuredData/trisurfaceStructure/multiTriSurface.cpp
-structuredData/trisurfaceStructure/stlFile.cpp
-structuredData/peakableRegion/sphereRegion/sphereRegion.cpp
-structuredData/peakableRegion/cylinderRegion/cylinderRegion.cpp
-structuredData/peakableRegion/boxRegion/boxRegion.cpp
-structuredData/peakableRegion/peakableRegion/peakableRegion.cpp
-structuredData/peakableRegion/peakableRegions.cpp
 
-containers/Vector/Vectors.cpp
-containers/Field/Fields.cpp
-containers/symArrayHD/symArrays.cpp
+triSurface/subSurface.cpp
+triSurface/triSurface.cpp
+triSurface/multiTriSurface.cpp
+
+containers/pointField/pointFields.cpp
 containers/triSurfaceField/triSurfaceFields.cpp
-containers/bitsetHD/bitsetHDs.cpp
-containers/indexContainer/indexContainer.cpp
 
 setFieldList/setFieldList.cpp
 setFieldList/setFieldEntry.cpp
 
-eventSubscriber/eventSubscriber.cpp
-eventSubscriber/eventObserver.cpp)
 
+
+
+)
+
+set(link_libs)
 set(link_libs Kokkos::kokkos tbb)
+	
 
-pFlow_add_library_install(phasicFlow SourceFiles link_libs)
 
-target_include_directories(phasicFlow PUBLIC ./Kokkos ./algorithms ./globals)
+if(pFlow_Build_MPI)
+
+	set(Zoltan_Install_DIR)
+	if(DEFINED ENV{Zoltan_DIR})
+	   set(Zoltan_Install_DIR $ENV{Zoltan_DIR})
+	else()
+	  set(Zoltan_Install_DIR $ENV{HOME}/PhasicFlow/Zoltan)
+	endif()
+	message(STATUS "Zoltan install directory is ${Zoltan_Install_DIR}")
+
+	set(ZOLTAN_PREFIX "${Zoltan_Install_DIR}" CACHE STRING "Zoltan install directory")
+
+	find_path(ZOLTAN_INCLUDE_DIR zoltan.h PATHS "${ZOLTAN_PREFIX}/include")
+
+	message(STATUS "Zoltan include path: ${ZOLTAN_INCLUDE_DIR}")
+
+	find_library(ZOLTAN_LIBRARY zoltan PATHS "${ZOLTAN_PREFIX}/lib")
+	message(STATUS "Zoltan lib path: ${ZOLTAN_LIBRARY}")
+	
+	list(APPEND SourceFiles
+	MPIParallelization/partitioning.cpp 
+	MPIParallelization/rcb1DPartitioning.cpp
+	MPIParallelization/domain/MPISimulationDomain.cpp
+    #MPIParallelization/dataIOMPI.cpp
+    MPIParallelization/procCommunication.cpp
+    MPIParallelization/boundaryProcessor.cpp
+    MPIParallelization/scatteredMasterDistributeChar.cpp
+	MPIParallelization/processorBoundaryFields.cpp
+	)
+	
+	list(APPEND link_libs MPI::MPI_CXX ${ZOLTAN_LIBRARY} -lm )
+	pFlow_add_library_install(phasicFlow SourceFiles link_libs)
+	target_include_directories(phasicFlow PUBLIC ./globals ${ZOLTAN_INCLUDE_DIR})
+
+else()
+	pFlow_add_library_install(phasicFlow SourceFiles link_libs)
+	target_include_directories(phasicFlow PUBLIC ./globals)
+endif()
+
 
diff --git a/src/phasicFlow/Kokkos/KokkosTypes.hpp b/src/phasicFlow/Kokkos/KokkosTypes.hpp
index 4f59872f..d58df4cb 100644
--- a/src/phasicFlow/Kokkos/KokkosTypes.hpp
+++ b/src/phasicFlow/Kokkos/KokkosTypes.hpp
@@ -17,133 +17,146 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
 #ifndef __KokkosTypes_hpp__
 #define __KokkosTypes_hpp__
 
+/**
+ *  \file KokkosType.hpp
+ * 
+ * 	\brief name aliases and typedesf for Kokkos entities that are 
+ * frequently used in PhasicFlow.
+ * 
+ */
+
 
 #include <Kokkos_Core.hpp>
 #include <Kokkos_DualView.hpp>
 #include <Kokkos_UnorderedMap.hpp>
 
-#include "iOstream.hpp"
+#include "builtinTypes.hpp"
 
 
 namespace pFlow
 {
 
-class DeviceSide{};
-class HostSide{};
 
-template<typename side>
-struct selectSide{};
+/// Host memory space 
+using HostSpace 	= Kokkos::HostSpace;
 
-using HostSpace 					= Kokkos::HostSpace;
-using Serial 						= Kokkos::Serial;
+/// Serial execution space 
+using Serial 		= Kokkos::Serial;
 
 #ifdef _OPENMP
-using OpenMP 						= Kokkos::OpenMP;
+/// OpenMp execution space 
+using OpenMP 		= Kokkos::OpenMP;
 #endif
 
+#ifdef __CUDACC__
+/// Cuda execution space 
+using Cuda 			= Kokkos::Cuda;
+#endif
+
+/// Default Host execution space, on top of all host execution spaces 
 using DefaultHostExecutionSpace 	= Kokkos::DefaultHostExecutionSpace;
+
+/// Default execution space, it can be device exe. space, if a device space is 
+/// activated. 
 using DefaultExecutionSpace 		= Kokkos::DefaultExecutionSpace;
 
 
+using deviceRPolicyStatic = 
+	Kokkos::RangePolicy<
+			Kokkos::DefaultExecutionSpace,
+			Kokkos::Schedule<Kokkos::Static>,
+			Kokkos::IndexType<pFlow::uint32> >;
 
+
+using hostRPolicyStatic = 
+	Kokkos::RangePolicy<
+			Kokkos::DefaultExecutionSpace,
+			Kokkos::Schedule<Kokkos::Static>,
+			Kokkos::IndexType<pFlow::uint32> >;
+
+
+/// Pair of two variables
 template<typename T1, typename T2>
-	using kPair = Kokkos::pair<T1,T2>;
-
-template<typename T>
-	using kRange = kPair<T,T>;
-
-using range = kRange<int>;
-
-using range64 = kRange<int long>;
+using Pair 	= Kokkos::pair<T1,T2>;
 
+/// View for a scalar
 template<typename T, typename... properties>
 	using ViewTypeScalar = Kokkos::View<T,properties...>;
 
+/// 1D veiw as a vector 
 template<typename T, typename... properties>
 	using ViewType1D = Kokkos::View<T*,properties...>;
 
+/// 2D view as an array
 template<typename T, typename... properties>
-	using DualViewType1D = Kokkos::DualView<T*,properties...>;
+	using ViewType2D = Kokkos::View<T**,properties...>;
 
+/// 3D view as an array
 template<typename T, typename... properties>
 	using ViewType3D = Kokkos::View<T***,properties...>;
 
+/// 1D dual view as a vector 
+template<typename T, typename... properties>
+	using DualViewType1D = Kokkos::DualView<T*,properties...>;
+
+/// unordered map
 template<typename Key, typename Value, typename... properties>
 	using unorderedMap = Kokkos::UnorderedMap<Key, Value, properties...>;
 
+/// unordered set 
 template<typename Key, typename... properties>
 	using unorderedSet = Kokkos::UnorderedMap<Key, void, properties...>;
 
-template<typename Key, typename Value>
-	using deviceHashMap= Kokkos::UnorderedMap<Key, Value>;
-
-template<typename Key, typename Value>
-	using hostHashMap= Kokkos::UnorderedMap<Key, Value, Kokkos::HostSpace>;
-
-template<typename Key>
-	using deviceHashSet= Kokkos::UnorderedMap<Key, void>;
-
-template<typename Key>
-	using hostHashSet  = Kokkos::UnorderedMap<Key,void, Kokkos::HostSpace>;
-
-// a 1D array (vector) with default device (memory space and execution space)
+/// Scalar on device 
 template<typename T>
 	using deviceViewTypeScalar = Kokkos::View<T>;
 
+/// 1D array (vector) with default device (memory space and execution space)
 template<typename T>
 	using deviceViewType1D = Kokkos::View<T*>;
 
+/// 2D view on device as an array on device 
 template<typename T, typename Layout=void>
 	using deviceViewType2D = Kokkos::View<T**,Layout, void>;
 
+/// 3D view on device as an array on device 
+template<typename T, typename Layout=void>
+	using deviceViewType3D = Kokkos::View<T***,Layout, void>;
+
+
 
-// a 1D array (vector with host memeory space)
 template<typename T>
 	using hostViewTypeScalar = Kokkos::View<T, Kokkos::HostSpace>;
 
+/// 1D array (vector with host memeory space)
 template<typename T>
 	using hostViewType1D = Kokkos::View<T*, Kokkos::HostSpace>;
 
+/// 2D array on host 
 template<typename T, typename Layout=void>
 	using hostViewType2D = Kokkos::View<T**,Layout, Kokkos::HostSpace>;
 
-
-#ifdef __CUDACC__
-using Cuda 							= Kokkos::Cuda;
-template<typename T>
-	using cudaViewTypeScalar = Kokkos::View<T, Kokkos::CudaSpace>;
-
-template<typename T>
-	using cudaViewType1D = Kokkos::View<T*, Kokkos::CudaSpace>;
-
+/// 3D array on host
 template<typename T, typename Layout=void>
-	using cudaViewType2D = Kokkos::View<T*,Layout, Kokkos::CudaSpace>;
-#endif
-
+	using hostViewType3D = Kokkos::View<T***,Layout, Kokkos::HostSpace>;
 
+/// 1D vector on device with atomic capabilities
 template<typename T>
 using deviceAtomicViewType1D = 
     Kokkos::View<
 		T*,
 		Kokkos::MemoryTraits<std::is_same<DefaultExecutionSpace,Serial>::value?0:Kokkos::Atomic>>;
 
+/// 3D array on device with atomic capabilities
 template<typename T>
 using deviceAtomicViewType3D =
 	Kokkos::View<
 	T***,
 	Kokkos::MemoryTraits<std::is_same<DefaultExecutionSpace,Serial>::value?0:Kokkos::Atomic>>;
 
-template<typename T>
-iOstream& operator <<(iOstream& os, const kRange<T>& rng)
-{
-	os<<"["<<rng.first<<" "<<rng.second<<")";
-	return os;
-}
-
 
 } // pFlow
 
diff --git a/src/phasicFlow/Kokkos/KokkosUtilities.hpp b/src/phasicFlow/Kokkos/KokkosUtilities.hpp
index 34e6aa2f..6d1c7f46 100644
--- a/src/phasicFlow/Kokkos/KokkosUtilities.hpp
+++ b/src/phasicFlow/Kokkos/KokkosUtilities.hpp
@@ -25,7 +25,9 @@ Licence:
 #include "KokkosTypes.hpp"
 #include "pFlowMacros.hpp"
 #include "types.hpp"
-
+#include "span.hpp"
+#include "dataIO.hpp"
+#include "iOstream.hpp"
 
 namespace pFlow
 {
@@ -37,6 +39,14 @@ bool constexpr isHostAccessible()
 	return Kokkos::SpaceAccessibility<ExecutionSpace,HostSpace>::accessible;
 }
 
+template<typename ExecutionSpace>
+INLINE_FUNCTION_H
+bool constexpr isDeviceAccessible()
+{
+	return Kokkos::SpaceAccessibility<ExecutionSpace,DefaultExecutionSpace::memory_space>::accessible;
+}
+
+/// Is MemoerySpace accessible from ExecutionSpace
 template<typename ExecutionSpace, typename MemoerySpace>
 INLINE_FUNCTION_H
 bool constexpr areAccessible()
@@ -48,43 +58,63 @@ template <
 	typename Type,
 	typename... Properties>
 INLINE_FUNCTION_H
-void realloc( ViewType1D<Type,Properties...>& view, int32 len)
+void reallocInit( ViewType1D<Type,Properties...>& view, uint32 len)
 {
-	Kokkos::realloc(view, len);
+	Kokkos::realloc(Kokkos::WithoutInitializing, view, len);	
 }
 
 template <
 	typename Type,
 	typename... Properties>
 INLINE_FUNCTION_H
-void reallocNoInit(ViewType1D<Type,Properties...>& view, int32 len)
+void reallocNoInit(ViewType1D<Type,Properties...>& view, uint32 len)
 {
-	using ViewType = ViewType1D<Type,Properties...>;
-	word vl = view.label();
-	view = ViewType();  // Deallocate first
-  	view = ViewType( 
-  		Kokkos::view_alloc(
-  			Kokkos::WithoutInitializing,
-  			vl), 
-  		len);
+	Kokkos::realloc(Kokkos::WithoutInitializing, view, len);
 }
 
 template <
 	typename Type,
 	typename... Properties>
 INLINE_FUNCTION_H
-void reallocFill( ViewType1D<Type,Properties...>& view, int32 len, Type val)
+void reallocFill( ViewType1D<Type,Properties...>& view, uint32 len, Type val)
 {
 	reallocNoInit(view, len);
 	Kokkos::deep_copy(view, val);
 }
 
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void reallocInit( ViewType2D<Type,Properties...>& view, uint32 len1, uint32 len2)
+{
+	Kokkos::realloc(view, len1, len2);
+}
 
 template <
 	typename Type,
 	typename... Properties>
 INLINE_FUNCTION_H
-void realloc( ViewType3D<Type,Properties...>& view, int32 len1, int32 len2, int32 len3)
+void reallocNoInit(ViewType2D<Type,Properties...>& view, uint32 len1, uint32 len2)
+{	
+  	Kokkos::realloc(Kokkos::WithoutInitializing, view, len1, len2);
+}
+
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void reallocFill( ViewType2D<Type,Properties...>& view, uint32 len1, uint32 len2, Type val)
+{
+	reallocNoInit(view, len1, len2);
+	Kokkos::deep_copy(view, val);
+}
+
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void reallocInit( ViewType3D<Type,Properties...>& view, uint32 len1, uint32 len2, uint32 len3)
 {
 	Kokkos::realloc(view, len1, len2, len3);
 }
@@ -93,38 +123,107 @@ template <
 	typename Type,
 	typename... Properties>
 INLINE_FUNCTION_H
-void reallocNoInit(ViewType3D<Type,Properties...>& view, int32 len1, int32 len2, int32 len3)
+void reallocNoInit(ViewType3D<Type,Properties...>& view, uint32 len1, uint32 len2, uint32 len3)
 {
-	using ViewType = ViewType3D<Type,Properties...>;
-	word vl = view.label();
-	view = ViewType();  // Deallocate first
-  	view = ViewType( 
-  		Kokkos::view_alloc(
-  			Kokkos::WithoutInitializing,
-  			vl), 
-  		len1, len2, len3);
+	
+  	Kokkos::realloc(Kokkos::WithoutInitializing, view, len1, len2, len3);
 }
 
 template <
 	typename Type,
 	typename... Properties>
 INLINE_FUNCTION_H
-void reallocFill( ViewType3D<Type,Properties...>& view, int32 len1, int32 len2, int32 len3, Type val)
+void reallocFill( ViewType3D<Type,Properties...>& view, uint32 len1, uint32 len2, uint32 len3, Type val)
 {
 	reallocNoInit(view, len1, len2, len3);
 	Kokkos::deep_copy(view, val);
 }
 
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void resizeInit(ViewType1D<Type,Properties...>& view, uint32 newLen)
+{
+	Kokkos::resize(view, newLen);
+}
+
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void resizeNoInit(ViewType1D<Type,Properties...>& view, uint32 newLen)
+{
+	Kokkos::resize(Kokkos::WithoutInitializing, view, newLen);
+}
 
 template<typename ViewType>
 INLINE_FUNCTION_H
 void swapViews(ViewType& v1, ViewType &v2)
 {
-	auto tmp = v1;
-	v1 = v2;
-	v2 = tmp;
+	static_assert(
+      std::is_move_assignable<ViewType>::value && std::is_move_constructible<ViewType>::value,
+      "swapViews arguments must be move assignable and move constructible");
+
+	ViewType tmp = std::move(v1);
+  	v1     = std::move(v2);
+  	v2     = std::move(tmp);
 }
 
+
+template<typename T1, typename T2>
+INLINE_FUNCTION_H
+iOstream& operator <<(iOstream& os, const Pair<T1,T2>& p)
+{
+	os<<'('<<p.first<<" "<<p.second<<')';
+	return os;
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+span<T> makeSpan(ViewType1D<T, properties...> & v)
+{
+	return span<T>(v.data(), v.size());
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+span<T> makeSpan(ViewType1D<T, properties...> & v, uint32 size)
+{
+	return span<T>(v.data(), size);
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+span<T> makeSpan(const ViewType1D<T, properties...> & v)
+{
+	return span<T>(const_cast<T*>(v.data()), v.size());
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+span<T> makeSpan(const ViewType1D<T, properties...> & v, uint32 size)
+{
+	return span<T>(const_cast<T*>(v.data()), size);
+}
+
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+iOstream& operator <<(iOstream& os, const ViewType1D<T, properties...> & v)
+{
+	
+	using ExSpace = typename ViewType1D<T, properties...>::execution_space;
+
+	static_assert(isHostAccessible<ExSpace>(), "View memory is not accessible from Host");
+
+	span<T> spn(v.data(), v.size());
+	os<<spn;
+	
+	return os;
+}
+
+
 } // pFlow
 
 #endif  //__KokkosUtilities_hpp__
diff --git a/src/phasicFlow/Kokkos/Range.hpp b/src/phasicFlow/Kokkos/Range.hpp
new file mode 100644
index 00000000..a47e451c
--- /dev/null
+++ b/src/phasicFlow/Kokkos/Range.hpp
@@ -0,0 +1,159 @@
+/*------------------------------- 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 __Range_hpp__
+#define __Range_hpp__
+
+
+
+
+#include <Kokkos_Core.hpp>
+
+#include "pFlowMacros.hpp"
+#include "typeInfo.hpp"
+#include "builtinTypes.hpp"
+#include "iOstream.hpp"
+
+
+namespace pFlow
+{
+
+
+/**
+ * Range for elements in an vector [start,end)
+ *  
+ */
+template<typename T>
+struct Range
+:
+public Kokkos::pair<T,T>
+{
+	using Pair = Kokkos::pair<T,T>;
+
+	TypeInfoTemplateNV11("Range", T)
+
+	//// - Constructors
+
+		/// Default
+		INLINE_FUNCTION_HD
+		Range(){}
+
+		/// From end, set start to 0
+		INLINE_FUNCTION_HD
+		Range(const T& e)
+		:
+			Range(0,e)
+		{}
+		
+		/// From componeents
+		INLINE_FUNCTION_HD
+		Range(const T& s, const T& e)
+		:
+			Range::Pair(s,e)
+		{}
+
+		/// From pair
+		INLINE_FUNCTION_HD
+		Range(const Range::Pair &src )
+		:
+			Range::Pair(src)
+		{}
+
+		/// Copy
+		INLINE_FUNCTION_HD
+		Range(const Range&) = default;
+
+		/// Move
+		INLINE_FUNCTION_HD
+		Range(Range&&) = default;
+
+		/// Copy assignment
+		INLINE_FUNCTION_HD
+		Range& operator=(const Range&) = default;
+
+		/// Move assignment
+		INLINE_FUNCTION_HD
+		Range& operator=(Range&&) = default;
+
+		/// Destructor
+		INLINE_FUNCTION_HD
+		~Range()=default;
+
+	//// - Methods
+
+		/// Start
+		INLINE_FUNCTION_HD
+		T& start()
+		{
+			return this->first;
+		}
+
+		/// End
+		INLINE_FUNCTION_HD
+		T& end()
+		{
+			return this->second;
+		}
+
+		INLINE_FUNCTION_HD
+		const T& start()const
+		{
+			return this->first;
+		}
+
+		INLINE_FUNCTION_HD
+		const T& end()const
+		{
+			return this->second;
+		}
+
+		INLINE_FUNCTION_HD
+		T numElements()
+		{
+			return end()-start();
+		}
+
+		INLINE_FUNCTION_HD
+		auto getPair()const
+		{
+			return Pair(this->first, this->second);
+		}
+
+};
+
+template<typename T>
+INLINE_FUNCTION_H
+iOstream& operator <<(iOstream& os, const Range<T>& rng)
+{
+	os<<"["<<rng.start()<<" "<<rng.end()<<")";
+	return os;
+}
+
+using range32 	= Range<int32>;
+
+using range64 	= Range<int64>;
+
+using rangeU32 	= Range<uint32>;
+
+using rangeU64 	= Range<uint64>;
+
+
+} // pFlow
+
+#endif  //__KokkosTypes_hpp__
diff --git a/src/phasicFlow/Kokkos/ViewAlgorithms.hpp b/src/phasicFlow/Kokkos/ViewAlgorithms.hpp
index 2e94cc3c..d765e014 100644
--- a/src/phasicFlow/Kokkos/ViewAlgorithms.hpp
+++ b/src/phasicFlow/Kokkos/ViewAlgorithms.hpp
@@ -23,7 +23,9 @@ Licence:
 
 
 #include "numericConstants.hpp"
+#include "Range.hpp"
 #include "KokkosUtilities.hpp"
+
 #include "kokkosAlgorithms.hpp"
 #include "stdAlgorithms.hpp"
 #include "cudaAlgorithms.hpp"
@@ -31,36 +33,25 @@ Licence:
 
 namespace pFlow
 { 	
-
-inline const size_t maxSizeToSerial__ = 64;
-
 template<typename T, typename... properties>
 INLINE_FUNCTION_H
-int32 count(
+uint32 count(
 	const ViewType1D<T, properties...>& view,
-	int32 start,
-	int32 end,
+	uint32 start,
+	uint32 end,
 	const T& val)
 {
+	
 	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
 	
-	int32 numElems = end-start;
+	uint32 numElems = end-start;
 
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{
-			return pFlow::algorithms::STD::count<T,false>(
-				view.data()+start,
-				numElems,
-				val);
-		}
-	}
-
-	return  pFlow::algorithms::KOKKOS::count<T, ExecutionSpace>(
-			view.data()+start,
-			numElems,
-			val);
+	return  pFlow::algorithms::KOKKOS::count<T, ExecutionSpace>
+	(
+		view.data()+start,
+		numElems,
+		val
+	);
 }	
 
 template<typename T, typename... properties>
@@ -68,40 +59,66 @@ INLINE_FUNCTION_H
 void fill
 (
 	ViewType1D<T, properties...>& view,
-	range span,
+	rangeU32 span,
 	T val
 )
 {
-	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
-
-
-	if constexpr( isHostAccessible<ExecutionSpace>())
+	using exe_space = typename ViewType1D<T, properties...>::execution_space;
+	auto subV = Kokkos::subview(view, span.getPair() );
+	if constexpr ( std::is_trivially_copyable_v<T>)
 	{
-		int32 numElems = span.second-span.first;
-		if( numElems<maxSizeToSerial__)
+		Kokkos::deep_copy(subV, val);
+	}
+	else if constexpr( isHostAccessible<exe_space>())
+	{
+		for(auto i=span.start(); i<span.end(); i++ )
 		{
-			pFlow::algorithms::STD::fill<T,false>(
-				view.data()+span.first,
-				numElems,
-				val);
-			return;
+			view[i] = val;
 		}
 	}
-
-	auto subV = Kokkos::subview(view, span);
-	Kokkos::deep_copy(subV, val);
+	else
+	{
+		static_assert("fill is not valid for non-trivially-copyable data type");
+	}
+	
 }
 
 template<typename T, typename... properties>
 void fill
 (
 	ViewType1D<T, properties...>& view,
-	int32 start,
-	int32 end,
+	uint32 start,
+	uint32 end,
 	T val
 )
 {
-	fill(view, range(start,end),val);
+	fill(view, rangeU32(start, end),val);
+}
+
+template<typename T, typename... properties>
+void fill
+(
+	ViewType3D<T, properties...>& view,
+	rangeU32 range1,
+	rangeU32 range2,
+	rangeU32 range3,
+	const T& val
+)
+{
+	static_assert(std::is_trivially_copyable_v<T>, "Not valid type for fill");
+	auto subV = Kokkos::subview(view, range1, range2, range3);
+	Kokkos::deep_copy(subV, val);
+}
+
+template<typename T, typename... properties>
+void fill
+(
+	ViewType3D<T, properties...>& view,
+	const T& val
+)
+{
+	static_assert(std::is_trivially_copyable_v<T>, "Not valid type for fill");
+	Kokkos::deep_copy(view, val);
 }
 
 template<
@@ -109,26 +126,14 @@ template<
 	typename... properties>
 void fillSequence(
 	ViewType1D<Type, properties...>& view,
-	int32 start,
-	int32 end,
+	uint32 start,
+	uint32 end,
 	const Type startVal
 	)
 {
-
+	static_assert(std::is_trivially_copyable_v<Type>, "Not valid type for fill");
 	using ExecutionSpace = typename ViewType1D<Type, properties...>::execution_space;
-	int32 numElems = end-start;
-
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{ 
-			pFlow::algorithms::STD::fillSequence<Type,false>(
-				view.data()+start,
-				numElems,
-				startVal);
-			return ;
-		}
-	}
+	uint32 numElems = end-start;
 
 	pFlow::algorithms::KOKKOS::fillSequence<Type, ExecutionSpace>(
 			view.data()+start,
@@ -144,38 +149,32 @@ template<
 	typename... properties,
 	typename indexType,
 	typename... indexProperties>
-bool fillSelected(
+bool fillSelected
+(
 	ViewType1D<Type, properties...> view,
-	const ViewType1D<indexType, indexProperties...> indices,
-	const int32 numElems,
-	const Type val,
-	typename std::enable_if_t<
-		areAccessible<
-			typename ViewType1D<Type, properties...>::execution_space,
-			typename ViewType1D<indexType, indexProperties...>::memory_space>(),
-		bool> = true )
+	ViewType1D<indexType, indexProperties...> indices,
+	uint32 numElems,
+	Type val
+)
 {
 
-	using ExecutionSpace = typename ViewType1D<Type, properties...>::execution_space;
-	
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{ 
-			pFlow::algorithms::STD::fillSelected<Type,indexType,false>(
-				view.data(),
-				indices.data(),
-				numElems,
-				val);
-			return true;
-		}
-	}
+	static_assert(std::is_trivially_copyable_v<Type>, "Not valid type for fillSelected");
+	static_assert(
+      areAccessible<
+			typename ViewType1D<Type, properties...>::execution_space,
+			typename ViewType1D<indexType, indexProperties...>::memory_space>(),
+      "In fillSelected, arguments view and indices must have similar spaces");
 
-	pFlow::algorithms::KOKKOS::fillSelected<Type, indexType, ExecutionSpace>(
-			view.data(),
-			indices.data(),
-			numElems,
-			val);
+	using ExSpace = typename ViewType1D<Type, properties...>::execution_space;
+	using policy = Kokkos::RangePolicy<ExSpace,Kokkos::IndexType<uint32> >;
+
+	Kokkos::parallel_for(
+		"ViewAlgorithms::fillSelected",
+		policy(0,numElems),
+		LAMBDA_HD(uint32 i){
+			//view[indices[i]]= val;
+		});
+	Kokkos::fence();
 
 	return true;
 }
@@ -185,39 +184,21 @@ template<
 	typename... properties,
 	typename indexType,
 	typename... indexProperties>
-	//typename valType> //,
-	//typename... valProperties>
 bool fillSelected(
 	ViewType1D<Type, properties...> view,
 	const ViewType1D<indexType, indexProperties...> indices,
-	const ViewType1D<Type, indexProperties...> vals,
-	const int32 numElems ,
-	typename std::enable_if_t<
-		areAccessible<
+	const ViewType1D<Type, properties...> vals,
+	const uint32 numElems )
+{
+	static_assert(std::is_trivially_copyable_v<Type>, "Not valid type for fillSelected");
+	static_assert(
+      areAccessible<
 			typename ViewType1D<Type, properties...>::execution_space,
 			typename ViewType1D<indexType, indexProperties...>::memory_space>(),
-		bool> = true )
-{
+      "In fillSelected arguments view and indices must have similar spaces");
 
 	using ExecutionSpace = typename ViewType1D<Type, properties...>::execution_space;
 	
-
-
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{ 
-			pFlow::algorithms::STD::fillSelected<Type,indexType,false>(
-				view.data(),
-				indices.data(),
-				vals.data(),
-				numElems
-				);
-			return true;
-		}
-	}
-
-
 	pFlow::algorithms::KOKKOS::fillSelected<Type, indexType, ExecutionSpace>(
 			view.data(),
 			indices.data(),
@@ -233,26 +214,15 @@ template<typename T, typename... properties>
 INLINE_FUNCTION_H
 T min( 
 	const ViewType1D<T, properties...>& view,
-	int32 start,
-	int32 end)
+	uint32 start,
+	uint32 end)
 {
 
 	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
 	
-	int32 numElems = end-start;
-
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{
-			return 
-			pFlow::algorithms::STD::min<T,false>(
-				view.data()+start,
-				numElems);
-		}
-	}
-
-	return  
+	uint32 numElems = end-start;
+ 	
+ 	return 
 	pFlow::algorithms::KOKKOS::min<T, ExecutionSpace>(
 		view.data()+start,
 		numElems);
@@ -262,24 +232,13 @@ template<typename T, typename... properties>
 INLINE_FUNCTION_H
 T max( 
 	const ViewType1D<T, properties...>& view,
-	int32 start,
-	int32 end)
+	uint32 start,
+	uint32 end)
 {
 
 	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
 	
-	int32 numElems = end-start;
-
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{
-			return 
-			pFlow::algorithms::STD::max<T,false>(
-				view.data()+start,
-				numElems);
-		}
-	}
+	uint32 numElems = end-start;
 
 	return  
 	pFlow::algorithms::KOKKOS::max<T, ExecutionSpace>(
@@ -309,15 +268,15 @@ template <
 INLINE_FUNCTION_H
 void copy(
 	const ViewType1D<dType, dProperties...>& dst,
-	int32 dStart,
+	uint32 dStart,
 	const ViewType1D<sType, sProperties...>& src,
-	int32 sStart,
-	int32 sEnd
+	uint32 sStart,
+	uint32 sEnd
 	)
 {
 
-	range sSpan(sStart,sEnd);
-	range dSpan(dStart,dStart+(sEnd-sStart));
+	range32 sSpan(sStart,sEnd);
+	range32 dSpan(dStart,dStart+(sEnd-sStart));
 	
 	auto srcSub = Kokkos::subview(src, sSpan);
 	auto dstSub = Kokkos::subview(dst, dSpan);
@@ -326,19 +285,19 @@ void copy(
 }
 
 template <
-	typename dType,
-	typename sType,
+	typename Type,
 	typename... sProperties>
 INLINE_FUNCTION_H
 void getNth(
-	dType& dst,
-	const ViewType1D<sType, sProperties...>& src,
-	const int32 n
+	Type& dst,
+	const ViewType1D<Type, sProperties...>& src,
+	const uint32 n
 	)
 {
-	range span(n,n+1);
-	auto subV = Kokkos::subview(src, span);
-	hostViewType1D<dType> dstView("getNth",1);
+		
+	auto subV = Kokkos::subview(src, Kokkos::make_pair(n,n+1));
+	hostViewType1D<Type> dstView("getNth",1);
+	//hostViewTypeScalar
 	Kokkos::deep_copy(dstView,subV);
 	dst = *dstView.data();
 }
@@ -348,30 +307,19 @@ template<typename T, typename... properties>
 INLINE_FUNCTION_H
 void sort( 
 	ViewType1D<T, properties...>& view,
-	int32 start,
-	int32 end)
+	uint32 start,
+	uint32 end)
 {
-
 	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
 	
-	int32 numElems = end-start;
+	uint32 numElems = end-start;
 
 	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{
-			pFlow::algorithms::STD::sort<T,false>(
-				view.data()+start,
-				numElems);
-			return;
-		}
-		else
-		{
-			pFlow::algorithms::STD::sort<T,true>(
-				view.data()+start,
-				numElems);
-			return;
-		}
+	{		
+		pFlow::algorithms::STD::sort<T,true>(
+			view.data()+start,
+			numElems);
+		return;
 	}
 
 #ifdef __CUDACC__
@@ -391,33 +339,22 @@ template<typename T, typename... properties, typename CompareFunc>
 INLINE_FUNCTION_H
 void sort( 
 	ViewType1D<T, properties...>& view,
-	int32 start,
-	int32 end,
+	uint32 start,
+	uint32 end,
 	CompareFunc compare)
 {
 
 	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
 	
-	int32 numElems = end-start;
+	uint32 numElems = end-start;
 
 	if constexpr( isHostAccessible<ExecutionSpace>())
 	{
-		if(numElems<maxSizeToSerial__)
-		{
-			pFlow::algorithms::STD::sort<T,CompareFunc,false>(
-				view.data()+start,
-				numElems,
-				compare);
-			return;
-		}
-		else
-		{
-			pFlow::algorithms::STD::sort<T,CompareFunc,true>(
-				view.data()+start,
-				numElems,
-				compare);
-			return;
-		}
+		pFlow::algorithms::STD::sort<T,CompareFunc,true>(
+			view.data()+start,
+			numElems,
+			compare);
+		return;	
 	}
 
 #ifdef __CUDACC__
@@ -441,40 +378,28 @@ template<
 	typename... permProperties>
 void permuteSort(
 	const ViewType1D<Type, properties...>& view,
-	int32 start,
-	int32 end,
+	uint32 start,
+	uint32 end,
 	ViewType1D<permType, permProperties...>& permuteView,
-	int32 permStart,
-	typename std::enable_if_t<
+	uint32 permStart )
+{
+	static_assert(
 		areAccessible<
 			typename ViewType1D<Type, properties...>::execution_space,
 			typename ViewType1D<permType, permProperties...>::memory_space>(),
-		bool> = true )
-{
+		"In permuteSort, view and permuteView should have the same space");
+
 	using ExecutionSpace = typename ViewType1D<Type, properties...>::execution_space;
 	
-	int32 numElems = end-start;
-
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{
-			pFlow::algorithms::STD::permuteSort<Type,permType,false>(
-				view.data()+start,
-				permuteView.data()+permStart,
-				numElems	);
-			return;
-		}
-		else
-		{
-			pFlow::algorithms::STD::permuteSort<Type,permType,true>(
-				view.data()+start,
-				permuteView.data()+permStart,
-				numElems);
-			return;
-		}
-	}
+	uint32 numElems = end-start;
+		
+	pFlow::algorithms::STD::permuteSort<Type,permType,true>(
+		view.data()+start,
+		permuteView.data()+permStart,
+		numElems);
+	return;
 
+	
 #ifdef __CUDACC__
 	
 	pFlow::algorithms::CUDA::permuteSort(
@@ -488,21 +413,52 @@ void permuteSort(
 
 }
 
+template<typename T>
+INLINE_FUNCTION_HD
+int32 binarySearch_(const T* array, int32 length, const T& val)
+{
+    if(length <= 0) return -1;
+    
+    int low = 0;            
+    int high = length - 1;  
+
+    while (low <= high) 
+    {
+        int mid = low + (high - low)/2;
+        
+        if ( array[mid] > val)
+        { 
+            high = mid - 1;  
+        }
+        else if ( array[mid] < val)
+        { 
+            low = mid + 1;        
+        }
+        else 
+        {           
+            return mid; 
+        }
+    }
+
+    return -1; // val not found in array[0, length)
+}
+
+/// On DEVICE and HOST calls 
 template<
 	typename Type,
 	typename... properties>
 INLINE_FUNCTION_HD
-int32 binarySearch(
+uint32 binarySearch(
 	const ViewType1D<Type, properties...>& view,
-	int32 start,
-	int32 end,
+	uint32 start,
+	uint32 end,
 	const Type& val)
 {
 	
 	if(end<=start)return -1;
 
 	if(auto res = 
-		pFlow::algorithms::binarySearch(view.data()+start,end-start,val); res>=0) {
+		binarySearch_(view.data()+start,end-start,val); res!=-1) {
 		return res+start;
 	}
 	else{
@@ -513,36 +469,29 @@ int32 binarySearch(
 template<
 	typename Type,
 	typename... properties,
-	typename dType,
 	typename... dProperties>
 void exclusiveScan(
 	const ViewType1D<Type, properties...>& view,
-	int32 start,
-	int32 end,
-	ViewType1D<dType, dProperties...>& dView,
-	int32 dStart,
-	typename std::enable_if_t<
+	uint32 start,
+	uint32 end,
+	ViewType1D<Type, dProperties...>& dView,
+	uint32 dStart )
+{
+
+	static_assert
+	(
 		areAccessible<
 			typename ViewType1D<Type, properties...>::execution_space,
-			typename ViewType1D<dType, dProperties...>::memory_space>(),
-		bool> = true )
-{
+			typename ViewType1D<Type, dProperties...>::memory_space>(),
+		"In exclusiveScan, view and dView should have the same space"
+
+	);
+
 	using ExecutionSpace = typename ViewType1D<Type, properties...>::execution_space;
 	
-	int32 numElems = end-start;
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{
-			pFlow::algorithms::STD::exclusiveScan<Type,dType,false>(
-				view.data()+start,
-				dView.data()+dStart,
-				numElems);
-			return;
-		}
-	}
-
-	pFlow::algorithms::KOKKOS::exclusiveScan<Type,dType,ExecutionSpace>(
+	uint32 numElems = end-start;
+	
+	pFlow::algorithms::KOKKOS::exclusiveScan<Type,ExecutionSpace>(
 		view.data()+start,
 		dView.data()+dStart,
 		numElems);
@@ -552,36 +501,28 @@ void exclusiveScan(
 template<
 	typename Type,
 	typename... properties,
-	typename dType,
 	typename... dProperties>
 void inclusiveScan(
 	const ViewType1D<Type, properties...>& view,
-	int32 start,
-	int32 end,
-	ViewType1D<dType, dProperties...>& dView,
-	int32 dStart,
-	typename std::enable_if_t<
-		areAccessible<
-			typename ViewType1D<Type, properties...>::execution_space,
-			typename ViewType1D<dType, dProperties...>::memory_space>(),
-		bool> = true )
+	uint32 start,
+	uint32 end,
+	ViewType1D<Type, dProperties...>& dView,
+	uint32 dStart)
 {
 	using ExecutionSpace = typename ViewType1D<Type, properties...>::execution_space;
 	
-	int32 numElems = end-start;
-	if constexpr( isHostAccessible<ExecutionSpace>())
-	{
-		if(numElems<maxSizeToSerial__)
-		{
-			pFlow::algorithms::STD::inclusiveScan<Type,dType,false>(
-				view.data()+start,
-				dView.data()+dStart,
-				numElems);
-			return;
-		}
-	}
+	static_assert
+	(
+		areAccessible<
+			typename ViewType1D<Type, properties...>::execution_space,
+			typename ViewType1D<Type, dProperties...>::memory_space>(),
+		"In exclusiveScan, view and dView should have the same space"
+	);
 
-	pFlow::algorithms::KOKKOS::inclusiveScan<Type,dType,ExecutionSpace>(
+
+	uint32 numElems = end-start;
+
+	pFlow::algorithms::KOKKOS::inclusiveScan<Type,ExecutionSpace>(
 		view.data()+start,
 		dView.data()+dStart,
 		numElems);
diff --git a/src/phasicFlow/Kokkos/baseAlgorithmsFwd.hpp b/src/phasicFlow/Kokkos/baseAlgorithmsFwd_.hpp
similarity index 100%
rename from src/phasicFlow/Kokkos/baseAlgorithmsFwd.hpp
rename to src/phasicFlow/Kokkos/baseAlgorithmsFwd_.hpp
diff --git a/src/phasicFlow/Kokkos/baseAlgorithms.hpp b/src/phasicFlow/Kokkos/baseAlgorithms_.hpp
similarity index 96%
rename from src/phasicFlow/Kokkos/baseAlgorithms.hpp
rename to src/phasicFlow/Kokkos/baseAlgorithms_.hpp
index 70f1f76f..0c887ae4 100644
--- a/src/phasicFlow/Kokkos/baseAlgorithms.hpp
+++ b/src/phasicFlow/Kokkos/baseAlgorithms_.hpp
@@ -213,17 +213,6 @@ void insertSetElementD
 
 }
 
-/*template<typename T, typename... properties>
-void fill
-(
-	ViewType1D<T, properties...>& view,
-	range range,
-	T val
-)
-{
-	auto subV = Kokkos::subview(view, range);
-	Kokkos::deep_copy(subV, val);
-}*/
 
 
 template<typename T, typename... properties>
diff --git a/src/Geometry/geometryMotion/geometryMotionsInstantiate.cpp b/src/phasicFlow/Kokkos/phasicFlowKokkos.hpp
similarity index 72%
rename from src/Geometry/geometryMotion/geometryMotionsInstantiate.cpp
rename to src/phasicFlow/Kokkos/phasicFlowKokkos.hpp
index a8ec4fd9..3372ba8a 100644
--- a/src/Geometry/geometryMotion/geometryMotionsInstantiate.cpp
+++ b/src/phasicFlow/Kokkos/phasicFlowKokkos.hpp
@@ -18,15 +18,13 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "fixedWall.hpp"
-#include "rotatingAxisMotion.hpp"
-#include "multiRotatingAxisMotion.hpp"
-#include "vibratingMotion.hpp"
+#ifndef __phsicFlowKokkos_hpp__
+#define __phsicFlowKokkos_hpp__
 
-template class pFlow::geometryMotion<pFlow::fixedWall>;
+#include "KokkosTypes.hpp"
+#include "KokkosUtilities.hpp"
+#include "ViewAlgorithms.hpp"
+#include "Range.hpp"
 
-template class pFlow::geometryMotion<pFlow::rotatingAxisMotion>;
 
-template class pFlow::geometryMotion<pFlow::multiRotatingAxisMotion>;
-
-template class pFlow::geometryMotion<pFlow::vibratingMotion>;
+#endif //  __phsicFlowKokkos_hpp__
diff --git a/src/phasicFlow/Timer/Timer.cpp b/src/phasicFlow/Timer/Timer.cpp
index 9a4546e4..424addec 100644
--- a/src/phasicFlow/Timer/Timer.cpp
+++ b/src/phasicFlow/Timer/Timer.cpp
@@ -22,7 +22,7 @@ Licence:
 #include "Timers.hpp"
 #include "streams.hpp"
 
-pFlow::Timer::Timer(const word name, Timers* parrent)
+pFlow::Timer::Timer(const word& name, Timers* parrent)
 :
 	name_(name),
 	parrent_(parrent)
diff --git a/src/phasicFlow/Timer/Timer.hpp b/src/phasicFlow/Timer/Timer.hpp
index 4c731444..ac32ba35 100644
--- a/src/phasicFlow/Timer/Timer.hpp
+++ b/src/phasicFlow/Timer/Timer.hpp
@@ -63,15 +63,15 @@ public:
 
 	TypeInfo("Timer");
 
-	Timer(){}
+	Timer() = default;
 
-	Timer(const word name)
+	explicit Timer(const word& name)
 	:
 		name_(name)
 	{}
 
 	
-	Timer(const word name, Timers* parrent);
+	Timer(const word& name, Timers* parrent);
 	
 
 	const word& name()const
diff --git a/src/phasicFlow/algorithms/algorithmFunctions.hpp b/src/phasicFlow/algorithms/algorithmFunctions.hpp
index 44778caf..0ce97355 100644
--- a/src/phasicFlow/algorithms/algorithmFunctions.hpp
+++ b/src/phasicFlow/algorithms/algorithmFunctions.hpp
@@ -60,37 +60,6 @@ struct minimum
       return lhs < rhs ? lhs : rhs; }
 };
 
-
-template<typename T>
-INLINE_FUNCTION_HD
-int binarySearch(const T* array, int length, const T& val)
-{
-    
-    int low = 0;            
-    int high = length - 1;  
-
-    while (low <= high) 
-    {
-        int mid = low + (high - low)/2;
-        
-        if ( array[mid] > val)
-        { 
-            high = mid - 1;  
-        }
-        else if ( array[mid] < val)
-        { 
-            low = mid + 1;        
-        }
-        else 
-        {           
-            return mid; 
-        }
-    }
-
-    return -1; // val not found in array[0, length)
-}
-
-
 } 
 
 #endif // __algorithmFunctions_hpp__
\ No newline at end of file
diff --git a/src/phasicFlow/algorithms/kokkosAlgorithms.hpp b/src/phasicFlow/algorithms/kokkosAlgorithms.hpp
index 218e6e6d..6102dd7a 100644
--- a/src/phasicFlow/algorithms/kokkosAlgorithms.hpp
+++ b/src/phasicFlow/algorithms/kokkosAlgorithms.hpp
@@ -30,15 +30,15 @@ namespace pFlow::algorithms::KOKKOS
 
 template<typename Type, typename ExecutionSpace>
 INLINE_FUNCTION_H
-int32 count(const Type* first, int32 numElems, const Type& val)
+uint32 count(const Type* first, uint32 numElems, const Type& val)
 {
 	using policy = Kokkos::RangePolicy<
 			ExecutionSpace,
-			Kokkos::IndexType<int32> >;
-	int32 num = 0;
+			Kokkos::IndexType<uint32> >;
+	uint32 num = 0;
 	Kokkos::parallel_reduce("count",
 							policy(0, numElems),
-							LAMBDA_HD(int32 i, int32& updateVal){
+							LAMBDA_HD(uint32 i, uint32& updateVal){
 								if(equal(first[i],val)) updateVal++;
 							},
 							num);
@@ -50,17 +50,17 @@ int32 count(const Type* first, int32 numElems, const Type& val)
 
 template<typename Type, typename ExecutionSpace>
 INLINE_FUNCTION_H
-void fillSequence(Type* first, int32 numElems, const Type& firstVal)
+void fillSequence(Type* first, uint32 numElems, const Type& firstVal)
 {
 	
 	using policy = Kokkos::RangePolicy<
 			ExecutionSpace,
-			Kokkos::IndexType<int32> >;
+			Kokkos::IndexType<uint32> >;
 
 	Kokkos::parallel_for(
 		"fillSequence",
 		policy(0, numElems),
-		LAMBDA_HD(int32 i){ 
+		LAMBDA_HD(uint32 i){ 
 			first[i] = firstVal+i;
 		});
 	Kokkos::fence();
@@ -68,15 +68,15 @@ void fillSequence(Type* first, int32 numElems, const Type& firstVal)
 
 template<typename Type, typename indexType, typename ExecutionSpace>
 INLINE_FUNCTION_H
-void fillSelected(Type* first, const indexType* indices, const int32 numElems, const Type val)
+void fillSelected(Type* first, const indexType* indices, const uint32 numElems, const Type val)
 {
 	using policy = Kokkos::RangePolicy<
 			ExecutionSpace,
-			Kokkos::IndexType<int32> >;
+			Kokkos::IndexType<uint32> >;
 	Kokkos::parallel_for(
 		"fillSelected",
 		policy(0,numElems),
-		LAMBDA_HD(int32 i){
+		LAMBDA_HD(uint32 i){
 			first[indices[i]]= val;
 		});
 	Kokkos::fence();
@@ -84,16 +84,16 @@ void fillSelected(Type* first, const indexType* indices, const int32 numElems, c
 
 template<typename Type, typename indexType, typename ExecutionSpace>
 INLINE_FUNCTION_H
-void fillSelected(Type* first, const indexType* indices, const Type* vals, const int32 numElems)
+void fillSelected(Type* first, const indexType* indices, const Type* vals, const uint32 numElems)
 {
 	using policy = Kokkos::RangePolicy<
 			ExecutionSpace,
-			Kokkos::IndexType<int32> >;
+			Kokkos::IndexType<uint32> >;
 
 	Kokkos::parallel_for(
 		"fillSelected",
 		policy(0,numElems),
-		LAMBDA_HD(int32 i){
+		LAMBDA_HD(uint32 i){
 			first[indices[i]]= vals[i];
 		});
 	Kokkos::fence();
@@ -101,17 +101,17 @@ void fillSelected(Type* first, const indexType* indices, const Type* vals, const
 
 template<typename Type, typename ExecutionSpace>
 INLINE_FUNCTION_H
-Type max(const Type* first, int32 numElems)
+Type max(const Type* first, uint32 numElems)
 {
 	using policy = Kokkos::RangePolicy<
 			ExecutionSpace,
-			Kokkos::IndexType<int32> >;
+			Kokkos::IndexType<uint32> >;
 	Type maxElement=0;
 
 	Kokkos::parallel_reduce(
 		"max",
 		policy(0, numElems),
-		LAMBDA_HD(int32 i, Type& maxUpdate){
+		LAMBDA_HD(uint32 i, Type& maxUpdate){
 			if(maxUpdate<first[i]) maxUpdate = first[i];
 		},
 		Kokkos::Max<Type>(maxElement));
@@ -144,38 +144,38 @@ Type min(const Type* first, int32 numElems)
 //void sort(Type* first, int32 numElems, CompareFunc compare);
 //void permuteSort(const Type* first, PermuteType* pFirst, int32 numElems);
 
-template<typename Type, typename DestType, typename ExecutionSpace>
-void exclusiveScan(Type* first, DestType* dFirst, int32 numElems)
+template<typename Type, typename ExecutionSpace>
+void exclusiveScan(Type* first, Type* dFirst, uint32 numElems)
 {	
 	using policy = Kokkos::RangePolicy<
 			ExecutionSpace,
-			Kokkos::IndexType<int32> >;
+			Kokkos::IndexType<uint32> >;
 
 	Kokkos::parallel_scan(
 		"exclusiveScan",
 		policy(0, numElems),
-		LAMBDA_HD(const int32 i, DestType& valToUpdate, const bool final)
+		LAMBDA_HD(const uint32 i, Type& valToUpdate, const bool final)
 		{
-			const int32 val = first[i];
+			const Type val = first[i];
 			if(final)
 				dFirst[i] = valToUpdate;
 			valToUpdate += val;
 		});
 }
 
-template<typename Type, typename DestType, typename ExecutionSpace>
-void inclusiveScan(Type* first, DestType* dFirst, int32 numElems)
+template<typename Type, typename ExecutionSpace>
+void inclusiveScan(Type* first, Type* dFirst, uint32 numElems)
 {
 	using policy = Kokkos::RangePolicy<
 			ExecutionSpace,
-			Kokkos::IndexType<int32> >;
+			Kokkos::IndexType<uint32> >;
 
 	Kokkos::parallel_scan(
 		"inclusiveScan",
 		policy(0, numElems),
-		LAMBDA_HD(const int32 i, int32& valToUpdate, const bool final)
+		LAMBDA_HD(const uint32 i, Type& valToUpdate, const bool final)
 		{
-			const int32 val = first[i];
+			const Type val = first[i];
 			valToUpdate += val;
 			if(final)
 				dFirst[i] = valToUpdate;
diff --git a/src/phasicFlow/commandLine/CLI/Validators.hpp b/src/phasicFlow/commandLine/CLI/Validators.hpp
index 03eb77b6..ffddd84b 100644
--- a/src/phasicFlow/commandLine/CLI/Validators.hpp
+++ b/src/phasicFlow/commandLine/CLI/Validators.hpp
@@ -11,7 +11,7 @@
 #include "TypeTools.hpp"
 
 // [CLI11:public_includes:set]
-#include <cmath>
+#include "math.hpp"
 #include <cstdint>
 #include <functional>
 #include <iostream>
diff --git a/src/phasicFlow/commandLine/commandLine.cpp b/src/phasicFlow/commandLine/commandLine.cpp
index d2002570..f9d82161 100644
--- a/src/phasicFlow/commandLine/commandLine.cpp
+++ b/src/phasicFlow/commandLine/commandLine.cpp
@@ -38,10 +38,10 @@ pFlow::commandLine::commandLine(word appName, word disptn)
 	CLI::App::add_flag_callback(
 		"--description",
 		[disptn, appName]() {
-			output<<"\n"<<yellowText(versoinCopyright)<<endl;
-			output<<yellowText(floatingPointDescription())<<endl<<endl;
-			output<<"Description for "<< boldText(appName)<<":\n";
-			output<<"  "<<disptn<<endl;
+			mOutput<<"\n"<<Yellow_Text(versoinCopyright)<<endl;
+			mOutput<<Yellow_Text(floatingPointDescription())<<endl<<endl;
+			mOutput<<"Description for "<< Bold_Text(appName)<<":\n";
+			mOutput<<"  "<<disptn<<endl;
 		},
 		"What does this app do?"
 		)->configurable(false);
diff --git a/src/phasicFlow/containers/Field/Field.cpp b/src/phasicFlow/containers/Field/Field.cpp
index 5569ea9b..335fbe49 100644
--- a/src/phasicFlow/containers/Field/Field.cpp
+++ b/src/phasicFlow/containers/Field/Field.cpp
@@ -18,7 +18,120 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<template<class, class> class VectorField, class T, class PropType>
+template<class T, class MemorySpace>
+bool pFlow::Field<T, MemorySpace>::read
+(
+	iIstream& is
+)
+{
+	
+	bool tokenFound = true;
+	
+    tokenFound = is.findToken(fieldKey_);
+
+	if( !tokenFound )
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		" error in searching for filedkey " << fieldKey_<<endl;
+		return false;
+	}
+	
+	if( !VectorType::read(is) )
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"error in reading field data from field "<< this->name()<<endl;
+		return false;
+	}
+    
+	is.readEndStatement("Field::read");
+
+	return true;
+}
+
+
+template<class T, class MemorySpace>
+bool pFlow::Field<T, MemorySpace>::read
+(
+	iIstream& is,
+	const IOPattern& iop
+)
+{
+	
+	bool tokenFound = true;
+	
+    if(iop.thisProcReadData())
+        tokenFound = is.findToken(fieldKey_);
+
+	if( !tokenFound )
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		" error in searching for filedkey " << fieldKey_<<endl;
+		return false;
+	}
+	
+	if( !VectorType::read(is, iop) )
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"error in reading field data from field "<< this->name()<<endl;
+		return false;
+	}
+    if(iop.thisProcReadData())
+	    is.readEndStatement("Field::read");
+
+	return true;
+}
+
+template<class T, class MemorySpace>
+bool pFlow::Field<T, MemorySpace>::write
+(
+	iOstream& os
+)const
+{
+
+	os.writeWordKeyword(fieldKey_)<<endl;
+
+	if(!os.check(FUNCTION_NAME))return false;
+
+	if(!VectorType::write(os)) return false;
+
+	os.endEntry();
+	if(!os.check(FUNCTION_NAME))return false;
+
+	return true;
+}
+
+
+
+template<class T, class MemorySpace>
+bool pFlow::Field<T, MemorySpace>::write
+(
+	iOstream& os, 
+	const IOPattern& iop
+)const
+{
+
+	if(iop.thisProcWriteData())
+		os.writeWordKeyword(fieldKey_)<<endl;
+
+	if(!os.check(FUNCTION_NAME))return false;
+
+	if(!VectorType::write(os, iop)) return false;
+
+	if(iop.thisProcWriteData())
+	{
+		os.endEntry();
+		os.newLine();
+	}	
+
+	if(!os.check(FUNCTION_NAME))return false;
+
+	return true;
+}
+
+
+
+
+/*template<template<class, class> class VectorField, class T, class PropType>
 bool pFlow::Field<VectorField, T, PropType>::readUniform
 ( 
 	iIstream& is,
@@ -94,10 +207,10 @@ bool pFlow::Field<VectorField, T, PropType>::readNonUniform
 		
 
 	return true;	
-}
+}*/
 
 
-template<template<class, class> class VectorField, class T, class PropType>
+/*template<template<class, class> class VectorField, class T, class PropType>
 bool pFlow::Field<VectorField, T, PropType>::readField
 (
 	iIstream& is,
@@ -178,5 +291,4 @@ bool pFlow::Field<VectorField, T, PropType>::writeField(iOstream& os)const
 	os.endEntry();
 
 	return true;
-}
-
+}*/
diff --git a/src/phasicFlow/containers/Field/Field.hpp b/src/phasicFlow/containers/Field/Field.hpp
index 1a0f2448..887b994d 100644
--- a/src/phasicFlow/containers/Field/Field.hpp
+++ b/src/phasicFlow/containers/Field/Field.hpp
@@ -21,226 +21,198 @@ Licence:
 #ifndef __Field_hpp__
 #define __Field_hpp__
 
+
+#include "types.hpp"
 #include "VectorSingle.hpp"
-#include "vocabs.hpp"
+#include "Vector.hpp"
+#include "streams.hpp"
 
 namespace pFlow
 {
 
 
-
-template<template<class, class> class VectorField, class T, class PropType=void>
+template<class T, class MemorySpace = void>
 class Field
 :
-	public VectorField<T, PropType>
+	public VectorSingle<T, MemorySpace>
 {
 public:
-	
 
-	using VectorType  		= VectorField<T,PropType>;
+	using VectorType  		= VectorSingle<T,MemorySpace>;
 
-	using FieldType         = Field<VectorField, T, PropType>;
+	using FieldType         = Field<T, MemorySpace>;
 
-	using iterator        = typename VectorType::iterator;
+	using FieldTypeHost 	= Field<T, HostSpace>;
 
-  	using constIterator   = typename VectorType::constIterator;
+	using memory_space 		= typename VectorType::memory_space;
 
-	using reference       = typename VectorType::reference;
+	using execution_space 	= typename VectorType::execution_space;
+
+	using iterator        	= typename VectorType::iterator;
+
+	using const_iterator   	= typename VectorType::const_iterator;
+
+	using reference       	= typename VectorType::reference;
   	
-  	using constReference  = typename VectorType::constReference;
+	using const_reference  	= typename VectorType::const_reference;
 
-	using valueType       = typename VectorType::valueType;
+	using value_type       	= typename VectorType::value_type;
   	
-  	using pointer         = typename VectorType::pointer;
+	using pointer         	= typename VectorType::pointer;
   	
-  	using constPointer    = typename VectorType::constPointer;
+	using const_pointer    	= typename VectorType::const_pointer;
   	
 
-protected:
+private:
 	
 	static const inline word FKey = "value";
 
 	const word fieldKey_ = FKey;
 
-	bool readUniform( iIstream& is, size_t len, bool readLength = true);
-
-	bool readNonUniform( iIstream& is, size_t len);
-
 public:
 
-	// - type info
-	TypeInfoTemplateNV2("Field", T, VectorType::memoerySpaceName());
+	/// type info
+	TypeInfoTemplateNV111("Field", T, VectorType::memoerySpaceName());
 
 	//// - Constructors
 
-		// construct an empty Filed with default fieldKey
+		/// construct an empty Filed with default fieldKey
 		Field()
 		:
 			VectorType()
 		{}
 
-		// construct an empty Field with fieldKey
-		Field(const word& fieldKey)
+		Field(const word& name)
 		:
-			VectorType(),
-			fieldKey_(fieldKey)
+			VectorType(name)
 		{}
 
-		// construct an empty field with name and fieldKey 
+		/// Construct an empty field with name and fieldKey 
 		Field(const word& name, const word& fieldKey)
 		:
 			VectorType(name),
 			fieldKey_(fieldKey)
 		{}
-
-		// construct an empty Filed with default fieldKey
-		Field(size_t len)
-		:
-			VectorType(len)
-		{}
-
-		// construct an empty Field with fieldKey
-		Field(const word& fieldKey, size_t len)
-		:
-			VectorType(len),
-			fieldKey_(fieldKey)
-		{}
-
-		// construct an empty field with name and fieldKey 
+		
+		/// Construct a field with name and fieldKey and specified len
 		Field(const word& name, const word& fieldKey, size_t len)
 		:
 			VectorType(name, len),
 			fieldKey_(fieldKey)
 		{}
 
-		// construct an empty Filed with default fieldKey and set vector to val
-		Field(size_t len, const T& val)
-		:
-			VectorType(len, val)
-		{}
-
-		// construct an empty Field with fieldKey and set vector to val
-		Field(const word& fieldKey, size_t len, const T& val)
-		:
-			VectorType(len, val),
-			fieldKey_(fieldKey)
-		{}
-
-		// construct an empty field with name and fieldKey and set vector to val
+		
+		/// Construct a field with name, fieldKey and 
+		/// set length to len and value to val
 		Field(const word& name, const word& fieldKey, size_t len, const T& val)
 		:
 			VectorType(name, len, val),
 			fieldKey_(fieldKey)
 		{}
 
-		// construct a field with capacity and len and default fieldKey
-		Field(size_t capacity, size_t len, RESERVE)
+		Field(const word& name, const word& fieldKey, size_t capacity, size_t len, const T& val)
 		:
-			VectorType(capacity, len, RESERVE())
-		{}
-
-		// construct an empty Field with fieldKey
-		Field(const word& fieldKey, size_t capacity, size_t len, RESERVE)
-		:
-			VectorType(capacity, len, RESERVE()),
+			VectorType(name, len, len, RESERVE()),
 			fieldKey_(fieldKey)
-		{}
+		{
+			VectorType::fill(val);
+		}
 
-		// construct an empty field with name and fieldKey 
+		/// Construct a field with name, fieldKey, capacity and len
 		Field(const word& name, const word& fieldKey, size_t capacity, size_t len, RESERVE)
 		:
 			VectorType(name, capacity, len, RESERVE()),
 			fieldKey_(fieldKey)
 		{}
 
-		// construct with vec and default fieldKey
-		Field(const Vector<T>& vec)
-		:
-			VectorType(vec)
-		{}
-
-		// construct an empty Field with fieldKey
+		/// Construct a field with fieldKey and Vector vec
 		Field(const word& fieldKey, const Vector<T>& vec)
 		:
-			VectorType(vec),
+			VectorType(vec.name(), vec.vectorField()),
 			fieldKey_(fieldKey)
 		{}
 
-		// construct an empty field with name and fieldKey 
+		/// Construct a field with name, fieldKey and Vector vec
 		Field(const word& name, const word& fieldKey, const Vector<T>& vec)
+		:
+			VectorType(name, vec.vectorField()),
+			fieldKey_(fieldKey)
+		{}
+
+		/// Construct a field with name and fieldKey and std::vector 
+		Field(const word& name, const word& fieldKey, const std::vector<T>& vec)
 		:
 			VectorType(name, vec),
 			fieldKey_(fieldKey)
 		{}
 
-
-		// - copy construct with new name and fieldkey
+		/// Copy construct with new name and fieldkey
 		Field(const word& name, const word& fieldKey, const FieldType& src):
 			VectorType(name, src),
 			fieldKey_(fieldKey)
 		{}
 
-		// - default copy constructor
+		/// Default copy constructor
 		Field(const FieldType&) = default;
 
-		// - default copy assignment 
-		FieldType& operator = (const FieldType&) = default;
-
-		// - no move constructor 
-		Field(FieldType&&) = delete;
-
-		// - no move assignment 
-		FieldType& operator = (FieldType&&) = delete;
-
-		// - clone as a uniquePtr
-		INLINE_FUNCTION_H
-		uniquePtr<FieldType> clone() const
+		/// Copy assignment, name and fieldKey
+		/// on the left hand side are preserved
+		FieldType& operator = (const FieldType& rhs)
 		{
-			return makeUnique<FieldType>(*this);
+			if(&rhs == this) return *this;
+			VectorType::operator=(rhs);
+			return *this;
 		}
 
-		// - clone as a raw pointer 
-		INLINE_FUNCTION_H
-		FieldType* clonePtr()const
-		{
-			return new FieldType(*this);
-		}
+		/// Move constructor 
+		Field(FieldType&&) = default;
+
+		/// Move assignment 
+		FieldType& operator = (FieldType&&) = default;
 
 	//// - Methods
 
-		const word& fieldKey()const
+		/// return field key
+		word fieldKey()const
 		{
 			return fieldKey_;
 		}
-	
+
+		word name()const
+		{
+			return VectorType::name();
+		}
+
+
+		void fillField(rangeU32 span, const T& val)
+		{
+			this->fill(span, val);
+		}
+
+		void fillField(const T& val)
+		{
+			this->fill(val);
+		}
+		
 	//// - IO operations 
-		bool readField(iIstream& is, const size_t len, bool resume, bool readLength = true);
 		
+		bool read(iIstream& is);
 		
-		bool readField(iIstream& is, bool resume );
+		bool write(iOstream& os)const;			
 
-		
-		bool writeField(iOstream& os)const;
 
+		bool read(iIstream& is, const IOPattern& iop);
 		
-		bool read(iIstream& is, bool resume = false)
-		{
-			return readField(is, resume);
-		}
 
-		bool write(iOstream& os)const
-		{
-			return writeField(os);
-		}
-	
+		bool write(iOstream& os, const IOPattern& iop )const;			
 
 };
 
 
-template<template<class, class> class VectorField, class T, class PropType>
-inline iIstream& operator >> (iIstream & is, Field<VectorField, T, PropType> & ifld )
+template<class T, class MemorySpace>
+inline iIstream& operator >> (iIstream & is, Field<T, MemorySpace> & ifld )
 {
-	if( !ifld.readField(is, false) )
+	if( !ifld.read(is, IOPattern::MasterProcessorOnly) )
 	{
 		ioErrorInFile (is.name(), is.lineNumber());
 		fatalExit;
@@ -248,11 +220,11 @@ inline iIstream& operator >> (iIstream & is, Field<VectorField, T, PropType> & i
 	return is;
 }
 
-template<template<class, class> class VectorField, class T, class PropType>
-inline iOstream& operator << (iOstream& os, const Field<VectorField, T, PropType>& ofld )
+template<typename T, typename MemorySpace>
+inline iOstream& operator << (iOstream& os, const Field<T, MemorySpace>& ofld )
 {
 	
-	if( !ofld.writeField(os) )
+	if( !ofld.write(os, IOPattern::AllProcessorsDifferent) )
 	{
 		ioErrorInFile(os.name(), os.lineNumber());
 		fatalExit;
diff --git a/src/phasicFlow/containers/Field/Fields.cpp b/src/phasicFlow/containers/Field/Fields.cpp
index 28779371..55337632 100644
--- a/src/phasicFlow/containers/Field/Fields.cpp
+++ b/src/phasicFlow/containers/Field/Fields.cpp
@@ -21,61 +21,17 @@ Licence:
 #include "Fields.hpp"
 
 
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int8>;
+template class pFlow::Field<pFlow::int8>;
 
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>;
+template class pFlow::Field<pFlow::uint8>;
 
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int16>;
+template class pFlow::Field<pFlow::int32>;
 
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int16, pFlow::HostSpace>;
+template class pFlow::Field<pFlow::uint32>;
 
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int32>;
+template class pFlow::Field<pFlow::real>;
 
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int32, pFlow::HostSpace>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int64>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::int64, pFlow::HostSpace>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::uint32>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::uint32, pFlow::HostSpace>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::label>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::label, pFlow::HostSpace>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::real>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::realx3>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::realx3, pFlow::HostSpace>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::realx3x3>;
-
-template class pFlow::Field<pFlow::VectorSingle, pFlow::realx3x3, pFlow::HostSpace>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::int8>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::int16>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::int32>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::int64>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::uint32>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::label>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::real>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::realx3>;
-
-template class pFlow::Field<pFlow::VectorDual, pFlow::realx3x3>;
+template class pFlow::Field<pFlow::realx3>;
 
 
-template class pFlow::Field<pFlow::Vector, pFlow::word, pFlow::vecAllocator<pFlow::word>>;
-
 
diff --git a/src/phasicFlow/containers/Field/Fields.hpp b/src/phasicFlow/containers/Field/Fields.hpp
index 8b2ff92c..a0b8d192 100644
--- a/src/phasicFlow/containers/Field/Fields.hpp
+++ b/src/phasicFlow/containers/Field/Fields.hpp
@@ -24,73 +24,58 @@ Licence:
 #include "types.hpp"
 #include "Field.hpp"
 #include "VectorSingle.hpp"
-#include "VectorDual.hpp"
+//#include "VectorDual.hpp"
 
 
 namespace pFlow
 {
 
+using int8Field_D 		= Field<int8>;
 
-using int8Field_D 		= Field<VectorSingle, int8>;
+using int8Field_H 		= Field<int8, HostSpace>;
 
-using int8Field_H 		= Field<VectorSingle, int8, HostSpace>;
+using int32Field_D 		= Field<int32>;
 
-using int16Field_D 		= Field<VectorSingle, int16>;
+using int32Field_H 		= Field<int32, HostSpace>;
 
-using int16Field_H 		= Field<VectorSingle, int16, HostSpace>;
+using int64Field_D 		= Field<int64>;
 
-using int32Field_D 		= Field<VectorSingle, int32>;
+using int64Field_H 		= Field<int64, HostSpace>;
 
-using int32Field_H 		= Field<VectorSingle, int32, HostSpace>;
+using uint8Field_D     = Field<uint8>;
 
-using int64Field_D 		= Field<VectorSingle, int64>;
+using uint8Field_H     = Field<uint8, HostSpace>;
 
-using int64Field_H 		= Field<VectorSingle, int64, HostSpace>;
+using uint32Field_D 	= Field<uint32>;
 
-using uint32Field_D 	= Field<VectorSingle, uint32>;
+using uint32Field_H 	= Field<uint32, HostSpace>;
 
-using uint32Field_H 	= Field<VectorSingle, uint32, HostSpace>;
+using uint64Field_D 		= Field<uint64>;
 
-using labelField_D 		= Field<VectorSingle, label>;
+using uint64Field_H 		= Field<uint64, HostSpace> ;
 
-using labelField_H 		= Field<VectorSingle, label, HostSpace> ;
+using uint32x3Field_D   = Field<uint32x3>;
 
-using realField_D 		= Field<VectorSingle, real>;
+using uint32x3Field_H   = Field<uint32x3, HostSpace>;
 
-using realField_H 		= Field<VectorSingle, real, HostSpace> ;
+using realField_D 		= Field<real>;
 
-using realx3Field_D 	= Field<VectorSingle, realx3>;
+using realField_H 		= Field<real, HostSpace> ;
 
-using realx3Field_H 	= Field<VectorSingle, realx3, HostSpace>;
+using realx3Field_D 	= Field<realx3>;
 
-using uint16x3Field_D 	= Field<VectorSingle, uint16x3>;
+using realx3Field_H 	= Field<realx3, HostSpace>;
 
-using uint16x3Field_H 	= Field<VectorSingle, uint16x3, HostSpace>;
+using realx3x3Field_D 	= Field<realx3x3>;
 
-using uint32x3Field_D   = Field<VectorSingle, uint32x3>;
-
-using uint32x3Field_H   = Field<VectorSingle, uint32x3, HostSpace>;
-
-using int32x3Field_D 	= Field<VectorSingle, int32x3>;
-
-using int32x3Field_H 	= Field<VectorSingle, int32x3, HostSpace>;
-
-using int64x3Field_D 	= Field<VectorSingle, int64x3>;
-
-using int64x3Field_H 	= Field<VectorSingle, int64x3, HostSpace>;
-
-using realx3x3Field_D 	= Field<VectorSingle, realx3x3>;
-
-using realx3x3Field_H 	= Field<VectorSingle, realx3x3, HostSpace>;
+using realx3x3Field_H 	= Field<realx3x3, HostSpace>;
 
 // - no typedef on device (since word does not compile on CUDA)
-using wordField_H 		= Field<VectorSingle, word, HostSpace>;
+using wordField_H 		= Field<word, HostSpace>;
 
 
 // host device fields
-using int8Field_HD 		= Field<VectorDual, int8>;
-
-using int16Field_HD 	= Field<VectorDual, int16>;
+/*using int8Field_HD 		= Field<VectorDual, int8>;
 
 using int32Field_HD 	= Field<VectorDual, int32>;
 
@@ -104,20 +89,13 @@ using realField_HD 		= Field<VectorDual, real>;
 
 using realx3Field_HD 	= Field<VectorDual, realx3>;
 
-using uint16x3Field_HD 	= Field<VectorDual, uint32x3>;
-
 using uint32x3Field_HD  = Field<VectorDual, uint32x3>;
 
 using int32x3Field_HD 	= Field<VectorDual, int32x3>;
 
 using int64x3Field_HD 	= Field<VectorDual, int64x3>;
 
-using realx3x3Field_HD 	= Field<VectorDual, realx3x3>;
-
-
-using wordField 		= Field<Vector, word , vecAllocator<word>>; 
-
-
+using realx3x3Field_HD 	= Field<VectorDual, realx3x3>;*/
 
 }
 
diff --git a/src/phasicFlow/containers/List/List/List.hpp b/src/phasicFlow/containers/List/List/List.hpp
index e416ae92..ca39e1e9 100644
--- a/src/phasicFlow/containers/List/List/List.hpp
+++ b/src/phasicFlow/containers/List/List/List.hpp
@@ -49,11 +49,11 @@ public:
 
 	using iterator 		= typename listType::iterator;
 	
-	using constIterator = typename listType::const_iterator;
+	using const_iterator = typename listType::const_iterator;
 	
 	using reference 	= typename listType::reference;
 	
-	using constReference= typename listType::const_reference;
+	using const_reference= typename listType::const_reference;
 	
 	using initList 		= typename std::initializer_list<T>;
 	
@@ -62,12 +62,7 @@ public:
 
 protected:
 
-	// position of ith element
-	auto pos(size_t i);
-
-	// position of ith element 
-	const auto pos(size_t i)const;
-
+	
 	static inline size_t getListStride(const size_t& len)
 	{
 		size_t stride = 1;
@@ -86,7 +81,7 @@ protected:
 public:
 
 	// - Type info
-	TypeInfoTemplateNV("List", T);
+	TypeInfoTemplateNV11("List", T);
 
 	//// - Constructors
 
@@ -114,30 +109,19 @@ public:
 
 
 		// - copy construct
-		List(const List& src):
-			listType(src)
-		{}
+		List(const List& src) = default;
+			
 
 		// - move construct
-		List( List && mv)
-		:
-			listType(std::move(mv))
-		{}
-
+		List( List && mv) = default;
+		
 		// - copy assignment
-		ListType& operator=(const ListType& rhs)
-		{
-			listType::operator=(rhs);
-			return *this;
-		}
+		ListType& operator=(const ListType& rhs) = default;
+		
 
 		// - move assignment
-		ListType& operator=(ListType&& rhs)
-		{
-			listType::operator=(std::move(rhs));
-			return *this;
-		}	
-
+		ListType& operator=(ListType&& rhs) = default;
+		
 
 		uniquePtr<ListType> clone()const{
 			return makeUnique<ListType>(*this);
@@ -162,6 +146,12 @@ public:
 		// - size of container
 		size_t size()const;
 		
+		// position of ith element
+		auto pos(size_t i, bool noError = false);
+
+		// position of ith element 
+		const auto pos(size_t i, bool noError = false)const;
+
 		// - access to ith element
 		//   fatal exit if out of range
 		T& operator[](size_t i);
@@ -172,7 +162,7 @@ public:
 		
 		// - find the position of the first element with value val
 		//   cend() if not found
-		constIterator find(const T& val) const;
+		const_iterator find(const T& val) const;
 		
 		// - find the position of the first element with value val
 		//    end() if not found
@@ -227,9 +217,8 @@ iIstream& operator >>(iIstream& is, List<T>& lst);
 
 using int64List 	= List<int64>;
 using int32List 	= List<int32>;
-using int16List 	= List<int16>;
 using int8List 		= List<int8>;
-using labelList 	= List<label>;
+using uint64List 	= List<uint64>;
 using uint32List 	= List<uint32>;
 
 using realList 		= List<real>;
diff --git a/src/phasicFlow/containers/List/List/ListI.hpp b/src/phasicFlow/containers/List/List/ListI.hpp
index 60caf3b2..c46d3efa 100644
--- a/src/phasicFlow/containers/List/List/ListI.hpp
+++ b/src/phasicFlow/containers/List/List/ListI.hpp
@@ -21,14 +21,22 @@ Licence:
 template<typename T>
 auto pFlow::List<T>::pos
 (
-	size_t i
+	size_t i,
+	bool noError
 )
 {
 	if( i >= size() )
 	{
-		fatalErrorInFunction<<
-		"our of range access to list element. \n";
-		fatalExit;
+		if(noError)
+		{
+			return std::end(*this);
+		}
+		else
+		{
+			fatalErrorInFunction<<
+			"out of range access to list element. \n";
+			fatalExit;
+		}
 	}
 	auto iter = listType::begin();
 	std::advance(iter, i);
@@ -38,14 +46,22 @@ auto pFlow::List<T>::pos
 template<typename T>
 const auto pFlow::List<T>::pos
 (
-	size_t i
+	size_t i,
+	bool noError
 )const 
 {
 	if( i >= size() )
 	{
-		fatalErrorInFunction<<
-		"our of range access to list element. \n";
-		fatalExit;
+		if(noError)
+		{
+			return std::end(*this);
+		}
+		else
+		{
+			fatalErrorInFunction<<
+			"out of range access to list element. \n";
+			fatalExit;
+		}
 	}
 	auto iter = listType::cbegin();
 	std::advance(iter, i);
@@ -88,7 +104,7 @@ inline const T& pFlow::List<T>::operator[]
 }
 
 template<typename T>
-inline typename  pFlow::List<T>::constIterator pFlow::List<T>::find
+inline typename  pFlow::List<T>::const_iterator pFlow::List<T>::find
 (
 	const T& val
 ) const
diff --git a/src/phasicFlow/containers/List/ListPtr/ListPtr.hpp b/src/phasicFlow/containers/List/ListPtr/ListPtr.hpp
index 8d12d1a6..efe0fc50 100644
--- a/src/phasicFlow/containers/List/ListPtr/ListPtr.hpp
+++ b/src/phasicFlow/containers/List/ListPtr/ListPtr.hpp
@@ -30,7 +30,6 @@ Licence:
 #include "error.hpp"
 #include "iOstream.hpp"
 
-
 namespace pFlow
 {
 
@@ -40,8 +39,12 @@ class ListPtr
 public:
 
 	using ListPtrType 		= ListPtr<T> ; 
+	
 	using listType 			= std::list<T*>;
 
+	using iterator 			= typename listType::iterator;
+
+	using const_iterator 	= typename listType::const_iterator;
 
 	template<typename... Args>
     inline static uniquePtr<T> makeSafe(Args&&... args)
@@ -64,21 +67,21 @@ protected:
 		bool copy(const ListPtrType& src);
 
 		// - return ith pointer
-		T* ptr(label i);
+		T* ptr(size_t i);
 
 		// - return ith const poiter
-		const T* ptr(label i)const;
+		const T* ptr(size_t i)const;
 
 		// - iterator position of ith element
-		auto pos(label i);
+		auto pos(size_t i);
 		
 		// - const iterator position of ith element
-		auto pos(label i) const;
+		auto pos(size_t i) const;
 
 public:
 
 	// - Type info
-	TypeInfoTemplateNV("ListPtr", T);
+	TypeInfoTemplateNV11("ListPtr", T);
 	
 	//// - Contructors 
 
@@ -91,7 +94,7 @@ public:
 		// - a list with initial length of len
 		ListPtr(size_t len)
 		:
-			list_(len)
+			list_(len, nullptr)
 		{}
 
 		// - copy construct, create new objects out of the pointers in the src 
@@ -141,21 +144,21 @@ public:
 	//// - Methods 
 
 		// - set the ith element 
-		T* set(label i, T* ptr);
+		uniquePtr<T> set(size_t i, T* ptr);
 		
 		// - set the ith element and take the ownership from uniquePtr
-		uniquePtr<T> set(label i, uniquePtr<T>& ptr );
+		uniquePtr<T> set(size_t i, uniquePtr<T>&& ptr );
 		
 		// - create the object in-place and set the pointer in ith position
 		//   if oject creation fails, uniquePtr deletes the memeory
 		template<typename... Args>
-	    uniquePtr<T> setSafe(label i, Args&&... args);
+	    uniquePtr<T> setSafe(size_t i, Args&&... args);
 	    
 	    // - put the pointer at the end
 	    void push_back(T* ptr);
 	    
 	    // - put the pointer at the end
-	    void push_back(uniquePtr<T>& ptr);
+	    void push_back(uniquePtr<T>&& ptr);
 	    
 	    // - safely create (in-place) and put the pointer at the end
 	    template<typename... Args>
@@ -163,11 +166,11 @@ public:
 	    
 		// - access to ith element
 		//   fatalexit if out of range or nullptr    
-		T& operator[](label i);
+		T& operator[](size_t i);
 		
 		// - const access to ith element
 		//   fatalexit if out of range or nullptr    
-		const T& operator[](label i) const;
+		const T& operator[](size_t i) const;
 
 		// size of container
 	    size_t size()const;
@@ -176,15 +179,33 @@ public:
 		auto empty() const;
 
 		// release the ownership of ith pointer 
-		uniquePtr<T> release(label i);
+		uniquePtr<T> release(size_t i);
 		
 		// - clear the content of list and delete objects
 		void clear();
 		
 		// - clear the ith element
-		void clear(label i);	
+		void clear(size_t i);	
 		
-		// - clone the object 
+		iterator begin()		
+		{
+			return list_.begin();
+		}
+		
+		const_iterator begin()const
+		{
+			return list_.begin();
+		}
+
+		iterator end()
+		{
+			return list_.end();
+		}
+
+		const_iterator end()const
+		{
+			return list_.end();
+		}
 		
 };
 
diff --git a/src/phasicFlow/containers/List/ListPtr/ListPtrI.hpp b/src/phasicFlow/containers/List/ListPtr/ListPtrI.hpp
index 2d476154..77ef5a99 100644
--- a/src/phasicFlow/containers/List/ListPtr/ListPtrI.hpp
+++ b/src/phasicFlow/containers/List/ListPtr/ListPtrI.hpp
@@ -39,7 +39,7 @@ inline bool pFlow::ListPtr<T>::copy(const ListPtrType& src)
 }
 
 template<typename T>
-T* pFlow::ListPtr<T>::ptr(label i) 
+T* pFlow::ListPtr<T>::ptr(size_t i) 
 {
 
 	if(i >= size() ) return nullptr;	
@@ -53,7 +53,7 @@ T* pFlow::ListPtr<T>::ptr(label i)
 template<typename T>
 const T* pFlow::ListPtr<T>::ptr
 (
-	label i
+	size_t i
 ) const
 {
 
@@ -68,7 +68,7 @@ const T* pFlow::ListPtr<T>::ptr
 template<typename T>
 auto pFlow::ListPtr<T>::pos
 (
-	label i
+	size_t i
 )
 {
 	if(i >= size() ) 
@@ -86,7 +86,7 @@ auto pFlow::ListPtr<T>::pos
 template<typename T>
 auto pFlow::ListPtr<T>::pos
 (
-	label i
+	size_t i
 )const 
 {
 	if(i >= size() ) 
@@ -144,9 +144,9 @@ pFlow::ListPtr<T>& pFlow::ListPtr<T>::operator=
 }
 
 template<typename T>
-T* pFlow::ListPtr<T>::set
+pFlow::uniquePtr<T> pFlow::ListPtr<T>::set
 (
-	label i, T* ptr
+	size_t i, T* ptr
 )
 {
 	uniquePtr<T> uptr(ptr);
@@ -157,8 +157,8 @@ T* pFlow::ListPtr<T>::set
 template<typename T>
 pFlow::uniquePtr<T> pFlow::ListPtr<T>::set
 (
-	label i,
-	uniquePtr<T>& ptr
+	size_t i,
+	uniquePtr<T>&& ptr
 )
 {
 	if( i > size() )
@@ -171,10 +171,9 @@ pFlow::uniquePtr<T> pFlow::ListPtr<T>::set
 
 	auto iter = list_.begin();
 	std::advance(iter, i);
-	auto oldIter = iter;
+	T* oldPtr = *iter;
 	*iter = ptr.release();
-	return *oldIter;
-
+	return uniquePtr<T>(oldPtr);
 }
 
 
@@ -182,7 +181,7 @@ template<typename T>
 template<typename... Args>
 pFlow::uniquePtr<T> pFlow::ListPtr<T>::setSafe
 (
-	label i,
+	size_t i,
 	Args&&... args
 )
 {
@@ -200,7 +199,7 @@ void pFlow::ListPtr<T>::push_back
 }
 
 template<typename T>
-void pFlow::ListPtr<T>::push_back(uniquePtr<T>& ptr)
+void pFlow::ListPtr<T>::push_back(uniquePtr<T>&& ptr)
 {
 	list_.push_back( ptr.release() );
 }
@@ -216,7 +215,7 @@ void pFlow::ListPtr<T>::push_backSafe(Args&&... args)
 template<typename T>
 T& pFlow::ListPtr<T>::operator[]
 (
-	label i
+	size_t i
 )
 {
 	T* p = ptr(i);
@@ -234,7 +233,7 @@ T& pFlow::ListPtr<T>::operator[]
 template<typename T>
 const T& pFlow::ListPtr<T>::operator[]
 (
-	label i
+	size_t i
 ) const
 {
 	const T* p = ptr(i);
@@ -263,7 +262,7 @@ auto pFlow::ListPtr<T>::empty() const
 template<typename T>
 pFlow::uniquePtr<T> pFlow::ListPtr<T>::release
 (
-	label i
+	size_t i
 )
 {
 	auto p = ptr(i);
@@ -271,24 +270,30 @@ pFlow::uniquePtr<T> pFlow::ListPtr<T>::release
 	return p;
 }
 
+
+
 template<typename T>
 void pFlow::ListPtr<T>::clear()
 {
+	
+	int i =0;
 	for( auto iter = list_.begin(); iter != list_.end(); ++iter )
 	{
 		if(*iter != nullptr)
 		{
+	
 			delete *iter;
 			*iter = nullptr;
-		}
+		}	
 	}
+
 	list_.clear();
 }
 
 template<typename T>
 void pFlow::ListPtr<T>::clear
 (
-	label i
+	size_t i
 )
 {
 	T* p = ptr(i);
diff --git a/src/Interaction/interaction/interactionTypes.hpp b/src/phasicFlow/containers/List/anyList/anyList.cpp
similarity index 73%
rename from src/Interaction/interaction/interactionTypes.hpp
rename to src/phasicFlow/containers/List/anyList/anyList.cpp
index 041eddc2..c66ad975 100644
--- a/src/Interaction/interaction/interactionTypes.hpp
+++ b/src/phasicFlow/containers/List/anyList/anyList.cpp
@@ -18,28 +18,26 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __interactionTypes_hpp__
-#define __interactionTypes_hpp__
+
+#include "anyList.hpp"
 
 
-
-#include "types.hpp"
-
-
-namespace pFlow
+size_t pFlow::anyList::size()const
 {
-
-
-// always use signed types
-using CELL_INDEX_TYPE 	= int32;
-
-using ID_TYPE 			= int32;
-
-//constexpr int32 minCellIndex = largestNegative<CELL_INDEX_TYPE>();
-
-//constexpr int32 maxCellIndex = largestPositive<CELL_INDEX_TYPE>();
-
+	return anyList_.size();
 }
 
+bool pFlow::anyList::empty()const
+{
+	return size()==0;
+}
 
-#endif //__interactionTypes_hpp__
+bool pFlow::anyList::contains(const word& name)const
+{
+	return names_.search(name);
+}
+
+const pFlow::wordList& pFlow::anyList::names()const
+{
+	return names_;
+}
diff --git a/src/phasicFlow/containers/List/anyList/anyList.hpp b/src/phasicFlow/containers/List/anyList/anyList.hpp
new file mode 100644
index 00000000..b0d39405
--- /dev/null
+++ b/src/phasicFlow/containers/List/anyList/anyList.hpp
@@ -0,0 +1,248 @@
+/*------------------------------- 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 __anyList_hpp__
+#define __anyList_hpp__
+
+#include <any>
+
+#include "types.hpp"
+#include "List.hpp"
+
+
+namespace pFlow
+{
+
+
+class anyList
+{
+
+public:
+
+	using anyListType 	= List<std::any>;
+
+	using reference 	= typename anyListType::reference;
+
+	using iterator 		= typename anyListType::iterator;
+
+	using const_iterator= typename anyListType::const_iterator;
+
+
+protected:
+
+	/// Contains a list of variables with any type 
+	anyListType 	anyList_;
+
+	/// List of variable names in anyList_ 
+	wordList 		names_;
+
+	wordList 		types_;	
+
+public:
+
+	// - Type info
+	TypeInfoNV("anyList");
+
+	//// - Constructors
+
+		// All five constructors are created by compiler 
+	
+
+	//// -  Methods
+		
+		/// Size of container
+		size_t size()const;
+
+		/// Is container empty
+		bool empty()const;
+
+		/// Does container contain this variable name?
+		bool contains(const word& name)const;
+
+		/// List of varibales names
+		const wordList& names()const;
+
+		/// Create variable using constructor in-place 
+		template<typename T, typename... Args>
+		reference emplaceBack(const word& name, Args&&... args)
+		{
+			if( contains(name))
+			{
+				fatalErrorInFunction<<
+				"variable name "<< name << " already exists in the anyList."<<endl<<
+				"list of variables is "<<names_<<endl;
+				fatalExit;
+			}
+			names_.push_back(name);
+			types_.push_back(getTypeName<T>());
+			return anyList_.emplace_back( 
+				std::in_place_type<T>, 
+				std::forward<Args>(args)...);
+		}
+
+		/// Create variable using copy constructor
+		template<typename T>
+		reference emplaceBack(const word& name, const T & other)
+		{
+			if( contains(name) )
+			{
+				fatalErrorInFunction<<
+				"variable name "<< name << " already exists in the anyList."<<endl<<
+				"list of variables is "<<names_<<endl;
+				fatalExit;
+			}
+			names_.push_back(name);
+			types_.push_back(getTypeName<T>());
+			return anyList_.emplace_back(std::in_place_type<T>, other);
+		}
+
+		/// Create variable using move constructor 
+		template<typename T>
+		reference emplaceBack(const word& name, T&& other)
+		{
+			if( contains(name) )
+			{
+				fatalErrorInFunction<<
+				"variable name "<< name << " already exists in the anyList."<<endl<<
+				"list of variables is "<<names_<<endl;
+				fatalExit;
+			}
+			names_.push_back(name);
+			types_.push_back(getTypeName<T>());
+			return anyList_.emplace_back(std::in_place_type<T>, std::move(other));
+		}
+
+		/// Get the reference to variable by index
+		template<typename T>
+		T& getObject(size_t i)
+		{
+			std::any *a = &(*anyList_.pos(i));
+			if(!a->has_value())
+			{
+				fatalErrorInFunction<<
+				"any does not have a value for dereferencing. "<<
+				"index in anyList is "<<i<<"."<<endl;
+				fatalExit;
+			}
+			return *std::any_cast<T>(a);
+		}
+
+		/// Get the reference to variable by name 
+		template<typename T>
+		T& getObject(const word& name)
+		{
+			int32 i = names_.findi(name);
+			if(i == -1 )
+			{
+				fatalErrorInFunction<<
+				"variable name "<< name << " does not exist in the anyList."<<endl<<
+				"list of variables is "<<names_<<endl;
+				fatalExit;
+			}
+			std::any *a = &(*anyList_.pos(i));
+			if(!a->has_value())
+			{
+				fatalErrorInFunction<<
+				"any does not have a value for dereferencing. "<<
+				"index in anyList is "<<i<<"."<<endl;
+				fatalExit;
+			}
+			return *std::any_cast<T>(a);
+		}
+
+		/// Get the const reference to variable by name 
+		template<typename T>
+		const T& getObject(const word& name)const
+		{
+			int32 i = names_.findi(name);
+			if(i == -1 )
+			{
+				fatalErrorInFunction<<
+				"variable name "<< name << " does not exist in the anyList."<<endl<<
+				"list of variables is "<<names_<<endl;
+				fatalExit;
+			}
+			const std::any *a = &(*anyList_.pos(i));
+			if(!a->has_value())
+			{
+				fatalErrorInFunction<<
+				"any does not have a value for dereferencing. "<<
+				"index in anyList is "<<i<<"."<<endl;
+				fatalExit;
+			}
+			return *std::any_cast<const T>(a);
+		}
+
+		/// Get the const reference to object by index
+		template<typename T>
+		const T& getObject(size_t i)const
+		{
+			const std::any *a = &(*anyList_.pos(i));
+			if(!a->has_value())
+			{
+				fatalErrorInFunction<<
+				"any does not have a value for dereferencing. "<<
+				"index in anyList is "<<i<<"."<<endl;
+				fatalExit;
+			}
+			return *std::any_cast<const T>(a);
+		}
+
+		/// Get the pointer to variable by index
+		template<typename T>
+		T* getObjectPtr(size_t i)
+		{
+			if(i>= size())return nullptr;
+
+			std::any *a = &(*anyList_.pos(i));
+			if( a->has_value())
+			{
+				return std::any_cast<T>(a);	
+			}
+			else
+			{
+				return nullptr;
+			}	
+		}
+
+		/// Get the const pointer to variable by index 
+		template<typename T>
+		const T* getObjectPtr(size_t i)const
+		{
+			if(i>=size())return nullptr;
+			const std::any *a = &(*anyList_.pos(i));
+			if( a->has_value())
+			{
+				return std::any_cast<const T>(a);	
+			}
+			else
+			{
+				return nullptr;
+			}	
+		}
+			
+};
+
+
+
+} // pFlow
+
+
+#endif //__anyList_hpp__
diff --git a/src/phasicFlow/containers/Map/Map/Map.hpp b/src/phasicFlow/containers/Map/Map/Map.hpp
index 16c0b9d3..b417aa55 100644
--- a/src/phasicFlow/containers/Map/Map/Map.hpp
+++ b/src/phasicFlow/containers/Map/Map/Map.hpp
@@ -60,7 +60,7 @@ public:
 	using valueType 	= typename mapType::value_type;
 
 	// - type info 
-	TypeInfoTemplateNV("Map", Key);
+	TypeInfoTemplateNV11("Map", Key);
 
 	//// - Constructors
 
@@ -138,7 +138,7 @@ template<typename T>
 using wordMap = Map<word,T>;
 
 template<typename T>
-using labelMap = Map<label,T>;
+using uint64Map = Map<uint64,T>;
 
 template<typename T>
 using uint32Map = Map<uint32,T>;
@@ -155,7 +155,7 @@ template<typename T>
 inline iOstream& printKeys(iOstream& os, const wordMap<T> & m);
 
 template<typename T>
-inline iOstream& printKeys(iOstream& os, const labelMap<T> & m);
+inline iOstream& printKeys(iOstream& os, const uint64Map<T> & m);
 
 template<typename T>
 inline iOstream& printKeys(iOstream& os, const uint32Map<T> & m);
diff --git a/src/phasicFlow/containers/Map/Map/MapI.hpp b/src/phasicFlow/containers/Map/Map/MapI.hpp
index 7d52ea7e..7b28efcd 100644
--- a/src/phasicFlow/containers/Map/Map/MapI.hpp
+++ b/src/phasicFlow/containers/Map/Map/MapI.hpp
@@ -92,7 +92,7 @@ inline iOstream& printKeys(iOstream& os, const uint32Map<T> & m)
 }
 
 template<typename T>
-inline iOstream& printKeys(iOstream& os, const labelMap<T> & m)
+inline iOstream& printKeys(iOstream& os, const uint64Map<T> & m)
 {
 	if (m.empty())
 		return os<<"labelMap is empty"<<endl;
diff --git a/src/phasicFlow/containers/Map/MapPtr/MapPtr.hpp b/src/phasicFlow/containers/Map/MapPtr/MapPtr.hpp
index ad9dfed4..7bce67c7 100644
--- a/src/phasicFlow/containers/Map/MapPtr/MapPtr.hpp
+++ b/src/phasicFlow/containers/Map/MapPtr/MapPtr.hpp
@@ -84,7 +84,7 @@ protected:
 public:
 
 	// - type info
-	TypeInfoTemplateNV("MapPtr", Key);
+	TypeInfoTemplateNV11("MapPtr", Key);
 
 	//// Contructors 
 	
diff --git a/src/phasicFlow/containers/Map/hashMap/hashMap.hpp b/src/phasicFlow/containers/Map/hashMap/hashMap.hpp
index b6eabc69..042800f5 100644
--- a/src/phasicFlow/containers/Map/hashMap/hashMap.hpp
+++ b/src/phasicFlow/containers/Map/hashMap/hashMap.hpp
@@ -43,6 +43,8 @@ public:
 	
 	using hashmapType 	= std::unordered_map<Key, T, Hash>;
 
+	using hasher 		= typename hashmapType::hasher;
+
 	using iterator 		= typename hashmapType::iterator;
 	
 	using constIterator = typename hashmapType::const_iterator;
@@ -60,7 +62,7 @@ public:
 	using valueType 	= typename hashmapType::value_type;
 
 	
-	TypeInfoTemplateNV("hashMap", Key);
+	TypeInfoTemplateNV11("hashMap", Key);
 
 	//// - Constructors
 
@@ -75,46 +77,24 @@ public:
 		{}
 
 		// - Copy construct
-		hashMap(const hashMapType & src)
-		:
-			hashmapType(src)
-		{}
+		hashMap(const hashMapType & src) = default;
 
 		// - Move construct 
-		hashMap( hashMapType&& src)
-		:
-			hashmapType(std::move(src))
-		{}
+		hashMap( hashMapType&& src) = default;
 
 		// - Copy assignment
-		hashMapType& operator=(const hashMapType& rhs)
-		{
-			hashmapType::operator=(rhs);
-			return *this;
-		}
-
+		hashMapType& operator=(const hashMapType& rhs) = default;
+		
 		// - Move assignment
-		hashMapType& operator=(hashMapType&& rhs)
-		{
-			hashmapType::operator=( std::move(rhs));
-			return *this;
-		}
-
+		hashMapType& operator=(hashMapType&& rhs) = default;
+		
 		uniquePtr<hashMapType> clone()const
 		{
 			return makeUnique<hashMapType>(*this);
 		}
 
-		hashMapType* clonePtr()const
-		{
-			return new hashMapType(*this);
-		}	
-
-		~hashMap()
-		{
-			this->clear();
-		}
-
+		~hashMap() = default;
+	
 
 	//// - Methods	
 
@@ -140,7 +120,7 @@ template<typename T>
 using wordHashMap = hashMap<word,T>;
 
 template<typename T>
-using labelHashMap = hashMap<label,T>;
+using uint64HashMap = hashMap<uint64,T>;
 
 template<typename T>
 using uint32HashMap = hashMap<uint32,T>;
@@ -155,7 +135,7 @@ template<typename T>
 inline iOstream& printKeys(iOstream& os, const wordHashMap<T> & m);
 
 template<typename T>
-inline iOstream& printKeys(iOstream& os, const labelHashMap<T> & m);
+inline iOstream& printKeys(iOstream& os, const uint64HashMap<T> & m);
 
 template<typename T>
 inline iOstream& printKeys(iOstream& os, const uint32HashMap<T> & m);
diff --git a/src/phasicFlow/containers/Map/hashMap/hashMapI.hpp b/src/phasicFlow/containers/Map/hashMap/hashMapI.hpp
index 74e85e6d..4c45687a 100644
--- a/src/phasicFlow/containers/Map/hashMap/hashMapI.hpp
+++ b/src/phasicFlow/containers/Map/hashMap/hashMapI.hpp
@@ -80,7 +80,7 @@ inline iOstream& printKeys(iOstream& os, const wordHashMap<T> & m)
 
 
 template<typename T>
-inline iOstream& printKeys(iOstream& os, const labelHashMap<T> & m)
+inline iOstream& printKeys(iOstream& os, const uint64HashMap<T> & m)
 {
 	if (m.empty())
 		return os<<"labelHashMap is empty"<<endl;
diff --git a/src/phasicFlow/containers/Set/Set.hpp b/src/phasicFlow/containers/Set/Set.hpp
index 3b6ea999..3c619f0b 100644
--- a/src/phasicFlow/containers/Set/Set.hpp
+++ b/src/phasicFlow/containers/Set/Set.hpp
@@ -23,6 +23,8 @@ Licence:
 
 #include <set>
 
+#include "types.hpp"
+
 namespace pFlow
 {
 
@@ -30,6 +32,9 @@ namespace pFlow
 template<typename Key>
 using Set = std::set<Key,std::less<Key>,std::allocator<Key>>;
 
+using wordSet = Set<word>;
+
+
 }
 
 #endif 
diff --git a/src/phasicFlow/containers/Vector/Vector.cpp b/src/phasicFlow/containers/Vector/Vector.cpp
index 7c0c9db3..ec729fc2 100644
--- a/src/phasicFlow/containers/Vector/Vector.cpp
+++ b/src/phasicFlow/containers/Vector/Vector.cpp
@@ -19,123 +19,28 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-template<typename T, typename Allocator>
-pFlow::Vector<T, Allocator>::Vector(iIstream& is)
-{
-	readVector(is);
-}
-
-template<typename T, typename Allocator>
+/*template<typename T, typename Allocator>
 bool pFlow::Vector<T, Allocator>::readVector
 (
 	iIstream& is,
-	size_t len
+	const IOPattern& iop
 )
 {
-	
-
-	if(is.isBinary() && !std::is_same_v<T,word>)
-	{
-		this->resize(len);
-		is.read(reinterpret_cast<char*>(this->data()), this->size()*sizeof(T));	
-	}
-	else
-	{
-		this->clear();
-		is.fatalCheck(FUNCTION_NAME);
-
-		token firstToken(is);
-
-		T val{};
-		if( firstToken.isPunctuation() ) // start of vector 
-		{
-			if(firstToken != token::BEGIN_LIST)
-			{
-				warningInFunction
-				<< "expected token "<< token::BEGIN_LIST 
-				<< " but found "<< firstToken ;
-				return false;
-
-			}
-
-			token lastToken(is);
-			
-			
-			is.fatalCheck(FUNCTION_NAME);
-			
-			while 
-				( !(
-						lastToken.isPunctuation()
-	             	&& lastToken == token::END_LIST
-	             	 
-	             	) 
-	            )
-			{
-
-				is.putBack(lastToken);
-				
-				is >> val;
-				this->push_back(val);
-				
-				is >> lastToken;
-				is.fatalCheck(FUNCTION_NAME);
-			}
-
-		} else
-		{
-			warningInFunction
-			<< "expected token "<< token::BEGIN_LIST 
-			<< " but found "<< firstToken ;
-			return false;
-		}
-	}
-
-	
-
-	return true;
+	return readStdVector(is, vectorField(), iop);
 }
 
 
 template<typename T, typename Allocator>
 bool pFlow::Vector<T, Allocator>::writeVector
 (
-	iOstream& os
+	iOstream& os,
+	const IOPattern& iop
 ) const
 {
-	// start of 
-	if( os.isBinary() && !std::is_same_v<T,word>)
-	{
-		os.write(reinterpret_cast<const char*>(this->data()), this->size()*sizeof(T));
-	}
-	else
-	{
+	return writeStdVector(os, vectorField(), iop);	
+}*/
 
-		auto len = size();
-		auto stride  = getVectorStride(len);
-		os << token::BEGIN_LIST;
-		label i = 0;
-		while( i<len )
-		{
-
-			os << this->operator[](i++);
-			for(label j=0; j<stride-1 && i<len; j++ )
-			{
-				os << token::SPACE << this->operator[](i++);	
-			}
-
-		 	if(i<len)
-		 		os<< token::NL;
-		}
-	    
-	    os << token::END_LIST;
-
-	    os.check(FUNCTION_NAME);
-	}
-
-    return true;
-}
-
-template<typename T, typename Allocator>
+/*template<typename T, typename Allocator>
 bool pFlow::Vector<T, Allocator>::deleteElement_sorted
 (
 	const Vector<label>& indices
@@ -384,4 +289,4 @@ inline bool pFlow::Vector<T, Allocator>::insertSetElement
 	}
 	
 	return true;
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Vector/Vector.hpp b/src/phasicFlow/containers/Vector/Vector.hpp
index c8d354ee..6b6eda77 100644
--- a/src/phasicFlow/containers/Vector/Vector.hpp
+++ b/src/phasicFlow/containers/Vector/Vector.hpp
@@ -29,10 +29,12 @@ Licence:
 #include "error.hpp"
 #include "uniquePtr.hpp"
 #include "stdAlgorithms.hpp"
-#include "indexContainer.hpp"
+#include "span.hpp"
 #include "iOstream.hpp"
 #include "iIstream.hpp"
 
+#include "stdVectorHelper.hpp"
+
 #ifndef __RESERVE__
 #define __RESERVE__
 	struct RESERVE{};
@@ -40,7 +42,7 @@ Licence:
 
 namespace pFlow
 {
-
+ 
 
 template<typename T, typename Allocator>
 class Vector;
@@ -48,18 +50,7 @@ class Vector;
 #include "VectorFwd.hpp"
 
 
-template <class T>
-class noConstructAllocator
-    : public std::allocator<T>
-{
-public:
-    using std::allocator<T>::allocator;
 
-    template <class U, class... Args> void construct(U*, Args&&...) {}
-};
-
-template<typename T>
-using vecAllocator = std::allocator<T>;
 
 template<typename T, typename Allocator = vecAllocator<T> >
 class Vector
@@ -68,109 +59,77 @@ class Vector
 {
 public:
 	
-	typedef Vector<T, Allocator>					VectorType;
+	using VectorType 		= Vector<T, Allocator>;
 
-	typedef typename std::vector<T, Allocator>		vectorType;
+	using vectorType 		= typename std::vector<T, Allocator>;
 
-	typedef typename vectorType::iterator 			iterator;
+	using iterator 			= typename vectorType::iterator;
 	
-	typedef typename vectorType::const_iterator 	constIterator;
+	using const_iterator 	= typename vectorType::const_iterator;
 	
-	typedef typename vectorType::reference 			reference;
+	using reference 		= typename vectorType::reference;
 	
-	typedef typename vectorType::const_reference 	constReference;
+	using const_reference 	= typename vectorType::const_reference;
 	
-	typedef  T 										valueType; 		
+	using value_type 		= T; 		
 
-	typedef  T* 									pointer;
+	using pointer 			= T *;
 
-	typedef const T*  								constPointer;
+	using const_pointer 	= const T *;
 
-	typedef typename std::initializer_list<T> 		initList;
+	using init_list 		= typename std::initializer_list<T>;
 
-protected:
+private:
 
 	// - name of the vector  
 	word name_;
 
-	static inline size_t getVectorStride(const size_t& len)
-	{
-		size_t stride = 1;
-		if( len < 6 ) 		stride = len;
-		else if( len <16 )  stride = 3;
-		else if( len < 31)  stride = 2;
-		else				stride = 1;
-
-		return stride;
-	}
 
 	static constexpr bool  isHostAccessible_ = true;
 
-	constexpr static inline const char* memoerySpaceName()
-  	{
-  		return "std";
-  	}
+	
   	
 
 public:
 
 	// - Type info
-	TypeInfoTemplateNV2("Vector", T, memoerySpaceName());
+	TypeInfoTemplateNV111("Vector", T, memoerySpaceName());
 
 	//// - Constructors
 
-		// - empty Vector
+		/// Empty Vector
 		inline Vector()
 		:
 			Vector("Vector")
 		{}
 
-		inline Vector(const word& name)
+
+		/// Empty Vector with a name 
+		inline 
+		explicit Vector(const word& name)
 		:
 			name_(name)
 		{}
-		// - with sepcified length
-		inline Vector(const size_t len)
-		:
-			Vector("Vector",len)
-		{}
 
-		// - with specified length and name
-		inline Vector(const word& name, size_t len)
+		
+		/// Vector with specified length and name
+		inline 
+		Vector(const word& name, size_t len)
 		:
 			vectorType(len),
 			name_(name)
-		{
-			
-		}
-
-		// - with length and value
-		inline Vector(size_t len, const T& val)
-		:
-			Vector("Vector", len, val)
 		{}
 
-		inline Vector(const word& name, size_t len, const T& val)
+		/// Vector with name, length and value
+		inline 
+		Vector(const word& name, size_t len, const T& val)
 		:
 			Vector(name, len)
 		{
 			this->assign(len, val);
 		}
 
-		// - zero length with specified capacity, use Logical
-		//   to make it different from previous constructor.
-		inline Vector(const size_t cap, RESERVE ):
-			Vector("Vector", cap, 0, RESERVE())
-		{
-		}
-
-		inline Vector(const size_t cap, const size_t len, RESERVE )
-		:
-			Vector("Vector", cap, len, RESERVE())
-		{
-			
-		}
-
+		/// Vector with name, size and reserved capacity 
 		Vector(const word& name, size_t cap, size_t len, RESERVE ):
 			name_(name)
 		{
@@ -178,142 +137,253 @@ public:
 			this->resize(len);
 		}
 
-		inline Vector(const size_t cap, const size_t len, const T& val, RESERVE )
-		{
-			name_ = "Vector";
-			reserve(cap);
-			this->assign(len, val);
-		}
 
-
-		// from initializer list 
-		inline Vector(const initList &l)
+		/// Vector from name and initializer list 
+		inline 
+		Vector(const word& name, const init_list &l)
 		:
-			vectorType(l)
+			vectorType(l),
+			name_(name)
 		{}
 
-		// - from src and a new name
-		inline Vector(const word name, const Vector<T>& src):
+		/// Construct with a name and form std::vector (host memory)
+		inline Vector(const word& name, const vectorType& src)
+		:
 			vectorType(src),
 			name_(name)
 		{}
 
-		// copy construct 
-		inline Vector(const VectorType& src) = default;
-		
-		// move construct 
-		inline Vector( VectorType && mv) = default;
-
-		inline Vector(const vectorType& src)
+		/// Construct with a name and form std::vector (host memory)
+		/// and with a desired capacity. 
+		inline Vector(const word& name, const vectorType& src, size_t cap)
 		:
-			vectorType(src),
-			name_("Vector")
+			Vector(name, cap, src.size(), RESERVE())
 		{
-			
+			this->assign(src.begin(), src.end());
 		}
-		
-		// copy assignment
+
+		/// Copy construct 
+		inline Vector(const VectorType& src) = default;
+
+		/// Copy from src with a new name 
+		inline Vector(const word& name, const Vector<T>& src):
+			vectorType(src),
+			name_(name)
+		{}
+
+		/// Copy assignment
 		inline VectorType& operator=( const VectorType& rhs ) = default;
 
+		/// Copy assignment from std::vector 
 		inline VectorType& operator=(const vectorType& rhs)
 		{
 			Vector::assign(rhs.begin(), rhs.end());
 			return *this;
 		}
-		
-		// move assignment 
-		inline VectorType& operator=( VectorType && mv) = default;
+
+		/// Move construct 
+		Vector( VectorType && mv) noexcept= default;
 	
-		// scalar assignment 
+		/// Move assignment 
+		VectorType& operator=( VectorType && mv)noexcept = default;
+	
+		/// Scalar assignment 
 		inline void operator=(const T& val)
 		{
 			fill(val);
 		}
 
-		inline ~Vector()
-		{
-			vectorType::clear();
-		}
+		/// Destructor 
+		~Vector() = default;
+		
 
+		/// Clone as a uniquePtr
 		inline uniquePtr<VectorType> clone() const
 		{
 			return makeUnique<VectorType>(*this);
 		}
 
+		/// Clone as a pointer 
 		inline VectorType* clonePtr()const
 		{
-			return new VectorType(*this);
+			uniquePtr<VectorType> Ptr = makeUnique<VectorType>(*this);
+			return Ptr.release();
 		}
 
-	inline auto clear()
+	
+	//// - Methods 
+
+		/// Access to this, mostly used by derived classes 
+		const VectorType& VectorField() const
+		{
+			return *this;
+		}
+	 
+		VectorType& VectorField()
+		{
+			return *this;
+		}
+
+		const vectorType& vectorField()const
+		{
+			return *this;
+		}
+
+		vectorType& vectorField()
+		{
+			return *this;
+		}
+
+		auto& deviceVectorAll()
+		{
+			return *this;
+		}
+
+		const auto& deviceVectorAll()const
+		{
+			return *this;
+		}
+
+		auto& deviceVector()
+		{
+			return *this;
+		}
+
+		const auto& deviceVector()const
+		{
+			return *this;
+		}
+
+
+		/// Name of the vector 
+		const word& name()const
+		{
+			return name_;
+		}
+
+		/// Size of the vector 
+		inline auto size()const
+		{
+			return vectorType::size();
+		}
+
+		/// Capacity of the vector 
+		inline auto capacity()const
+		{
+			return vectorType::capacity();
+		}
+
+		/// If vector is empty 
+		inline bool empty()const
+		{
+			return vectorType::empty();
+		}
+
+		/// Reserve capacity for vector 
+		/// Preserve the content.
+		inline void reserve(size_t cap)
+		{
+			vectorType::reserve(cap);
+		}
+
+		// - fill the whole content of vector, [begin, end), with val 
+		void fill( const T& val);
+
+		/// fill the content in range [start, end)
+		void fill( uint32 start, uint32 end, const T& val);
+
+		inline
+		auto getSpan()
+		{
+			return span<T>(this->data(), this->size());
+		}
+		
+		inline 
+		auto getSpan()const
+		{
+			return span<T>(const_cast<T*>(this->data()), this->size());
+		}
+
+		static constexpr bool isHostAccessible()
+		{
+			return isHostAccessible_;
+		}
+
+	void operator +=( const T& val);
+	void operator -=( const T& val);
+	void operator *=( const T& val);
+	void operator /=( const T& val);
+
+	void operator +=( const VectorType& v );
+	void operator -=( const VectorType& v );
+	void operator /=( const VectorType& v );
+	void operator *=( const VectorType& v );
+
+	VectorType operator -()const;
+
+	bool read(iIstream& is)
 	{
-		return vectorType::clear();
+		return readStdVector(is, vectorField());
+	}
+	bool write(iOstream& os)const
+	{
+		return writeStdVector(os, vectorField());
 	}
 
-	// access to this, mostly used by derived classes 
-	const VectorType& VectorField() const
+	bool read(iIstream& is, const IOPattern& iop)
 	{
-		return *this;
-	}
- 
-	VectorType& VectorField()
-	{
-		return *this;
+		return readStdVector(is, vectorField(), iop);
 	}
 
-	const vectorType& vectorField()const
+	bool write(iOstream& os, const IOPattern& iop)const
 	{
-		return *this;
+		return writeStdVector(os, vectorField(), iop);
 	}
 
-	vectorType& vectorField()
+	static
+	constexpr const char* memoerySpaceName()
+  	{
+  		return "std";
+  	}
+};
+
+
+template<typename T, typename Allocator>
+inline iIstream& operator >> (iIstream & is, Vector<T, Allocator> & ivec )
+{
+	if( !ivec.read(is) )
 	{
-		return *this;
+		ioErrorInFile (is.name(), is.lineNumber());
+		fatalExit;
 	}
+	return is;
+}
 
-	auto& deviceVectorAll()
+template<typename T, typename Allocator> 
+inline iOstream& operator << (iOstream& os, const Vector<T, Allocator>& ovec )
+{	
+	if( !ovec.write(os) )
 	{
-		return *this;
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
 	}
+	return os; 
+}
 
-	const auto& deviceVectorAll()const
-	{
-		return *this;
-	}
 
-	auto& deviceVector()
-	{
-		return *this;
-	}
+} // pFlow
 
-	const auto& deviceVector()const
-	{
-		return *this;
-	}
+
+#include "VectorI.hpp"
+#include "Vector.cpp"
+#include "VectorMath.hpp"
+#include "VectorAlgorithm.hpp"
+
+#endif
 
 
 
-	const word& name()const
-	{
-		return name_;
-	}
-
-	inline auto size()const
-	{
-		return vectorType::size();
-	}
-
-	inline auto capacity()const
-	{
-		return vectorType::capacity();
-	}
-
-	inline auto reserve(label len)
-	{
-		return vectorType::reserve(len);
-	}
-
-	// - delete elemens of vector based on sorted indices 
+	/*// - delete elemens of vector based on sorted indices 
 	//   return false if out of range
 	bool deleteElement_sorted(const Vector<label>& indices );
 
@@ -346,83 +416,4 @@ public:
 
 	// - set or insert a new element into the vecor 
 	//   return false if it fails 
-	inline bool insertSetElement(int32 idx, const T& val);
-
-	// - fill the whole content of vector, [begin, end), with val 
-	inline void fill( const T& val);
-
-	static constexpr bool isHostAccessible()
-	{
-		return isHostAccessible_;
-	}
-
-	inline void operator +=( const T& val);
-	inline void operator -=( const T& val);
-	inline void operator *=( const T& val);
-	inline void operator /=( const T& val);
-
-	inline void operator +=( const VectorType& v );
-	inline void operator -=( const VectorType& v );
-	inline void operator /=( const VectorType& v );
-	inline void operator *=( const VectorType& v );
-
-	inline VectorType operator -()const;
-
-	// from iIstream and specified size 
-	//Vector(iIstream & is, size_t len);
-
-	// from iIstream and free size
-	Vector(iIstream& is);
-
-	bool readVector(iIstream& is, size_t len=0);
-
-	bool writeVector(iOstream& os) const;
-
-	bool read(iIstream& is)
-	{
-		return readVector(is);
-	}
-
-	bool write(iOstream& os)const
-	{
-		return writeVector(os);
-	}
-
-};
-
-
-template<typename T, typename Allocator>
-inline iIstream& operator >> (iIstream & is, Vector<T, Allocator> & ivec )
-{
-	if( !ivec.readVector(is) )
-	{
-		ioErrorInFile (is.name(), is.lineNumber());
-		fatalExit;
-	}
-	return is;
-}
-
-template<typename T, typename Allocator> 
-inline iOstream& operator << (iOstream& os, const Vector<T, Allocator>& ovec )
-{
-	
-	if( !ovec.writeVector(os) )
-	{
-		ioErrorInFile(os.name(), os.lineNumber());
-		fatalExit;
-	}
-
-	return os; 
-}
-
-
-
-} // pFlow
-
-
-#include "VectorI.hpp"
-#include "Vector.cpp"
-#include "VectorMath.hpp"
-#include "VectorAlgorithm.hpp"
-
-#endif
+	inline bool insertSetElement(int32 idx, const T& val);*/
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Vector/VectorI.hpp b/src/phasicFlow/containers/Vector/VectorI.hpp
index 6bacd5dd..38c7a5fd 100644
--- a/src/phasicFlow/containers/Vector/VectorI.hpp
+++ b/src/phasicFlow/containers/Vector/VectorI.hpp
@@ -1,3 +1,4 @@
+#include "Vector.hpp"
 /*------------------------------- phasicFlow ---------------------------------
       O        C enter of
      O O       E ngineering and
@@ -24,9 +25,17 @@ inline void pFlow::Vector<T, Allocator>::fill( const T& val)
 	std::fill(this->begin(), this->end(), val);
 }
 
+template <typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::fill(uint32 start, uint32 end, const T &val)
+{
+	
+	for(uint32 i=start; i<end; i++)
+	{
+		this->at(i) = val;
+	}
+}
 #pragma hd_warning_disable 
-template<typename T, typename Allocator>
-inline void pFlow::Vector<T, Allocator>::operator +=( const T& val)
+template < typename T, typename Allocator> inline void pFlow::Vector < T, Allocator> ::operator+= (const T &val)
 {
 	for( auto& v:(*this) )
 	{
@@ -77,7 +86,7 @@ inline void pFlow::Vector<T, Allocator>::operator +=( const Vector<T, Allocator>
 		fatalExit;
 	}
 
-	for(label i=0; i<v.size(); i++)
+	for(size_t i=0; i<v.size(); i++)
 	{
 		this->operator[](i) += v[i];
 	}
@@ -96,7 +105,7 @@ inline void pFlow::Vector<T, Allocator>::operator -=( const Vector<T, Allocator>
 		fatalExit;
 	}
 
-	for(label i=0; i<v.size(); i++)
+	for(size_t i=0; i<v.size(); i++)
 	{
 		this->operator[](i) -= v[i];
 	}
@@ -115,7 +124,7 @@ inline void pFlow::Vector<T, Allocator>::operator *=( const Vector<T, Allocator>
 		fatalExit;
 	}
 
-	for(label i=0; i<v.size(); i++)
+	for(size_t i=0; i<v.size(); i++)
 	{
 		this->operator[](i) *= v[i];
 	}
@@ -134,7 +143,7 @@ inline void pFlow::Vector<T, Allocator>::operator /=( const Vector<T, Allocator>
 		fatalExit;
 	}
 
-	for(label i=0; i<v.size(); i++)
+	for(size_t i=0; i<v.size(); i++)
 	{
 		this->operator[](i) /= v[i];
 	}
diff --git a/src/phasicFlow/containers/Vector/VectorMath.hpp b/src/phasicFlow/containers/Vector/VectorMath.hpp
index 22c7087d..153fdfff 100644
--- a/src/phasicFlow/containers/Vector/VectorMath.hpp
+++ b/src/phasicFlow/containers/Vector/VectorMath.hpp
@@ -18,12 +18,14 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
+namespace pFlow
+{
 
 #define VecFunc(fnName) 									\
 template<typename T, typename Allocator>										\
-inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T,Allocator>& v)	\
+inline Vector<T, Allocator> fnName(const Vector<T,Allocator>& v)	\
 {															\
-	Vector<T, Allocator> res(v.capacity(), Logical());		\
+	Vector<T, Allocator> res(v.name(), v.capacity(), 0 ,RESERVE());		\
 	for(auto& e:v)											\
 	{														\
 		res.push_back( fnName(e) );							\
@@ -31,10 +33,10 @@ inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T,Allocator>& v)	\
 	return std::move(res);									\
 }															\
 template<typename T, typename Allocator, typename indexFunc>					\
-inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T, Allocator>& v, indexFunc iFn) 	\
+inline Vector<T, Allocator> fnName(const Vector<T, Allocator>& v, indexFunc iFn) 	\
 {																		\
-	Vector<T, Allocator> res(v.capacity(), Logical());								\
-	for(label i=0; i<v.size(); i++)										\
+	Vector<T, Allocator> res(v.name(), v.capacity(), 0, RESERVE());								\
+	for(size_t i=0; i<v.size(); i++)										\
 	{																	\
 		if( iFn(i) )													\
 			res.push_back(fnName(v[i]));								\
@@ -46,20 +48,20 @@ inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T, Allocator>& v,
 
 #define VecFunc2(fnName) 									\
 template<typename T, typename Allocator>										\
-inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T, Allocator>& v1, const Vector<T, Allocator>& v2)	\
+inline Vector<T, Allocator> fnName(const Vector<T, Allocator>& v1, const Vector<T, Allocator>& v2)	\
 {															\
-	Vector<T, Allocator> res(v1.capacity(), Logical());					\
-	for(label i=0; i<v1.size(); i++)							\
+	Vector<T, Allocator> res(v1.name(), v1.capacity(), 0 ,RESERVE());					\
+	for(size_t i=0; i<v1.size(); i++)							\
 	{														\
 		res.push_back( fnName(v1[i], v2[i]));				\
 	}														\
 	return std::move(res);									\
 }															\
 template<typename T, typename Allocator, typename indexFunc>					\
-inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T, Allocator>& v1, const Vector<T, Allocator>& v2, indexFunc iFn) 	\
+inline Vector<T, Allocator> fnName(const Vector<T, Allocator>& v1, const Vector<T, Allocator>& v2, indexFunc iFn) 	\
 {																		\
-	Vector<T, Allocator> res(v1.capacity(), Logical());							\
-	for(label i=0; i<v1.size(); i++)									\
+	Vector<T, Allocator> res(v1.name(), v1.capacity(), 0 ,RESERVE());							\
+	for(size_t i=0; i<v1.size(); i++)									\
 	{																	\
 		if( iFn(i) )													\
 			res.push_back(fnName(v1[i], v2[i]));						\
@@ -77,6 +79,8 @@ inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T, Allocator>& v1,
 // min, max
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+
+
 VecFunc(abs);
 VecFunc2(mod);
 VecFunc(exp);
@@ -100,6 +104,9 @@ VecFunc(acosh);
 VecFunc(atanh);
 
 #undef VecFunc
+}
+
+
 
 //// special implementation of math functions 
 namespace pFlow
@@ -108,7 +115,7 @@ namespace pFlow
 template<typename T, typename Allocator>
 inline Vector<T, Allocator> pow(const Vector<T, Allocator>& v, T e)
 {
-	Vector<T, Allocator> res(v.capacity(), Logical());
+	Vector<T, Allocator> res(v.name(), v.capacity(), 0 ,RESERVE());
 	for(auto& elm:v)
 	{
 		res.push_back(pow(elm,e));
@@ -119,8 +126,8 @@ inline Vector<T, Allocator> pow(const Vector<T, Allocator>& v, T e)
 template<typename T, typename Allocator, typename indexFunc>
 inline Vector<T,Allocator> pow(const Vector<T,Allocator>& v, T e, indexFunc iFn)
 {
-	Vector<T, Allocator> res(v.capacity(), Logical());
-	for(label i=0; i<v.size(); i++)
+	Vector<T, Allocator> res(v.name(), v.capacity(), 0 ,RESERVE());
+	for(size_t i=0; i<v.size(); i++)
 	{
 		if(iFn(i))
 		{
@@ -149,7 +156,7 @@ template<typename T, typename Allocator, typename indexFunc>
 inline T min(const Vector<T, Allocator>& v, indexFunc iFn)
 {
 	T minVal(largestPositive<T>());
-	for(label i=0; i<v.size(); i++)
+	for(size_t i=0; i<v.size(); i++)
 	{
 		if(iFn(i))
 		{
@@ -175,7 +182,7 @@ template<typename T, typename Allocator ,typename indexFunc>
 inline T max(const Vector<T, Allocator>& v, indexFunc iFn)
 {
 	T maxVal(largestNegative<T>());
-	for(label i=0; i<v.size(); i++)
+	for(size_t i=0; i<v.size(); i++)
 	{
 		if(iFn(i))
 		{
@@ -201,7 +208,7 @@ template<typename T, typename Allocator, typename indexFunc>
 inline T sum(const Vector<T, Allocator>& v, indexFunc iFn)
 {
 	T s = static_cast<T>(0);
-	for(label i=0; i<v.size(); ++i)
+	for(size_t i=0; i<v.size(); ++i)
 	{
 		if(iFn(i))
 			s += v[i];
diff --git a/src/phasicFlow/containers/Vector/Vectors.cpp b/src/phasicFlow/containers/Vector/Vectors.cpp
index dd958b08..d8f2dc05 100644
--- a/src/phasicFlow/containers/Vector/Vectors.cpp
+++ b/src/phasicFlow/containers/Vector/Vectors.cpp
@@ -20,27 +20,4 @@ Licence:
 
 #include "Vectors.hpp"
 
-// instantiation just for numeral types 
-template class pFlow::Vector<pFlow::int8>;
-
-template class pFlow::Vector<pFlow::int16>;
-
-template class pFlow::Vector<pFlow::int32>;
-
-template class pFlow::Vector<pFlow::int64>;
-
-template class pFlow::Vector<pFlow::uint32>;
-
-template class pFlow::Vector<pFlow::label>;
-
-template class pFlow::Vector<pFlow::real>;
-
-template class pFlow::Vector<pFlow::realx3>;
-
-template class pFlow::Vector<pFlow::realx3x3>;
-
-//template class pFlow::Vector<pFlow::word>;
-
- 
-
 
diff --git a/src/phasicFlow/containers/Vector/Vectors.hpp b/src/phasicFlow/containers/Vector/Vectors.hpp
index 8eba5863..ff1c1db7 100644
--- a/src/phasicFlow/containers/Vector/Vectors.hpp
+++ b/src/phasicFlow/containers/Vector/Vectors.hpp
@@ -31,69 +31,27 @@ namespace pFlow
 
 using int8Vector 	= Vector<int8>;
 
-using int16Vector 	= Vector<int16>;
-
 using int32Vector 	= Vector<int32>;
 
 using int64Vector 	= Vector<int64>;
 
-using uint32Vector 	= Vector<uint32>;
+using uint8Vector  = Vector<uint8>;
 
-using labelVector 	= Vector<label>;
+using uint32Vector   = Vector<uint32>;
+
+using uint64Vector   = Vector<uint64>;
+
+using uint32x3Vector = Vector<uint32x3>;
 
 using realVector 	= Vector<real> 	;
 
 using realx3Vector 	= Vector<realx3>;
 
-using uint16x3Vector= Vector<uint16x3>;
-
-using uint32x3Vector= Vector<uint32x3>;
-
-using int32x3Vector = Vector<int32x3>;
-
-using int64x3Vector = Vector<int64x3>;
-
-using uint16x3x3Vector 	= Vector<uint16x3x3>;
-
-using uint32x3x3Vector 	= Vector<uint32x3x3>;
-
-using int32x3x3Vector 	= Vector<int32x3x3>;
-
 using realx3x3Vector 	= Vector<realx3x3>;
 
 using wordVector 		= Vector<word>;
 
-/*template<>
-inline word Vector<label>::TYPENAME() { return "labelVector"; }
-typedef Vector<label> 	labelVector;
 
-template<>
-inline word Vector<real>::TYPENAME() { return "realVector"; }
-typedef Vector<real> 	realVector;
-
-template<>
-inline word Vector<unit3>::TYPENAME() { return "unit3Vector"; }
-typedef Vector<unit3> 	unit3Vector;
-
-template<>
-inline word Vector<real3>::TYPENAME() { return "real3Vector"; }
-typedef Vector<real3>	real3Vector;
-
-template<>
-inline word Vector<real33>::TYPENAME() { return "real33Vector"; }
-typedef Vector<real33>	real33Vector;
-
-template<>
-inline word Vector<bool>::TYPENAME() { return "boolVector"; }
-typedef Vector<bool> 	boolVector;
-
-template<>
-inline word Vector<word>::TYPENAME() { return "wordVector"; }
-typedef Vector<word> 	wordVector;
-
-template<>
-inline word Vector<sint>::TYPENAME() { return "sintVector"; }
-typedef Vector<sint> 	sintVector;*/
 
 }
 
diff --git a/src/phasicFlow/containers/Vector/stdVectorHelper.hpp b/src/phasicFlow/containers/Vector/stdVectorHelper.hpp
new file mode 100644
index 00000000..210ea048
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/stdVectorHelper.hpp
@@ -0,0 +1,187 @@
+/*------------------------------- 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 __stdVectorHelper_hpp__
+#define __stdVectorHelper_hpp__
+
+#include <vector>
+#include <algorithm>
+
+#include "span.hpp"
+#include "iOstream.hpp"
+#include "iIstream.hpp"
+#include "createDataIO.hpp"
+#include "pFlowProcessors.hpp"
+
+namespace pFlow
+{
+ 
+
+template <class T>
+class noConstructAllocator
+    : public std::allocator<T>
+{
+public:
+    using std::allocator<T>::allocator;
+
+    template <class U, class... Args> void construct(U*, Args&&...) {}
+};
+
+template<typename T>
+using vecAllocator = std::allocator<T>;
+
+template<typename T>
+inline
+span<T> makeSpan(std::vector<T>& container)
+{
+    return span<T>(container.data(), container.size());
+}
+
+template<typename T>
+inline
+span<T> makeSpan(const std::vector<T>& container)
+{
+    return span<T>(
+		const_cast<T*>(container.data()), 
+		container.size());
+}
+
+
+template<typename T>
+inline
+bool writeSpan(
+    iOstream& os, 
+    span<T> sp)
+{
+	return writeDataAsciiBinary(os, sp);
+}
+
+template<typename T>
+inline
+bool writeSpan(
+    iOstream& os, 
+    span<T> sp, 
+    const IOPattern& iop)
+{
+   
+   auto ioPtr = createDataIO<T>(pFlowProcessors().localRunTypeName(), iop);
+    
+   if(!ioPtr)
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+   if(!ioPtr().writeData(os, sp))
+   {
+   		fatalErrorInFunction;
+   		return false;
+   }
+    return true; 
+}
+
+template<typename T, typename Allocator>
+bool writeStdVector
+(
+	iOstream& os, 
+	const std::vector<T,Allocator>& vec
+)
+{
+	auto sp = makeSpan(vec);
+	return writeSpan(os, sp);
+}
+
+template<typename T, typename Allocator>
+bool writeStdVector
+(
+	iOstream& os, 
+	const std::vector<T,Allocator>& vec,
+	const IOPattern& iop 
+)
+{
+	auto sp = makeSpan(vec);
+	return writeSpan(os, sp, iop);
+}
+
+template<typename T, typename Allocator>
+bool readStdVector
+(
+	iIstream& is, 
+	std::vector<T,Allocator>& vec
+)
+{
+
+	return readDataAsciiBinary(is, vec);
+	
+}
+
+template<typename T, typename Allocator>
+bool readStdVector
+(
+	iIstream& is, 
+	std::vector<T,Allocator>& vec,
+	const IOPattern& iop 
+)
+{
+	auto ioPtr = createDataIO<T>(pFlowProcessors().localRunTypeName(), iop);
+
+	if(!ioPtr)
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+	if(!ioPtr().readData(is, vec))
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+	return true;
+	
+}
+
+template<typename T, typename Allocator>
+iOstream& operator<<( iOstream& os, const std::vector<T,Allocator>& vec)
+{
+	if(!writeStdVector(os, vec))
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+	return os;
+}
+
+/// Always assume ASCII is in the input stream 
+template<typename T, typename Allocator>
+iIstream& operator>>(iIstream& is, std::vector<T,Allocator>& vec)
+{
+	if( !readStdVector(is,vec))
+	{
+		fatalErrorInFunction;
+		fatalExit;
+	}
+	return is;
+}
+
+} // pFlow
+
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/containers/VectorHD/VectorDual.hpp b/src/phasicFlow/containers/VectorHD/VectorDual.hpp
index aa39549e..407c10e5 100644
--- a/src/phasicFlow/containers/VectorHD/VectorDual.hpp
+++ b/src/phasicFlow/containers/VectorHD/VectorDual.hpp
@@ -259,8 +259,8 @@ public:
 				dualView_.clear_sync_state();
 			}
 
-			Kokkos::deep_copy(hostVector(), src.hostVector());
-			Kokkos::deep_copy(deviceVector(), src.deviceVector());
+			Kokkos::deep_copy(hostView(), src.hostView());
+			Kokkos::deep_copy(deviceView(), src.deviceView());
 		}
 
 		// copy construct with new name 
@@ -280,8 +280,8 @@ public:
 				dualView_.clear_sync_state();
 			}
 
-			Kokkos::deep_copy(hostVector(), src.hostVector());
-			Kokkos::deep_copy(deviceVector(), src.deviceVector());
+			Kokkos::deep_copy(hostView(), src.hostView());
+			Kokkos::deep_copy(deviceView(), src.deviceView());
 		}
 
 		// - copy assignment 
@@ -332,53 +332,53 @@ public:
 		}
 
 		// - Device vector
-		INLINE_FUNCTION_H deviceViewType& deviceVectorAll(){
+		INLINE_FUNCTION_H deviceViewType& deviceViewAll(){
 			return dualView_.d_view;
 		}
 
 		// - Device vector 
-		INLINE_FUNCTION_H const deviceViewType& deviceVectorAll() const {
+		INLINE_FUNCTION_H const deviceViewType& deviceViewAll() const {
 			return dualView_.d_view;
 		}
 
 		// - Host vector
-		INLINE_FUNCTION_H hostViewType& hostVectorAll(){
+		INLINE_FUNCTION_H hostViewType& hostViewAll(){
 			return dualView_.h_view;
 		}
 
 		// - Host Vector
-		INLINE_FUNCTION_H const hostViewType& hostVectorAll() const {
+		INLINE_FUNCTION_H const hostViewType& hostViewAll() const {
 			return dualView_.h_view;
 		}
 
-		INLINE_FUNCTION_H deviceViewType& deviceVector(){
+		INLINE_FUNCTION_H deviceViewType& deviceView(){
 			updateSubViews();
 			return deviceSubView_;
 		}
 
-		INLINE_FUNCTION_H const deviceViewType& deviceVector() const{
+		INLINE_FUNCTION_H const deviceViewType& deviceView() const{
 			updateSubViews();
 			return deviceSubView_;
 		}
 
-		INLINE_FUNCTION_H hostViewType& hostVector(){
+		INLINE_FUNCTION_H hostViewType& hostView(){
 			updateSubViews();
 			return hostSubView_;
 		}
 
-		INLINE_FUNCTION_H const hostViewType& hostVector()const{
+		INLINE_FUNCTION_H const hostViewType& hostView()const{
 			updateSubViews();
 			return hostSubView_;
 		}
 
 		INLINE_FUNCTION_H
-		hostViewType hostVector(int32 start, int32 end)const
+		hostViewType hostView(int32 start, int32 end)const
 		{
 			return Kokkos::subview(dualView_.h_view, Kokkos::make_pair(start,end));
 		}
 
 		INLINE_FUNCTION_H
-		deviceViewType deviceVector(int32 start, int32 end)const
+		deviceViewType deviceView(int32 start, int32 end)const
 		{
 			return Kokkos::subview(dualView_.d_view, Kokkos::make_pair(start,end));
 		}
@@ -455,22 +455,22 @@ public:
 		INLINE_FUNCTION_H void fill(const T& val)
 		{
 			if(empty())return;
-			Kokkos::deep_copy(deviceVector(),val);
-			Kokkos::deep_copy(hostVector(),val);
+			Kokkos::deep_copy(deviceView(),val);
+			Kokkos::deep_copy(hostView(),val);
 			dualView_.clear_sync_state();
 		}
 
 		INLINE_FUNCTION_H void fillHost(const T& val)
 		{
 			if(empty())return;
-			Kokkos::deep_copy(hostVector(),val);
+			Kokkos::deep_copy(hostView(),val);
 			modifyOnHost();
 		}
 
 		INLINE_FUNCTION_H void fillDevice(const T& val)
 		{
 			if(empty())return;
-			Kokkos::deep_copy(deviceVector(),val);
+			Kokkos::deep_copy(deviceView(),val);
 			modifyOnDevice();
 		}
 
@@ -556,7 +556,7 @@ public:
 			size_t newSize = indices.size();
 
 			deviceViewType 	sortedView("sortedView", newSize);
-			auto dVec = deviceVectorAll();
+			auto dVec = deviceViewAll();
 
 			auto d_indices = indices.deviceView();
 			
@@ -570,7 +570,7 @@ public:
 			
 			Kokkos::fence();
 			setSize(newSize);
-			copy(deviceVector(), sortedView);
+			copy(deviceView(), sortedView);
 			modifyOnDevice();
 			syncViews();
 		}
@@ -586,10 +586,10 @@ public:
 			{
 				resize(maxInd+1);
 			} 
-			fillSelected(hostVectorAll(), indices.hostView(), indices.size(), val);
+			fillSelected(hostViewAll(), indices.hostView(), indices.size(), val);
 			
 			auto dIndices = indices.deviceView();
-			auto dVals = deviceVectorAll();
+			auto dVals = deviceViewAll();
 
 			Kokkos::parallel_for(
 				"fillSelected",
@@ -627,10 +627,10 @@ public:
 			{
 
 				hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
-				//fillSelected(hostVector(), indices.hostView(), hVecVals, indices.size());
+				//fillSelected(hostView(), indices.hostView(), hVecVals, indices.size());
 
 				pFlow::algorithms::KOKKOS::fillSelected<T, int32, DefaultHostExecutionSpace>(
-					hostVectorAll().data(),
+					hostViewAll().data(),
 					indices.hostView().data(),
 					hVecVals.data(),
 					indices.size());
@@ -648,9 +648,9 @@ public:
 				Kokkos::deep_copy(dVecVals, hVecVals);
 				
 
-				//fillSelected(deviceVector(), indices.deviceView(), dVecVals, indices.size());
+				//fillSelected(deviceView(), indices.deviceView(), dVecVals, indices.size());
 				pFlow::algorithms::KOKKOS::fillSelected<T, int32, execution_space>(
-					deviceVectorAll().data(),
+					deviceViewAll().data(),
 					indices.deviceView().data(),
 					dVecVals.data(),
 					indices.size());
@@ -683,7 +683,7 @@ public:
 			if constexpr (std::is_same<side,HostSide>::value )
 			{
 				hostViewType1D<int32> hVecInd( const_cast<int32*>(indices.data()), indices.size());
-				fillSelected( hostVectorAll(), hVecInd, indices.size(), val);
+				fillSelected( hostViewAll(), hVecInd, indices.size(), val);
 
 				modifyOnHost();
 				syncViews(minInd, maxInd+1);
@@ -696,7 +696,7 @@ public:
 				hostViewType1D<int32> hVecInd( const_cast<int32*>(indices.data()), indices.size());
 				deviceViewType1D<int32> dVecInd("dVecInd", indices.size());
 				Kokkos::deep_copy(dVecInd, hVecInd);
-				fillSelected(deviceVectorAll(), dVecInd, indices.size(), val);
+				fillSelected(deviceViewAll(), dVecInd, indices.size(), val);
 				
 				modifyOnDevice();
 
@@ -734,7 +734,7 @@ public:
 				hostViewType1D<int32> hVecInd( const_cast<int32*>(indices.data()), indices.size());
 				hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
 
-				fillSelected(hostVectorAll(), hVecInd, hVecVals, indices.size());
+				fillSelected(hostViewAll(), hVecInd, hVecVals, indices.size());
 
 				modifyOnHost();
 			
@@ -752,7 +752,7 @@ public:
 				Kokkos::deep_copy(dVecVals, hVecVals);
 				Kokkos::deep_copy(dVecInd, hVecInd);
 
-				fillSelected(deviceVectorAll(), dVecInd, dVecVals, indices.size());
+				fillSelected(deviceViewAll(), dVecInd, dVecVals, indices.size());
 
 				modifyOnDevice();
 				
@@ -858,7 +858,7 @@ public:
 		{
 			if(empty())return;
 			
-			Kokkos::deep_copy(deviceVector(), hostVector());
+			Kokkos::deep_copy(deviceView(), hostView());
 			dualView_.clear_sync_state();
 		}
 
@@ -866,7 +866,7 @@ public:
 		void copyHostToDevice(int32 start, int32 end, bool setUpdated = true)
 		{
 			if(empty())return;
-			Kokkos::deep_copy(deviceVector(start, end), hostVector(start, end));
+			Kokkos::deep_copy(deviceView(start, end), hostView(start, end));
 			if(setUpdated)
 				dualView_.clear_sync_state();
 		}
@@ -876,7 +876,7 @@ public:
 		INLINE_FUNCTION_H void copyDeviceToHost()
 		{
 			if(empty())return;
-			Kokkos::deep_copy(hostVector(), deviceVector());
+			Kokkos::deep_copy(hostView(), deviceView());
 			dualView_.clear_sync_state();
 		}
 
@@ -884,7 +884,7 @@ public:
 		void copyDeviceToHost(int32 start, int32 end, bool setUpdated = true)
 		{
 			if(empty())return;
-			Kokkos::deep_copy(hostVector(start, end), deviceVector(start, end));
+			Kokkos::deep_copy(hostView(start, end), deviceView(start, end));
 			if(setUpdated)
 				dualView_.clear_sync_state();
 		}
@@ -962,12 +962,12 @@ public:
 			if(hostRequiresSync()) // device is updated
 			{
 				//const auto dVec = Kokkos::subview(dualView_.d_view, Kokkos::make_pair(0,int(size_)));
-				Kokkos::deep_copy(mirror,deviceVector());
+				Kokkos::deep_copy(mirror,deviceView());
 			}
 			else // either host is updated or both sides are syncronized
 			{
 				//const auto hVec = Kokkos::subview(dualView_.h_view, Kokkos::make_pair(0,int(size_)));
-				Kokkos::deep_copy(mirror,hostVector());
+				Kokkos::deep_copy(mirror,hostView());
 			}				
 			return vecToFile.write(os);
 		}
diff --git a/src/phasicFlow/containers/VectorHD/VectorDualAlgorithms.hpp b/src/phasicFlow/containers/VectorHD/VectorDualAlgorithms.hpp
index a1191675..603ae29a 100644
--- a/src/phasicFlow/containers/VectorHD/VectorDualAlgorithms.hpp
+++ b/src/phasicFlow/containers/VectorHD/VectorDualAlgorithms.hpp
@@ -39,11 +39,11 @@ int64 count(const VectorDual<T,MemorySpace>& vec, const T& val)
 {
 	if constexpr (std::is_same<side,HostSide>::value)
 	{
-		return count( vec.hostVectorAll(), static_cast<size_t>(0), vec.size(), val);
+		return count( vec.hostViewAll(), static_cast<size_t>(0), vec.size(), val);
 	}
 	else
 	{
-		return count( vec.deviceVectorAll(), static_cast<size_t>(0), vec.size(), val);
+		return count( vec.deviceViewAll(), static_cast<size_t>(0), vec.size(), val);
 	}
 
 	return -1;
@@ -63,11 +63,11 @@ int64 min(const VectorDual<T,MemorySpace>& vec)
 {
 	if constexpr (std::is_same<side,HostSide>::value)
 	{
-		return min( vec.hostVectorAll(), static_cast<size_t>(0), vec.size());
+		return min( vec.hostViewAll(), static_cast<size_t>(0), vec.size());
 	}
 	else
 	{
-		return min( vec.deviceVectorAll(), static_cast<size_t>(0), vec.size());
+		return min( vec.deviceViewAll(), static_cast<size_t>(0), vec.size());
 	}
 
 	return 0.0;
@@ -87,11 +87,11 @@ int64 max(const VectorDual<T,MemorySpace>& vec)
 {
 	if constexpr (std::is_same<side,HostSide>::value)
 	{
-		return max( vec.hostVectorAll(), static_cast<size_t>(0), vec.size());
+		return max( vec.hostViewAll(), static_cast<size_t>(0), vec.size());
 	}
 	else
 	{
-		return max( vec.deviceVectorAll(), static_cast<size_t>(0), vec.size());
+		return max( vec.deviceViewAll(), static_cast<size_t>(0), vec.size());
 	}
 
 	return 0.0;
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingle.cpp b/src/phasicFlow/containers/VectorHD/VectorSingle.cpp
new file mode 100644
index 00000000..f7dad0c7
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorSingle.cpp
@@ -0,0 +1,886 @@
+#include "VectorSingle.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.
+
+-----------------------------------------------------------------------------*/
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+pFlow::uint32 pFlow::VectorSingle<T,MemorySpace>::changeSize
+(
+    uint32 n, 
+    bool withInit
+)
+{
+    if(n > this->capacity() )
+    {
+        uint32 newCap = evalCapacity(n);
+        changeCapacity(newCap, withInit);
+    }
+    return setSize(n);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+pFlow::uint32 pFlow::VectorSingle<T,MemorySpace>::changeCapacitySize
+(
+    uint32 actualCap, 
+    uint32 n, 
+    bool withInit
+)
+{
+    changeCapacity(actualCap, withInit);
+    return setSize(n);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+void pFlow::VectorSingle<T,MemorySpace>::changeCapacity
+(
+    uint32 actualCap, 
+    bool withInit
+)
+{
+    if constexpr( isTriviallyCopyable_ )
+    {
+        if(withInit)
+        {
+            resizeInit(view_, actualCap);
+        }
+        else
+        {
+            resizeNoInit(view_, actualCap);
+        }
+    }
+    else if constexpr( isHostAccessible_ )
+    {
+        viewType newView(view_.label(), actualCap);
+
+        for(auto i=0u; i<min(size_,actualCap); i++)
+        {
+            newView(i) = view_(i);
+        }
+
+        view_ = newView;
+
+    }
+    else
+    {
+        static_assert("changeCapacity is not a valid operation for non-trivially-copyable data type on device memory");
+    }
+    
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+pFlow::uint32 pFlow::VectorSingle<T,MemorySpace>::reallocateCapacitySize
+(
+    uint32 cap, 
+    uint32 s
+)
+{
+    if constexpr (isTriviallyCopyable_)
+    {
+        reallocNoInit(view_, cap);
+    }
+    else
+    {
+        viewType newView(view_.label(), cap);
+        view_ = newView;
+    }
+    
+    return setSize(s);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+pFlow::uint32 pFlow::VectorSingle<T,MemorySpace>::setSize(uint32 n)
+{
+    auto os = size_;
+    size_ = n;
+    return os;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle()
+:
+    VectorSingle("VectorSingle")
+{}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle(const word& name)
+:
+    size_(0),
+    view_(name,2)
+{}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle
+(
+    const word& name, 
+    uint32 n
+)
+:
+    size_(n),
+    view_(name, evalCapacity(n))
+{}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle
+(
+    const word& name, 
+    uint32 n, 
+    const T& val
+)
+:
+    VectorSingle(name, n)
+{
+    assign(n, val); 
+}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle
+(
+    const word& name, 
+    uint32 cap, 
+    uint32 n, 
+    RESERVE
+)
+:
+    size_(n),
+    view_(name, cap)
+{}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle
+(
+    const word& name, 
+    const std::vector<T> & src
+) 
+:
+    VectorSingle(name)
+{
+    assign(src);
+}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle
+(
+    const word& name, 
+    const std::vector<T> & src, 
+    uint32 cap
+) 
+:
+    VectorSingle(name)
+{
+    assign(src, cap);
+}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle
+(
+    const VectorSingle& src
+)
+:
+    VectorSingle(src.name(), src)
+{}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::VectorSingle
+(
+    const word& name, 
+    const VectorSingle& src
+)
+:
+    VectorSingle(name, src.capacity(), src.size(), RESERVE())
+{
+    if constexpr(isTriviallyCopyable_)
+    {
+        copy(deviceView(), src.deviceView());
+    }
+    else if constexpr( isHostAccessible_)
+    {
+        for(auto i=0u; i<src.size(); i++)
+        {
+            view_[i] = src.view_[i];
+        }
+    }
+    else
+    {
+        static_assert("This constructor is not valid for non-trivially copyable data type on device memory");
+    }
+}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>& 
+    pFlow::VectorSingle<T,MemorySpace>::operator = (const VectorSingle& rhs) 
+{
+    if(&rhs == this) return *this;
+    VectorSingle temp(rhs);
+
+    size_ 	= temp.size();	
+    view_   = temp.view_;
+
+    return *this;
+}
+
+template<typename T, typename MemorySpace>
+pFlow::VectorSingle<T,MemorySpace>::~VectorSingle()
+{
+    view_ = viewType();
+    size_ = 0;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+pFlow::uniquePtr<pFlow::VectorSingle<T,MemorySpace>>
+ pFlow::VectorSingle<T,MemorySpace>::clone() const  
+{
+    return makeUnique<VectorSingle>( this->name(), *this);
+}
+
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+pFlow::VectorSingle<T,MemorySpace>& 
+    pFlow::VectorSingle<T,MemorySpace>::VectorField()
+{
+    return *this;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+const pFlow::VectorSingle<T,MemorySpace>& 
+pFlow::VectorSingle<T,MemorySpace>::VectorField()const
+{
+    return *this;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+const auto& pFlow::VectorSingle<T,MemorySpace>::deviceViewAll() const
+{
+    return view_;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+auto& pFlow::VectorSingle<T,MemorySpace>::deviceViewAll()
+{
+    return view_;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+auto pFlow::VectorSingle<T,MemorySpace>::deviceView()const
+{
+    return Kokkos::subview(
+        view_, 
+        Kokkos::make_pair(0u,static_cast<uint32>(size_)));
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+auto pFlow::VectorSingle<T,MemorySpace>::hostViewAll()const
+{
+    auto hView = Kokkos::create_mirror_view(view_);
+    if constexpr(isTriviallyCopyable_)
+    {
+        copy(hView, view_);
+    }
+    else if constexpr( isHostAccessible_ )
+    {
+        // nothing to be done, since it is already a host memory
+    }
+    else
+    {
+        static_assert("hostViewAll is not valid for non-trivially copyable data type on device memory");
+    }
+    return hView;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+auto pFlow::VectorSingle<T,MemorySpace>::hostView()const
+{
+    auto hView = Kokkos::create_mirror_view(deviceView());
+    if constexpr(isTriviallyCopyable_)
+    {
+        copy(hView, deviceView());
+    }
+    else if constexpr( isHostAccessible_ )
+    {
+        // nothing to be done, since it is already a host memory
+    }
+    else
+    {
+        static_assert("hostView is not valid for non-trivially copyable data type on device memory");
+    }
+    
+    return hView;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+pFlow::word pFlow::VectorSingle<T,MemorySpace>::name()const
+{
+    return view_.label();
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+pFlow::uint32 pFlow::VectorSingle<T,MemorySpace>::size()const
+{
+    return size_;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+pFlow::uint32 pFlow::VectorSingle<T,MemorySpace>::capacity()const
+{
+    return view_.extent(0);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+bool pFlow::VectorSingle<T,MemorySpace>::empty()const
+{
+    return size_==0;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::reserve(uint32 cap) 
+{
+    changeCapacity(cap);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::reallocate(uint32 cap) 
+{
+    reallocateCapacitySize(cap, 0);			
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::reallocate
+(
+    uint32 cap, 
+    uint32 newSize
+) 
+{
+    reallocateCapacitySize(cap, newSize);			
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H   
+void pFlow::VectorSingle<T,MemorySpace>::resize(uint32 n)
+{
+    changeSize(n);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H  
+void pFlow::VectorSingle<T,MemorySpace>::resize(uint32 n, const T& val) 
+{
+    assign(n, val);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::clear() 
+{
+    size_ = 0;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::fill(const T& val)
+{
+    if(empty())return;
+    pFlow::fill(view_, rangeU32(0 ,size_) ,val);    
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::fill
+(
+    rangeU32 r, 
+    const T& val
+)
+{
+    changeSize(r.end());
+    pFlow::fill(view_, r, val);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+void pFlow::VectorSingle<T,MemorySpace>::assign
+(
+    size_t n, 
+    const T& val
+)
+{
+    
+    if( n > capacity() )
+    {
+        reallocateCapacitySize(evalCapacity(n), n);
+    }
+    else
+    {
+        setSize(n);	
+    }
+    this->fill(val);
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::assign
+(
+    const std::vector<T>& src, 
+    uint32 cap
+) 
+{
+    // make sure that vector has enough capacity
+    uint32 newCap = max(static_cast<uint32>(src.size()), cap);
+    uint32 srcSize = src.size();
+    
+    if(newCap != capacity())
+    {
+        reallocateCapacitySize(newCap, srcSize);
+    }
+    else
+    {
+        changeSize(srcSize);
+    }
+    
+    if constexpr( isTriviallyCopyable_ )
+    {
+        // - unmanaged view in the host
+        hostViewType1D<const T> temp(src.data(), srcSize );
+        copy(deviceView(), temp);
+    }
+    else if constexpr( isHostAccessible_)
+    {
+        
+        for(auto i=0u; i<srcSize; i++)
+        {
+            view_[i] = src[i];
+        }
+        
+    }
+    else
+    {
+        static_assert("Not a valid operation for this data type on memory device");
+    }
+    
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::assign
+(
+    const std::vector<T>& src
+) 
+{
+    assign(src, this->capacity());
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+void pFlow::VectorSingle<T,MemorySpace>::assignFromHost(const VectorTypeHost& src)
+{
+	uint32 srcSize = src.size();
+	uint32 srcCap = src.capacity();
+
+    if(srcCap != capacity())
+    {
+        reallocateCapacitySize(srcCap, srcSize);
+    }
+    else
+    {
+        setSize(srcSize);
+    }
+	
+    if constexpr(isTriviallyCopyable_)
+    {
+        copy(deviceView(), src.hostView());
+    }
+    else if constexpr( isHostAccessible_)
+    {
+        for(auto i=0u; i<src.size(); i++)
+        {
+            view_[i] = src.view_[i];
+        }
+    }
+    else
+    {
+        static_assert("Not a valid operation for this data type on device memory");
+    }
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+void pFlow::VectorSingle<T,MemorySpace>::assign
+(
+    const VectorType& src, 
+    bool srcCapacity
+)
+{
+    uint32 srcSize = src.size();
+	uint32 srcCap = src.capacity();
+
+    if(srcCapacity && srcCap != capacity())
+    {
+        reallocateCapacitySize(srcCap, srcSize);
+    }
+    else 
+    {
+        changeSize(srcSize);
+    }
+    
+
+    if constexpr(isTriviallyCopyable_)
+    {
+        copy(deviceView(), src.deviceView());
+    }
+    else if constexpr( isHostAccessible_)
+    {
+        for(auto i=0u; i<src.size(); i++)
+        {
+            view_[i] = src.view_[i];
+        }
+    }
+    else
+    {
+        static_assert("Not a valid operation for this data type on device memory");
+    }
+}
+
+template <typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+void pFlow::VectorSingle<T, MemorySpace>::append
+(
+    const std::vector<T> &appVec
+)
+{
+    if(appVec.empty())return;
+
+    auto srcSize = appVec.size();
+    uint32 oldSize = size();
+    uint32 newSize = srcSize + oldSize;
+    
+    changeSize(newSize);
+    
+    hostViewType1D<const T> temp(appVec.data(), srcSize );
+    auto dest = Kokkos::subview(view_, Kokkos::make_pair<uint32>(oldSize,newSize));
+
+    if constexpr( isTriviallyCopyable_)
+    {
+        copy(dest, temp);
+    }
+    else if constexpr( isHostAccessible_)
+    {
+        for(auto i=0u; i<appVec.size(); i++)
+        {
+            dest[i] = appVec[i];
+        }
+    }
+    else
+    {
+        static_assert("not a valid operation for this data type on device memory");
+    }
+    
+}
+
+template <typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+void pFlow::VectorSingle<T, MemorySpace>::append
+(
+    const VectorType& appVec
+)
+{
+    uint32 appSize  = appVec.size();
+	if(appSize == 0) return;
+
+	uint32 oldS = size();
+	uint32 newSize = oldS + appSize; 
+
+	changeSize(newSize);
+
+	auto appendView = Kokkos::subview(
+		view_,
+		Kokkos::make_pair<uint32>(oldS, newSize));
+	
+    if constexpr( isTriviallyCopyable_)
+    {
+        copy(appendView, appVec.deviceView());
+    }
+    else if constexpr( isHostAccessible_)
+    {
+        for(auto i=0u; i<appVec.size(); i++)
+        {
+            appendView[i] = appVec.view_[i];
+        }
+    }
+    else
+    {
+        static_assert("not a valid operation for this data type on device memory");
+    }
+}
+
+template <typename T, typename MemorySpace>
+INLINE_FUNCTION_H auto pFlow::VectorSingle<T, MemorySpace>::getSpan()
+{
+    return span<T>(view_.data(), size());
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+auto pFlow::VectorSingle<T,MemorySpace>::getSpan()const
+{
+    return span<T>(const_cast<T*>(view_.data()), this->size());
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+bool pFlow::VectorSingle<T,MemorySpace>::insertSetElement(uint32IndexContainer indices, const T& val)
+{
+	if(indices.empty()) return true;
+	
+	auto maxInd = indices.max();
+
+	if(this->empty() || maxInd > size()-1 )
+	{
+		resize(maxInd+1);
+	}
+
+	using policy = Kokkos::RangePolicy<execution_space,Kokkos::IndexType<uint32>>;
+
+	if constexpr( isDeviceAccessible_ )
+	{
+		auto v = view_;
+		auto ind = indices.deviceView();
+
+		Kokkos::parallel_for(
+			"VectorSingle::insertSetElement",
+			policy(0,indices.size()),
+			LAMBDA_HD(uint32 i){
+				v[ind[i]]= val;
+			});
+
+		Kokkos::fence();
+	}
+	else
+	{
+
+		auto v = view_;
+		auto ind = indices.hostView();
+		
+		Kokkos::parallel_for(
+			"VectorSingle::insertSetElement",
+			policy(0,indices.size()),
+			LAMBDA_HD(uint32 i){
+				v[ind[i]]= val;
+			});
+
+		Kokkos::fence();
+
+	}
+
+	return true;
+}
+
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+bool pFlow::VectorSingle<T,MemorySpace>::insertSetElement
+(
+	const uint32IndexContainer indices, 
+	const std::vector<T>& vals
+)
+{
+
+	if(indices.empty())return true;
+	if(indices.size() != vals.size())return false;
+
+	auto maxInd = indices.max(); 
+	
+	if(this->empty() || maxInd > size()-1 )
+	{
+		resize(maxInd+1);
+	} 
+	
+	using policy = Kokkos::RangePolicy<execution_space,Kokkos::IndexType<uint32>>;
+
+	hostViewType1D<const T> hVals( vals.data(), vals.size());
+
+	if constexpr( isDeviceAccessible_ )
+	{
+		deviceViewType1D<T> dVals("dVals", indices.size());
+		copy(dVals, hVals);
+		auto dVec = view_;
+		auto ind = indices.deviceView();
+
+		Kokkos::parallel_for(
+			"VectorSingle::insertSetElement",
+			policy(0,indices.size()), LAMBDA_HD(uint32 i){	
+				dVec(ind(i))= dVals(i);});
+		Kokkos::fence();
+
+	}
+	else
+	{
+		auto dVec = view_;
+		auto ind = indices.hostView();
+
+		Kokkos::parallel_for(
+			"VectorSingle::insertSetElement",
+			policy(0,indices.size()), LAMBDA_HD(uint32 i){	
+				dVec(ind(i))= hVals(i);});
+		Kokkos::fence();
+
+	}
+		
+	return true;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+bool pFlow::VectorSingle<T,MemorySpace>::insertSetElement
+(
+	uint32IndexContainer indices, 
+	const ViewType1D<T, memory_space> vals
+)
+{
+    if(indices.empty())return true;
+	if(indices.size() != vals.size())return false;
+
+	auto maxInd = indices.max(); 
+	
+	if(this->empty() || maxInd > size()-1 )
+	{
+		resize(maxInd+1);
+	} 
+
+    using policy = Kokkos::RangePolicy<
+                    execution_space,
+                    Kokkos::IndexType<uint32>>;
+
+	if constexpr( isDeviceAccessible_ )
+	{
+		auto dVec = view_;
+        auto dVals = vals;
+		auto ind = indices.deviceView();
+
+		Kokkos::parallel_for(
+			"VectorSingle::insertSetElement",
+			policy(0,indices.size()), LAMBDA_HD(uint32 i){	
+				dVec(ind(i))= dVals(i);});
+		Kokkos::fence();
+
+	}
+	else
+	{
+		auto dVec = view_;
+        auto hVals = vals;
+		auto ind = indices.hostView();
+
+		Kokkos::parallel_for(
+			"VectorSingle::insertSetElement",
+			policy(0,indices.size()), LAMBDA_HD(uint32 i){	
+				dVec(ind(i))= hVals(i);});
+		Kokkos::fence();
+
+	}
+		
+	return true;
+}
+
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H
+bool pFlow::VectorSingle<T,MemorySpace>::reorderItems(uint32IndexContainer indices)
+{
+	if(indices.size() == 0)
+	{
+		setSize(0);
+		return true;
+	}
+	
+	auto maxInd = indices.max();
+
+	if(maxInd >= this->size())
+	{
+		fatalErrorInFunction<<"In reordering the VectorSingle ("
+		<< this->name()<< ") maximum index ("<< maxInd << 
+		") exceeds the size of the vector ("	<< this->size()<<")"<<endl;
+		return false;
+	}
+
+	uint32 		newSize = indices.size();
+	
+	setSize(newSize);
+
+	viewType 	sortedView(this->name(), newSize);
+
+	using policy = Kokkos::RangePolicy< execution_space,Kokkos::IndexType<uint32>>;
+
+	if constexpr( isDeviceAccessible_)
+	{
+		auto d_indices = indices.deviceView();
+		auto d_view = view_;
+		
+		Kokkos::parallel_for
+		(
+			"VectorSingle::sortItems",
+			policy(0,newSize), 
+			LAMBDA_HD(uint32 i)
+			{	
+				sortedView(i) = d_view(d_indices(i));
+			}
+		);
+
+		Kokkos::fence();
+
+	}
+	else
+	{
+		auto h_indices = indices.hostView();
+		auto d_view = view_;
+		
+		Kokkos::parallel_for
+		(
+			"VectorSingle::sortItems",
+			policy(0,newSize), 
+			LAMBDA_HD(uint32 i)
+			{	
+				sortedView(i) = d_view(h_indices(i));
+			}
+		);
+		
+		Kokkos::fence();
+	}
+
+	copy(deviceView(), sortedView);
+	
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingle.hpp b/src/phasicFlow/containers/VectorHD/VectorSingle.hpp
index 8dafeeb7..1243d501 100644
--- a/src/phasicFlow/containers/VectorHD/VectorSingle.hpp
+++ b/src/phasicFlow/containers/VectorHD/VectorSingle.hpp
@@ -17,21 +17,18 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
-
 #ifndef __VectorSingle_hpp__
 #define __VectorSingle_hpp__
 
-#include "globalSettings.hpp"
-#include "types.hpp"
-#include "typeInfo.hpp"
-#include "Vector.hpp"
-#include "indexContainer.hpp"
+#include <vector>
 
+#include "globalSettings.hpp"
+#include "phasicFlowKokkos.hpp"
+#include "stdVectorHelper.hpp"
+#include "error.hpp"
+#include "indexContainer.hpp"
 #include "streams.hpp"
 
-#include "KokkosTypes.hpp"
-#include "ViewAlgorithms.hpp"
 
 
 #ifndef __RESERVE__
@@ -42,824 +39,431 @@ Licence:
 namespace pFlow
 {
 
-
+//- Forward 
 template<typename T, typename MemorySpace>
 class VectorSingle;
 
-
 template<typename T, typename MemorySpace=void>
 class VectorSingle
 {
 public:
 	
-	// viewType (view of data host and device)
-  	using VectorType		= VectorSingle<T, MemorySpace>;
+	//- typedefs for accessing data
 
-  	using iterator        = T*;
+		using VectorType		= VectorSingle<T, MemorySpace>;
 
-  	using constIterator   = const T*;
+		using VectorTypeHost 	= VectorSingle<T, HostSpace>; 		
+
+		using iterator        = T*;
+
+		using const_iterator   = const T*;
+	  	
+		using reference       = T&;
+	  	
+	 	using const_reference  = const T&;
+
+		using value_type       = T;
+	  	
+		using pointer         = T*;
+	  	
+		using const_pointer    = const T*;
   	
-	using reference       = T&;
-  	
-  	using constReference  = const T&;
+	//- typedefs related to memory management 
 
-	using valueType       = T;
-  	
-  	using pointer         = T*;
-  	
-  	using constPointer    = const T*;
-  	
-  	// type defs related to Kokkos 
-  	using viewType 			= ViewType1D<T, MemorySpace>;
+		using viewType 			= ViewType1D<T, MemorySpace>;
 
-  	using deviceType 		= typename viewType::device_type;
+		using device_type 		= typename viewType::device_type;
 
-  	using memory_space 		= typename viewType::memory_space;
+		using memory_space 		= typename viewType::memory_space;
 
-  	using execution_space 	= typename viewType::execution_space;
+		using execution_space 	= typename viewType::execution_space;
 
-protected:
+private:
 	
-	size_t 			size_ = 0;
+	// - Data members
 
-	size_t 			capacity_ = 0;
+		/// Size of the vector 
+		uint32 			size_ = 0;
 
-	viewType   		view_;
+		/// view of the vector 
+		viewType   		view_;
 
-	mutable viewType	subView_;
+	// - protected members and methods 
 
-	mutable bool		subViewUpdated_ = false;
+		/// growth factor for vector 
+		static const inline 
+		real 	growthFactor_ = vectorGrowthFactor__;
 
-	static const inline real 	growthFactor_ = vectorGrowthFactor__;
+		/// Is the memory of this vector accessible from Host
+		static constexpr 
+		bool  isHostAccessible_ = isHostAccessible<execution_space>();
 
-	static constexpr bool  isHostAccessible_ =
-  	Kokkos::SpaceAccessibility<execution_space,Kokkos::HostSpace>::accessible;
+		/// Is the memory of this vector accessiple from Divce
+		static constexpr
+		bool isDeviceAccessible_ = isDeviceAccessible<execution_space>();
 
-  	constexpr static inline const char* memoerySpaceName()
-  	{
-  		return memory_space::name();
-  	}
+		static constexpr
+		bool isTriviallyCopyable_ = std::is_trivially_copyable_v<T>;
 
-	static INLINE_FUNCTION_H size_t evalCapacity(size_t n)
-	{
-		return static_cast<size_t>(n*growthFactor_+1);
-	}
-
-	// use actualCap = true only for reserve
-	INLINE_FUNCTION_H void changeSize(size_t n, bool actualCap=false)
-	{
-		if(n > capacity_ )
+	  	/// Evaluate capacity based on the input size 
+		static INLINE_FUNCTION_H uint32 evalCapacity(uint32 n)
 		{
-			if(actualCap)
-				capacity_ = n;
-			else
-				capacity_ = evalCapacity(n);
-
-			Kokkos::resize(view_, capacity_);
-			subViewUpdated_ = false;
+			return static_cast<uint32>(n*growthFactor_+1);
 		}
-		if(!actualCap) 
-		{
-			setSize(n);
-		}
-	}
 
-	INLINE_FUNCTION_H void setSize(size_t n)
-	{
-		size_ = n;
-		subViewUpdated_ = false;
-	}
+	/// @brief Change size to n and preserve the conetent if realloc 
+	/// occurs 
+	INLINE_FUNCTION_H 
+	uint32 changeSize(uint32 n, bool withInit= false);
 
-	// - update subview 
-	INLINE_FUNCTION_H void updateSubView()const
-	{
-		if(subViewUpdated_) return;
-
-		subView_ 	= Kokkos::subview(view_, Kokkos::make_pair(0,int(size_)));
-		subViewUpdated_ = true;
-	}
+    /// @brief Change the size and capacity of Vector
+	INLINE_FUNCTION_H
+	uint32 changeCapacitySize(uint32 actualCap, uint32 n, bool withInit= false);
 	
+	INLINE_FUNCTION_H
+	void changeCapacity(uint32 actualCap, bool withInit= false);
+	
+	INLINE_FUNCTION_H
+	uint32 reallocateCapacitySize(uint32 cap, uint32 s);
+	
+	INLINE_FUNCTION_H 
+	uint32 setSize(uint32 n);
 	
 public:
 
-	// - type info
-	TypeInfoTemplateNV2("VectorSingle", T, memoerySpaceName());
+	/// Type info
+	TypeInfoTemplateNV111("VectorSingle", T, memoerySpaceName());
 
 	//// - Constructors
 
-		// - empty constructor
-		VectorSingle()
-		:
-			VectorSingle("VectorSingle")
-		{}
+		/// Empty vector
+		VectorSingle();
+		
+		/// Empty vector with a name (capacity = 2) 
+		explicit VectorSingle(const word& name);
+		
+		/// Vector with name and size n
+		VectorSingle(const word& name, uint32 n);
+		
+		/// Vector with name, size and value
+		VectorSingle(const word& name, uint32 n, const T& val);
 
-		// empty vector with a name 
-		VectorSingle(const word& name)
-		:
-			size_(0),
-			capacity_(2),
-			view_(name,capacity_)
-		{
-			changeSize(size_);
-		}
+		/// Vector with name, size (n) and reserved capacity 
+		VectorSingle(const word& name, uint32 cap, uint32 n, RESERVE );
+		
+		/// Construct with a name and form std::vector (host memory)
+		VectorSingle(const word& name, const std::vector<T> & src); 
 
-		// - a vector with size n
-		VectorSingle(size_t n)
-		:
-			VectorSingle("VectorSingle",n)
-		{}
+		/// Construct with a name and form std::vector (host memory) and with a desired capacity. 
+		VectorSingle(const word& name, const std::vector<T> & src, uint32 cap);
+		
+		/// Copy construct (performs deep copy)
+		VectorSingle(const VectorSingle& src);
+		
+    	/// Copy construct with a new name (perform deep copy)
+		VectorSingle(const word& name, const VectorSingle& src);
+		
+		/// Copy assignment (perform deep copy from rhs to *this)
+		VectorSingle& operator = (const VectorSingle& rhs) ;
+		
+		/// Move construct
+		VectorSingle(VectorSingle&&) = default;   
 
-		// - a vector with name and size n
-		VectorSingle(const word& name, size_t n)
-		:
-			size_(n),
-			capacity_(evalCapacity(n)),
-			view_(name, capacity_)
-		{
-			changeSize(size_);
-		}
+		/// Move assignment
+		VectorSingle& operator= (VectorSingle&&) = default; 
 
-		// a vector with size and value 
-		VectorSingle(size_t n, const T& val)
-		:
-			VectorSingle("VectorSingle", n , val)
-		{}
+		/// @brief Descructor
+        /// This may not destroy the underlying memory, sice view is 
+		/// shared_ptr and maybe referenced by another object too 
+		~VectorSingle();
 
-		// a vector with name, size and value
-		VectorSingle(const word& name, size_t n, const T& val)
-		:
-			VectorSingle(name, n)
-		{
-			assign(n, val);
-		}
-
-		// a vector with name and reserved capacity 
-		VectorSingle(size_t cap, size_t n, RESERVE )
-		:
-			VectorSingle("VectorSingle", cap, n, RESERVE())
-		{}
-
-
-		// a vector with name and reserved capacity 
-		VectorSingle(const word& name, size_t cap, size_t n, RESERVE )
-		:
-			VectorSingle(name)
-		{
-			reallocate(cap);
-			size_ = n;
-		}
-
-		// - construct from pFlow::Vector (host memory)
-		VectorSingle(const Vector<T> & src)
-		:
-			VectorSingle("VectorSingle", src)
-		{}
-
-		// - construct from pFlow::Vector and name 
-		VectorSingle(const word& name, const Vector<T> & src)
-		:
-			VectorSingle(name)
-		{
-			assign(src);
-		}
-
-		// - copy construct (perform deep copy)
-		VectorSingle(const VectorSingle& src)
-		:
-			VectorSingle(src.name(), src.capacity(), src.size(), RESERVE())
-		{	
-			copy(deviceVectorAll(), src.deviceVectorAll());
-			////Kokkos::deep_copy(deviceVectorAll(), src.deviceVectorAll());
-		}
-
-		// - copy construct with a new name 
-		VectorSingle(const word& name, const VectorSingle& src)
-		:
-			VectorSingle(name, src.capacity(), src.size(), RESERVE())
-		{
-			copy(deviceVectorAll(), src.deviceVectorAll());	
-			////Kokkos::deep_copy(deviceVectorAll(), src.deviceVectorAll());
-		}
-
-		// - copy assignment 
-		VectorSingle& operator = (const VectorSingle& rhs)
-		{
-			if(&rhs == this) return *this;
-			VectorSingle temp(rhs);
-			capacity_   = temp.capacity();
-			size_ 		= temp.size();	
-			view_   = temp.view_;
-			subViewUpdated_ = false;
-
-			return *this;
-		}
-
-		// no move construct
-		VectorSingle(VectorSingle&&) = delete;
-
-		// no move assignment
-		VectorSingle& operator= (VectorSingle&&) = delete;
-
-
-		// - clone as a uniquePtr
+		/// Clone as a uniquePtr (perform deep copy)
 		INLINE_FUNCTION_H 
-		uniquePtr<VectorSingle> clone() const
-		{
-			return makeUnique<VectorSingle>(*this);
-		}
-
-		// - clone as a pointer
-		INLINE_FUNCTION_H
-		VectorSingle* clonePtr()const
-		{
-			return new VectorSingle(*this);
-		}
+		uniquePtr<VectorSingle> clone() const;
 
+			
 	//// - Methods
 
-		// - return *this
+		/// Return *this
 		INLINE_FUNCTION_H
-		VectorType& VectorField()
-		{
-			return *this;
-		}
+		VectorType& VectorField();
 
-		// - return *this
+		/// Return *this
 		INLINE_FUNCTION_H
-		const VectorType& VectorField()const
-		{
-			return *this;
-		}
+		const VectorType& VectorField()const;
 
-
-		// - Device vector range [0,capcity)
+		/// Device view range [0,capcity)
 		INLINE_FUNCTION_H 
-		viewType& deviceVectorAll(){
-			return view_;
-		}
+		auto& deviceViewAll();
 
-		// - Device vector range [0,capacity)
+		/// Device view range [0,capcity)
 		INLINE_FUNCTION_H 
-		const viewType& deviceVectorAll() const {
-			return view_;
-		}
+		const auto& deviceViewAll() const;
 
-		//  - Device vector range [0, size)
+		///  Device view range [0, size)
 		INLINE_FUNCTION_H 
-		viewType& deviceVector(){
-			updateSubView();
-			return subView_;
-		}
+		auto deviceView()const;
 
-		//  - Device vector range [0, size)
+		/// Return a view accessible on Host in range [0,capacity)
 		INLINE_FUNCTION_H 
-		const viewType& deviceVector()const{
-			updateSubView();
-			return subView_;
-		}
-
-		INLINE_FUNCTION_H 
-		const auto hostVectorAll()const
-		{
-			auto hView = Kokkos::create_mirror_view(view_);
-			copy(hView, view_);
-			return hView;
-		}
-
-		INLINE_FUNCTION_H 
-		auto hostVectorAll()
-		{
-			auto hView = Kokkos::create_mirror_view(view_);
-			copy(hView, view_);
-			return hView;
-		}
-
-		INLINE_FUNCTION_H 
-		const auto hostVector()const
-		{
-			auto hView = Kokkos::create_mirror_view(deviceVector());
-			copy(hView, deviceVector());
-			return hView;
-		}
-
-		INLINE_FUNCTION_H 
-		auto hostVector()
-		{
-			auto hView = Kokkos::create_mirror_view(deviceVector());
-			copy(hView, deviceVector());
-			return hView;
-		}
-
-		// - name of vector 
-		INLINE_FUNCTION_H 
-		const word name()const
-		{
-			return view_.label();
-		}
+		auto hostViewAll()const;
 		
-		// - size of vector 
+
+		/// Return a view accessible on Host in range [0,size)
 		INLINE_FUNCTION_H 
-		size_t size()const
-		{
-			return size_;
-		}
+		auto hostView()const;
 
-		// - capcity of vector 
+		/// Name of the vector 
 		INLINE_FUNCTION_H 
-		size_t capacity()const
-		{
-			return capacity_;
-		}
-
-		// - if vector is empty 
-		INLINE_FUNCTION_H 
-		bool empty()const
-		{
-			return size_==0;
-		}
-
-		// - reserve capacity for vector 
-		//   preserve the content
-		INLINE_FUNCTION_H 
-		void reserve(size_t cap)
-		{
-			changeSize(cap, true);
-		}
-
-		// - reallocate memory
-		INLINE_FUNCTION_H void reallocate(size_t cap)
-		{
-			capacity_ = cap;
-			size_ = 0;
-			reallocNoInit(view_, capacity_);
-			subViewUpdated_ = false;
-		}
-
-		INLINE_FUNCTION_H void reallocate(size_t cap, size_t size)
-		{
-			capacity_ = cap;
-			size_ = size;
-			reallocNoInit(view_, capacity_);
-			subViewUpdated_ = false;
-		}
-
-		// resize the vector  
-		INLINE_FUNCTION_H 
-		void resize(size_t n){
-			changeSize(n);
-		}
-
-		// resize the view and assign value to the most recent view (most updated)
-		INLINE_FUNCTION_H 
-		void resize(size_t n, const T& val) {
-			assign(n, val);
-		}
-
-		// - clear the vector 
-		INLINE_FUNCTION_H 
-		void clear() {
-			 size_ = 0;
-			 subViewUpdated_ = false;
-
-		}
-
-		// - fill the range [0,size) with val
-		INLINE_FUNCTION_H 
-		void fill(const T& val)
-		{
-			if(empty())return;
-			pFlow::fill(deviceVectorAll(),0 ,size_ ,val);
-		}
+		word name()const;
 		
-		// - host calls only
-		// - assign n first elements to val
-		//   resize view
-		//   assign value to either side (device/host)
-		INLINE_FUNCTION_H
-		void assign(size_t n, const T& val)
-		{
-			if(capacity()<n)
-			{
-				this->reallocate(evalCapacity(n));
-			}
-			size_ = n;
-			this->fill(val);
-		}
-
-		// - host calls only
-		// - assign source vector
-		//   resize views
-		//   assign to both sides (device&host)
-		INLINE_FUNCTION_H void assign(const Vector<T>& src)
-		{
-			auto srcSize = src.size();
-			if( capacity() < srcSize ) 
-			{
-				this->reallocate( src.capacity() );
-			}
-			size_ = srcSize;
-			
-			// - unmanaged view in the host
-			hostViewType1D<const T> temp(src.data(), srcSize );
-			copy(deviceVector(), temp);
-		}
-
-
-		//TODO: change it to parallel version 
-		// - delete elements from vector 
-		//   similar memory spaces 
-		/*template<class indT, class MSpace>
-		INLINE_FUNCTION_H 
-			typename std::enable_if<
-				Kokkos::SpaceAccessibility<
-					execution_space, typename VectorSingle<indT,MSpace>::memory_space>::accessible,
-					bool>::type
-		deleteElement
-		(
-			const VectorSingle<indT,MSpace>& sortedIndices
-		)
-		{
-			
-			auto& indices = sortedIndices.deviceVectorAll();
-			auto& dVec = deviceVectorAll();
-			indT  numInd = sortedIndices.size();
-			indT  oldSize = this->size();
-
-			if( numInd == 0 )return true;
-			
-			// an scalalr
-			
-			Kokkos::parallel_for(1, LAMBDA_HD(int nn)
-			 	{
-			 		(void)nn;	
-			 		indT n = 0;
-					indT nextInd = indices[0];
-					indT j = indices[0];
-					for(label i=indices[0]; i < oldSize; ++i)
-					{
-						if( n < numInd && i == nextInd )
-						{
-							++n;
-							nextInd = indices[n];
-						}
-						else
-						{
-							dVec[j] = dVec[i];
-							++j;	
-						}				
-					}
-
-			 	});
-			typename viewType::execution_space().fence();
-			size_ = oldSize - indices.size();
-			subViewUpdated_ = false;
-
-			return true;
-		}
-
-		// different memory spaces 
-		template<class indT, class MSpace>
-		INLINE_FUNCTION_H 
-		typename std::enable_if<
-				! Kokkos::SpaceAccessibility<
-					execution_space, typename VectorSingle<indT,MSpace>::memory_space>::accessible,
-					bool>::type
-		deleteElement
-		(
-			const VectorSingle<indT,MSpace>& sortedIndices
-		)
-		{
-			
-			notImplementedFunction;
-		}*/
-
-		INLINE_FUNCTION_H
-		bool insertSetElement(const int32IndexContainer& indices, const T& val)
-		{
-			if(indices.empty()) return true;
-			auto maxInd = indices.max();
-
-			if(this->empty() || maxInd > size()-1 )
-			{
-				resize(maxInd+1);
-			}
-
-			
-			using policy = Kokkos::RangePolicy<
-			execution_space,
-			Kokkos::IndexType<int32> >;
-			auto dVec = deviceVectorAll();
-			auto dIndex = indices.deviceView();
-			
-			Kokkos::parallel_for(
-				"insertSetElement",
-				policy(0,indices.size()), LAMBDA_HD(int32 i){	
-				dVec(dIndex(i))= val;
-				});
-			Kokkos::fence();
-
-			return true;
-		}
-
-		INLINE_FUNCTION_H
-		void sortItems(const int32IndexContainer& indices)
-		{
-			if(indices.size() == 0)
-			{
-				setSize(0);
-				return;
-			}
-			
-			size_t 		newSize = indices.size();
-			viewType 	sortedView("sortedView", newSize);
-
-			using policy = Kokkos::RangePolicy<
-			execution_space,
-			Kokkos::IndexType<int32> >;
-
-			auto d_indices = indices.deviceView();
-			auto d_view = view_;
-			Kokkos::parallel_for(
-				"sortItems",
-				newSize, 
-				LAMBDA_HD(int32 i){	
-					sortedView(i) = d_view(d_indices(i));
-				});
-
-			Kokkos::fence();
-
-			setSize(newSize);
-
-			copy(deviceVector(), sortedView);
-			
-			return;
-
-		}
-
-		INLINE_FUNCTION_H
-		bool insertSetElement(const int32IndexContainer& indices, const Vector<T>& vals)
-		{
-
-			if(indices.size() == 0)return true;
-			if(indices.size() != vals.size())return false;
-
-			auto maxInd = indices.max(); 
-			
-			if(this->empty() || maxInd > size()-1 )
-			{
-				resize(maxInd+1);
-			} 
-
-				
-			hostViewType1D<const T> hVecVals( vals.data(), vals.size());
-			deviceViewType1D<T> dVecVals("dVecVals", indices.size());
-
-			copy(dVecVals, hVecVals);
-
-			using policy = Kokkos::RangePolicy<
-			execution_space,
-			Kokkos::IndexType<int32> >;
-			auto dVec = deviceVectorAll();
-			auto dIndex = indices.deviceView();
 		
-			Kokkos::parallel_for(
-				"insertSetElement",
-				policy(0,indices.size()), LAMBDA_HD(int32 i){	
-				dVec(dIndex(i))= dVecVals(i);
-				});
-			Kokkos::fence();
+		/// Size of the vector 
+		INLINE_FUNCTION_H 
+		uint32 size()const;
+		
 
-			return true;
-			
-		}
+		// Capcity of the vector 
+		INLINE_FUNCTION_H 
+		uint32 capacity()const;
+		
+		/// If vector is empty 
+		INLINE_FUNCTION_H 
+		bool empty()const;
+		
+		/// Reserve capacity for vector 
+		/// Preserve the content.
+		INLINE_FUNCTION_H 
+		void reserve(uint32 cap); 
+
+		/// Reallocate memory to new cap and set size to 0. 
+		INLINE_FUNCTION_H 
+		void reallocate(uint32 cap); 
+		
+		/// Reallocate memory to new cap and set size to newSize. 
+		/// Do not preserve the content
+		INLINE_FUNCTION_H 
+		void reallocate(uint32 cap, uint32 newSize); 
+		
+		/// Resize the vector and preserve the content
+		INLINE_FUNCTION_H   
+		void resize(uint32 n);
+
+		/// Resize the vector and assign the value to it. 
+		INLINE_FUNCTION_H  
+		void resize(uint32 n, const T& val);
+
+		/// Clear the vector, but keep the allocated memory unchanged 
+		INLINE_FUNCTION_H 
+		void clear();
+		
+		/// Fill the range [0,size) with val
+		INLINE_FUNCTION_H 
+		void fill(const T& val);
 
 		INLINE_FUNCTION_H
-		bool insertSetElement(const Vector<int32>& indices, const T& val)
-		{
-			if(indices.empty()) return true;
+		void fill(rangeU32 r,  const T& val);
+		
+		/// Change size of the vector and assign val to vector and 
+		INLINE_FUNCTION_H
+		void assign(size_t n, const T& val);
+		
+		/// Assign source vector with specified capacity.
+		/// The size of *this becomes the size of src. 
+		INLINE_FUNCTION_H 
+		void assign(const std::vector<T>& src, uint32 cap); 
+		
 
-			auto maxInd = max(indices);
-			
-			if(this->empty() || maxInd > size()-1 )
-			{
-				resize(maxInd+1);
-			}
+		/// Assign source vector.
+		/// The size of *this becomes the size of src. 
+		/// The capacity of *this becomes the capacity of src.
+		INLINE_FUNCTION_H 
+		void assign(const std::vector<T>& src);
 
-			if constexpr (isHostAccessible_)
-			{
-				hostViewType1D<int32> hostView(const_cast<int32*>(indices.data()), indices.size());
-				fillSelected(deviceVectorAll(), hostView, indices.size(), val);
-				return true;
-			
-			}else
-			{
-
-				// TODO: remove the const_cast 
-				hostViewType1D<int32> hostView(const_cast<int32*>(indices.data()), indices.size());
-				deviceViewType1D<int32> dView("dView", indices.size());
-				copy(dView, hostView);
-				fillSelected(deviceVectorAll(), dView, indices.size(), val);
-				return true;
-			}
-
-			return false;
-		}
+		/// Assign source vector from host side.
+		/// The size of *this becomes the size of src. 
+		/// The capacity of *this becomes the capacity of src.
+		INLINE_FUNCTION_H
+		void assignFromHost(const VectorTypeHost& src);
 
 		INLINE_FUNCTION_H
-		bool insertSetElement(const Vector<int32>& indices, const Vector<T>& vals)
-		{
-			if(indices.size() == 0)return true;
-			if(indices.size() != vals.size())return false;
+		void assign(const VectorType& src, bool srcCapacity = true);
 
-			auto maxInd = max(indices); 
-			
-			if(this->empty() || maxInd > size()-1 )
-			{
-				resize(maxInd+1);
-			} 
+		INLINE_FUNCTION_H
+		void append(const std::vector<T>& appVec);
 
-			if constexpr (isHostAccessible_)
-			{
-				// TODO: remove const_cast
-				hostViewType1D<int32> hVecInd( const_cast<int32*>(indices.data()), indices.size());
-				hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
-
-				fillSelected(deviceVectorAll(), hVecInd, hVecVals, indices.size());
-				return true;
-			
-			}else
-			{
+		INLINE_FUNCTION_H
+		void append(const VectorType& appVec);
+		
+		INLINE_FUNCTION_H
+		auto getSpan();
 				
-				// TODO: remove const_cast
-				hostViewType1D<int32> hVecInd( const_cast<int32*>(indices.data()), indices.size());
-				deviceViewType1D<int32> dVecInd("dVecInd", indices.size());
-
-				hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
-				deviceViewType1D<T> dVecVals("dVecVals", indices.size());
-				
-				copy(dVecVals, hVecVals);
-				copy(dVecInd, hVecInd);
-
-				fillSelected(deviceVectorAll(), dVecInd, dVecVals, indices.size());
-				return true;
-			}
-
-			return false;
-		}
+		INLINE_FUNCTION_H 
+		auto getSpan()const;
+		
+		INLINE_FUNCTION_H
+		bool insertSetElement(uint32IndexContainer indices, const T& val);
+		
+		INLINE_FUNCTION_H
+		bool insertSetElement(uint32IndexContainer indices, const std::vector<T>& vals);
+		
+		INLINE_FUNCTION_H
+		bool insertSetElement(
+			uint32IndexContainer indices, 
+			const ViewType1D<T, memory_space> vals);
 
 		INLINE_FUNCTION_H
-		bool append(const deviceViewType1D<T>& dVec, size_t numElems)
-		{
+		bool reorderItems(uint32IndexContainer indices);
 
-			if(numElems == 0 )return true;
-			auto oldSize = size_;
-			auto newSize = size_ + numElems;
-
-			if(this->empty() || newSize > capacity() )
-			{
-				resize(newSize);
-			}
-			else
-			{
-				size_ = size_+numElems;
-			}
-			
-			auto dSubView = Kokkos::subview(view_, Kokkos::make_pair(oldSize, newSize)); 
-			copy(dSubView, dVec);
-
-			return true;
-		}
-
-		INLINE_FUNCTION_H
-		bool append(const VectorSingle& Vec)
-		{
-			return append(Vec.deviceVector(), Vec.size());
-		}
-
-		// - host calls only
-		//   push a new element at the end
-		//   resize if necessary
-		//   works on host accessible vector 
+		/// @brief push a new element at the end (host call only)
+		///  resize if necessary and works on host accessible vector.
 		template<bool Enable = true>
-		typename std::enable_if<
-			isHostAccessible_ && Enable,
-			void>::type
+		INLINE_FUNCTION_H
+		typename std::enable_if_t<isHostAccessible_ && Enable, void>
 		push_back(const T& val)
 		{
-			if(size_ == capacity_) 
-			{
-				changeSize(evalCapacity(capacity_), true);
-			}
-			data()[size_++] = val;
-			subViewUpdated_ = false;
+			auto n = changeSize(size_+1);
+			data()[n] = val;	
 		}
 
-		INLINE_FUNCTION_H pointer data(){
+		INLINE_FUNCTION_H 
+		pointer data(){
 			return view_.data();
 		}
 
-		INLINE_FUNCTION_H constPointer data()const{
+		INLINE_FUNCTION_H 
+		const_pointer data()const{
 			return view_.data();
 		}
 
-		// - host calls only
-		//   works on host accessible vector 
-		// 	 returns begin iterator 
+		/// Return begin iterator. It works when devices is host accessible.
 		template<bool Enable = true>
 		INLINE_FUNCTION_H 
-		typename std::enable_if_t<
-			isHostAccessible_ && Enable,
-			iterator>
+		typename std::enable_if_t<isHostAccessible_ && Enable,iterator>
 		begin(){
 			return data();
 		}
 
-		// - host calls only
-		//   works on host accessible vector 
-		//   returns begin iterator 
+		/// Return begin iterator. it works when host is accessible.
 		template<bool Enable = true>
 		INLINE_FUNCTION_H 
-		typename std::enable_if<
-			isHostAccessible_ && Enable,
-			constIterator>::type
+		typename std::enable_if_t<isHostAccessible_ && Enable,const_iterator>
 		begin()const {
 			return data();
 		}
 
-		// - host calls only
-		//   works on host accessible vector 
-		//   returns end iterator
+		
+		/// Return end iterator. it works when host is accessible.
 		template<bool Enable = true> 
 		INLINE_FUNCTION_H
-		typename std::enable_if<
-			isHostAccessible_ && Enable,
-			iterator>::type
+		typename std::enable_if_t<isHostAccessible_ && Enable,iterator>
 		end(){
 			return size_ > 0 ? data() + size_: data();
 		}
 
-		// host call
-		// returns end iterator 
+		
+		/// Return end iterator. it works when host is accessible.
 		template<bool Enable = true>
 		INLINE_FUNCTION_H
-		typename std::enable_if<
-			isHostAccessible_ && Enable,
-			constIterator>::type
+		typename std::enable_if_t<isHostAccessible_ && Enable,const_iterator>
 		end()const{
 			return size_ > 0 ? data() + size_: data();
 		}
 				
-		// operator to be used on host side vectors
+		/// Return reference to element i. it works when host is accessible.
 		template<bool Enable = true>
 		INLINE_FUNCTION_H 
-		typename std::enable_if<
-			isHostAccessible_ && Enable,
-			reference>::type
-		operator[](label i){
+		typename std::enable_if_t<isHostAccessible_ && Enable,reference>
+		operator[](size_t i){
 			return view_[i];
 		}
 
+		/// Return reference to element i. it works when host is accessible.
 		template<bool Enable = true>
 		INLINE_FUNCTION_H 
-		typename std::enable_if<
-			isHostAccessible_ && Enable,
-			constReference>::type
-		 operator[](label i)const{
+		typename std::enable_if_t<isHostAccessible_ && Enable,const_reference>
+		 operator[](size_t i)const{
 			return view_[i];
 		}
 
 	//// - IO operations
 
+		/// Read vector from stream
 		FUNCTION_H
-		bool readVector(
-			iIstream& is,
-			size_t len=0)
+		bool read(iIstream& is)
 		{
-			Vector<T> vecFromFile;
-			if( !vecFromFile.readVector(is,len) ) return false;
+			std::vector<T> vecFromFile;
+			if(! readStdVector(is, vecFromFile)) return false;
 
 			this->assign(vecFromFile);
 
 			return true;
 		}
 
+		/// Read vector from stream
 		FUNCTION_H
-		bool read(iIstream& is)
+		bool read(iIstream& is, const IOPattern& iop)
 		{
-			return readVector(is);
+			std::vector<T> vecFromFile;
+			if(! readStdVector(is, vecFromFile, iop)) return false;
+			this->assign(vecFromFile);
+
+			return true;
+		}
+
+		/// Write the vector to os
+		FUNCTION_H
+		bool write(iOstream& os, const IOPattern& iop)const
+		{
+			auto hVec = hostView();
+			auto sp = span<T>( const_cast<T*>(hVec.data()), hVec.size());
+			
+			return writeSpan(os, sp, iop);
+			
 		}
 
 		FUNCTION_H
 		bool write(iOstream& os)const
 		{
+			auto hVec = hostView();
+			auto sp = span<T>( const_cast<T*>(hVec.data()), hVec.size());
 			
-			Vector<T, noConstructAllocator<T>> vecToFile(this->size());
+			return writeSpan(os, sp);
 			
-			const auto dVec = Kokkos::subview(view_, Kokkos::make_pair(0,int(size_)));
-			hostViewType1D<T> mirror(vecToFile.data(), vecToFile.size());
-			copy(mirror,dVec);
+		}
 
-			return vecToFile.write(os);
+		template<typename HostMask>
+		FUNCTION_H
+		bool write(iOstream& os, const IOPattern& iop, const HostMask& mask)const
+		{
+			auto hVec = hostView();
+			
+			auto numActive = mask.numActive();
+			std::vector<T> finalField;
+			finalField.clear();
+			finalField.reserve(numActive);
+			
+			uint32 start 	= mask.activeRange().start();
+			uint32 end 		= mask.activeRange().end();
+			
+			for(uint32 i=start; i<end; i++ )
+			{
+				if( mask() )
+					finalField.push_back(hVec[i]);
+			}
+
+			auto sp = span<T>( finalField.data(), finalField.size());
+
+			return writeSpan(os, sp, iop);
+
+		}
+
+
+		/// Name of the memory space
+		static  
+		constexpr const char* memoerySpaceName()
+		{
+			return memory_space::name();
 		}
 
 }; // class VectorSingle
@@ -889,12 +493,43 @@ inline iOstream& operator << (iOstream& os, const VectorSingle<T, MemorySpace>&
 }
 
 
-
-
 } // - pFlow
 
 #include "VectorSingleAlgorithms.hpp"
+#include "VectorSingle.cpp"
+
+
 
 
 #endif //__VectorSingle_hpp__
 
+
+/*
+INLINE_FUNCTION_H
+		bool append(const deviceViewType1D<T>& dVec, size_t numElems)
+		{
+
+			if(numElems == 0 )return true;
+			auto oldSize = size_;
+			auto newSize = size_ + numElems;
+
+			if(this->empty() || newSize > capacity() )
+			{
+				resize(newSize);
+			}
+			else
+			{
+				size_ = size_+numElems;
+			}
+			
+			auto dSubView = Kokkos::subview(view_, Kokkos::make_pair(oldSize, newSize)); 
+			copy(dSubView, dVec);
+
+			return true;
+		}
+
+		INLINE_FUNCTION_H
+		bool append(const VectorSingle& Vec)
+		{
+			return append(Vec.deviceView(), Vec.size());
+		}*/
\ No newline at end of file
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingleAlgorithms.hpp b/src/phasicFlow/containers/VectorHD/VectorSingleAlgorithms.hpp
index bdd5c521..831390d4 100644
--- a/src/phasicFlow/containers/VectorHD/VectorSingleAlgorithms.hpp
+++ b/src/phasicFlow/containers/VectorHD/VectorSingleAlgorithms.hpp
@@ -17,14 +17,10 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
-
 #ifndef __VectorSingleMath_hpp__
 #define __VectorSingleMath_hpp__
 
 
-
-
 namespace pFlow
 {
 
@@ -32,14 +28,14 @@ template<typename T, typename MemorySpace>
 INLINE_FUNCTION_H 
 size_t count(const VectorSingle<T,MemorySpace>& vec, const T& val)
 {
-	return count( vec.deviceVectorAll(), 0, vec.size(), val);
+	return count( vec.deviceViewAll(), 0, vec.size(), val);
 }
 
 template<class T, class MemorySpace>
 INLINE_FUNCTION_H T min( const VectorSingle<T,MemorySpace>& vec) 
 {
 	return min(
-		vec.deviceVectorAll(),
+		vec.deviceViewAll(),
 		0, vec.size()
 		);	
 }
@@ -48,13 +44,11 @@ template<class T, class MemorySpace>
 INLINE_FUNCTION_H T max( const VectorSingle<T, MemorySpace>& vec) 
 {
 	return min(
-		vec.deviceVectorAll(),
+		vec.deviceViewAll(),
 		0, vec.size()
 		);		
 }
 
-
-
 }
 
 
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingles.cpp b/src/phasicFlow/containers/VectorHD/VectorSingles.cpp
new file mode 100644
index 00000000..c856b7c1
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorSingles.cpp
@@ -0,0 +1,38 @@
+/*------------------------------- 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 "VectorSingles.hpp" 
+
+
+template class Kokkos::View<pFlow::uint8*>;
+template class pFlow::VectorSingle<pFlow::uint8>;
+
+template class Kokkos::View<pFlow::int32*>;
+template class pFlow::VectorSingle<pFlow::int32>;
+
+template class Kokkos::View<pFlow::uint32*>;
+template class pFlow::VectorSingle<pFlow::uint32>;
+
+template class Kokkos::View<pFlow::real*>;
+template class pFlow::VectorSingle<pFlow::real>;
+
+template class Kokkos::View<pFlow::realx3*>;
+template class pFlow::VectorSingle<pFlow::realx3>;
+
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingles.hpp b/src/phasicFlow/containers/VectorHD/VectorSingles.hpp
index ecae1398..d0c3acdf 100644
--- a/src/phasicFlow/containers/VectorHD/VectorSingles.hpp
+++ b/src/phasicFlow/containers/VectorHD/VectorSingles.hpp
@@ -33,10 +33,6 @@ typedef VectorSingle<int8> 				int8Vector_D;
 
 typedef VectorSingle<int8, HostSpace> 	int8Vector_H;
 
-typedef VectorSingle<int16> 			int16Vector_D;
-
-typedef VectorSingle<int16, HostSpace> 	int16Vector_H;
-
 typedef VectorSingle<int32> 			int32Vector_D;
 
 typedef VectorSingle<int32, HostSpace> 	int32Vector_H;
@@ -45,13 +41,17 @@ typedef VectorSingle<int64> 			int64Vector_D;
 
 typedef VectorSingle<int64, HostSpace> 	int64Vector_H;
 
+typedef VectorSingle<uint8> 			uint8Vector_D;
+
+typedef VectorSingle<uint8, HostSpace> 	uint8Vector_H;
+
 typedef VectorSingle<uint32> 			uint32Vector_D;
 
 typedef VectorSingle<uint32, HostSpace> uint32Vector_H;
 
-typedef VectorSingle<label> 			labelVector_D;
+typedef VectorSingle<uint64> 			uint64Vector_D;
 
-typedef VectorSingle<label, HostSpace> 	labelVector_H;
+typedef VectorSingle<uint64, HostSpace> uint64Vector_H;
 
 typedef VectorSingle<real> 				realVector_D;
 
@@ -61,14 +61,6 @@ typedef VectorSingle<realx3> 				realx3Vector_D;
 
 typedef VectorSingle<realx3, HostSpace> 	realx3Vector_H;
 
-typedef VectorSingle<uint16x3> 				uint16x3Vector_D;
-
-typedef VectorSingle<uint16x3, HostSpace> 	uint16x3Vector_H;
-
-typedef VectorSingle<uint32x3> 				uint32x3Vector_D;
-
-typedef VectorSingle<uint32x3, HostSpace> 	uint32x3Vector_H;
-
 typedef VectorSingle<int32x3> 				int32x3Vector_D;
 
 typedef VectorSingle<int32x3, HostSpace> 	int32x3Vector_H;
@@ -77,6 +69,10 @@ typedef VectorSingle<int64x3> 				int64x3Vector_D;
 
 typedef VectorSingle<int64x3, HostSpace> 	int64x3Vector_H;
 
+typedef VectorSingle<uint32x3> 				uint32x3Vector_D;
+
+typedef VectorSingle<uint32x3, HostSpace> 	uint32x3Vector_H;
+
 typedef VectorSingle<realx3x3> 				realx3x3Vector_D;
 
 typedef VectorSingle<realx3x3, HostSpace> 	realx3x3Vector_H;
diff --git a/src/phasicFlow/containers/indexContainer/indexContainer.hpp b/src/phasicFlow/containers/indexContainer/indexContainer.hpp
index 7b517a5a..10fce100 100644
--- a/src/phasicFlow/containers/indexContainer/indexContainer.hpp
+++ b/src/phasicFlow/containers/indexContainer/indexContainer.hpp
@@ -21,32 +21,41 @@ Licence:
 #ifndef __indexContainer_hpp__ 
 #define __indexContainer_hpp__
 
-#include "span.hpp"
-#include "KokkosTypes.hpp"
-#include "KokkosUtilities.hpp"
-#include "ViewAlgorithms.hpp"
+#include <vector>
+
+#include "phasicFlowKokkos.hpp"
 
 
 namespace pFlow
 {
 
+/**
+ * It holds two vectors of indecis on Host and Device.
+ * Host vector should be used for threads running on
+ * Host and Device vector should be used for threads
+ * running on Device.
+ */
 template<typename IndexType>
 class indexContainer
 {
 public:
 	
-	using DualViewType 		= Kokkos::DualView<IndexType*>;
+	using DVType 					= DualViewType1D<IndexType>;
+	///  Device type on device 
+	using DeviceViewType 	= typename DVType::t_dev;
 
-	// - viewType of data on device 
-  	using DeviceViewType 	= typename DualViewType::t_dev;
+	/// Host type on device 
+	using HostViewType 		= typename DVType::t_host;
 
-  	// - viewType of data on host
-  	using HostViewType 		= typename DualViewType::t_host;
+	/// Host memory type
+	using HostType 			= typename HostViewType::device_type;
 
-  	using HostType 			= typename HostViewType::device_type;
-
-  	using DeviceType 		= typename DeviceViewType::device_type;
+	/// Device memory ype
+	using DeviceType 		= typename DeviceViewType::device_type;
 
+	/**
+	 * Helper class for accessing index on host or device 
+	 */
   	template<typename ViewType>
   	class IndexAccessor
   	{
@@ -58,169 +67,207 @@ public:
   		view_(v){}
 
   		INLINE_FUNCTION_HD
-  		IndexType operator()(int32 i)const
+  		IndexType operator()(uint32 i)const
   		{
   			return view_[i];
   		}
+
+  		uint32 size()const
+  		{
+  			return view_.extent(0);
+  		}
   	};
 
 protected:
 
-	int32 		min_  	= 0;
-	int32 		max_ 	= 0;
-	size_t 		size_	= 0; 	
+	/// min value in indices
+	IndexType 		min_  	= 0;
 
-	DualViewType 	views_;
+	/// max value in the indices
+	IndexType 		max_ 	= 0;
+
+	/// number/size of index vector 
+	uint32 			size_	= 0; 	
+
+	/// views to hold indices on Host and Device
+	DVType 			views_;
 
 public:
 
-	indexContainer(){}
+	//// - Constructors 
 
-	// half open [begin,end)
-	indexContainer(IndexType begin, IndexType end)
-	:
-		min_(begin),
-		max_(end-1),
-		size_(end-begin),
-		views_("indexContainer", size_)
-	{
-		pFlow::fillSequence(views_.h_view, 0, size_, min_);
-		copy(views_.d_view, views_.h_view);
-	}
+		/// Default
+		indexContainer(){}
 
+		/// Construct from a Range (half open)
+		template<typename T>
+		indexContainer(const Range<T>& rng)
+		:
+			indexContainer
+			(
+				static_cast<IndexType>(rng.begin()), 
+				static_cast<IndexType>(rng.end())
+			)
+		{}
 
-	indexContainer(IndexType* data, int32 numElems)
-	:
-		size_(numElems),
-		views_("indexContainer", numElems)
-	{
-		HostViewType hData(data, numElems);
-		copy(views_.h_view, hData);
-		copy(views_.d_view, views_.h_view);
-		min_ 	= pFlow::min(views_.d_view, 0, numElems);
-		max_ 	= pFlow::max(views_.d_view, 0, numElems);
-	}
-
-	indexContainer(const indexContainer&) = default;
-
-	indexContainer& operator = (const indexContainer&) = default;
-
-	indexContainer(indexContainer&&) = default;
-
-	indexContainer& operator = (indexContainer&&) = default;	
-
-	~indexContainer() = default;
-
-	INLINE_FUNCTION_HD
-	size_t size()const
-	{
-		return size_;
-	}
-
-	INLINE_FUNCTION_HD
-	size_t empty()const
-	{
-		return size_==0;
-	}
-	
-	INLINE_FUNCTION_HD
-	IndexType min()const
-	{
-		return min_;
-	}
-
-	INLINE_FUNCTION_HD
-	IndexType max()const
-	{
-		return max_;
-	}
-
-	template<typename executionSpace>
-	INLINE_FUNCTION_HD
-	IndexType operator()(selectSide<executionSpace>,int32 i)const
-	{	
-		if constexpr (isHostAccessible<executionSpace>())
+		/// Construct half open [begin,end)
+		indexContainer(IndexType begin, IndexType end)
+		:
+			min_(begin),
+			max_(end-1),
+			size_(end-begin),
+			views_("indexContainer", size_)
 		{
-			return views_.h_view(i);
-		}else
-		{
-			return views_.d_view(i);
-		}
-	}
-
-	const HostViewType& hostView()const
-	{
-		return views_.h_view;
-	}
-
-	const DeviceViewType& deviceView()const
-	{
-		return views_.d_view;
-	}
-
-	HostViewType& hostView()
-	{
-		return views_.h_view;
-	}
-
-	DeviceViewType& deviceView()
-	{
-		return views_.d_view;
-	}
-
-	auto indicesHost()const
-	{
-		return IndexAccessor<HostViewType>(views_.h_view);
-	}
-
-	auto indicesDevice()const
-	{
-		return IndexAccessor<DeviceViewType>(views_.d_view);
-	}
-
-	void modifyOnHost()
-	{
-		views_.modify_host();
-	}
-
-	void modifyOnDevice()
-	{
-		views_.modify_device();
-	}
-
-	void syncViews()
-	{
-		bool findMinMax = false;
-		if(views_.template need_sync<HostType>())
-		{
-			Kokkos::deep_copy(views_.d_view, views_.h_view);
-			findMinMax = true;
-		}
-		else if(views_.template need_sync<DeviceType>())
-		{
-			Kokkos::deep_copy(views_.h_view, views_.d_view);
-			findMinMax = true;
+			pFlow::fillSequence(views_.h_view, 0, size_, min_);
+			copy(views_.d_view, views_.h_view);
 		}
 
-		if(findMinMax)
+		/// From data and number of elements in data. 
+		/// data is a pointer in the Host memory 
+		indexContainer(IndexType* data, int32 numElems)
+		:
+			size_(numElems),
+			views_("indexContainer", numElems)
 		{
-			min_ 	= pFlow::min(views_.d_view, 0, size_);
-			max_ 	= pFlow::max(views_.d_view, 0, size_);
+			HostViewType hData(data, numElems);
+			copy(views_.h_view, hData);
+			copy(views_.d_view, views_.h_view);
+			min_ 	= pFlow::min(views_.d_view, 0, numElems);
+			max_ 	= pFlow::max(views_.d_view, 0, numElems);
+		}
+
+		indexContainer(std::vector<IndexType> &ind)
+		:
+			indexContainer(ind.data(), ind.size())
+		{}
+
+		/// Copy
+		indexContainer(const indexContainer&) = default;
+
+		/// Copy assignment
+		indexContainer& operator = (const indexContainer&) = default;
+
+		/// Move
+		indexContainer(indexContainer&&) = default;
+
+		/// Mover assignement 
+		indexContainer& operator = (indexContainer&&) = default;	
+
+		/// Destructor
+		~indexContainer() = default;
+
+	//// - Methods 
+
+		/// Size 
+		INLINE_FUNCTION_HD
+		auto size()const
+		{
+			return size_;
+		}
+
+		/// If the container empty
+		INLINE_FUNCTION_HD
+		bool empty()const
+		{
+			return size_==0;
+		}
+		
+		/// Min value of indices 
+		INLINE_FUNCTION_HD
+		IndexType min()const
+		{
+			return min_;
+		}
+
+		/// Max value of indices 
+		INLINE_FUNCTION_HD
+		IndexType max()const
+		{
+			return max_;
+		}
+
+		/// Return Host veiw
+		const HostViewType& hostView()const
+		{
+			return views_.h_view;
+		}
+
+		/// Return Device view
+		const DeviceViewType& deviceView()const
+		{
+			return views_.d_view;
+		}
+
+		/// Return Host veiw
+		HostViewType& hostView()
+		{
+			return views_.h_view;
+		}
+
+		/// Return Device veiw
+		DeviceViewType& deviceView()
+		{
+			return views_.d_view;
+		}
+
+		/// Return index accessor that works on Host
+		auto indicesHost()const
+		{
+			return IndexAccessor<HostViewType>(views_.h_view);
+		}
+
+		/// Return index accessor that works on Device 
+		auto indicesDevice()const
+		{
+			return IndexAccessor<DeviceViewType>(views_.d_view);
+		}
+
+		/// Mark host is modified 
+		void modifyOnHost()
+		{
+			views_.modify_host();
+		}
+
+		/// Mark device is modified
+		void modifyOnDevice()
+		{
+			views_.modify_device();
+		}
+
+		/// synchronize views 
+		void syncViews()
+		{
+			bool findMinMax = false;
+			if(views_.template need_sync<HostType>())
+			{
+				Kokkos::deep_copy(views_.d_view, views_.h_view);
+				views_.clear_sync_state();
+				findMinMax = true;
+			}
+			else if(views_.template need_sync<DeviceType>())
+			{
+				Kokkos::deep_copy(views_.h_view, views_.d_view);
+				views_.clear_sync_state();
+				findMinMax = true;
+			}
+
+			if(findMinMax)
+			{
+				min_ 	= pFlow::min(views_.d_view, 0, size_);
+				max_ 	= pFlow::max(views_.d_view, 0, size_);
+			}
 		}
-	}
 
-	size_t setSize(size_t ns)
-	{
-		auto tmp = size_;
-		size_ = ns;
-		return tmp;
-	}
 };
 
 
+
 using int32IndexContainer = indexContainer<int32>;
 using int64IndexContainer = indexContainer<int64>;
 
+using uint32IndexContainer = indexContainer<uint32>;
+using uint64IndexContainer = indexContainer<uint64>;
+
 
 }
 
diff --git a/src/phasicFlow/containers/pointField/boundaryField/boundaryField.cpp b/src/phasicFlow/containers/pointField/boundaryField/boundaryField.cpp
new file mode 100644
index 00000000..b4a90c13
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryField/boundaryField.cpp
@@ -0,0 +1,63 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+template<class T, class MemorySpace>
+pFlow::boundaryField<T, MemorySpace>::boundaryField
+(
+	const boundaryBase& boundary, 
+	InternalFieldType& internal
+)
+:
+	observer(&boundary, defaultMessage_),
+	boundary_(boundary),
+	internal_(internal)
+{}
+
+
+template<class T, class MemorySpace>
+pFlow::uniquePtr<pFlow::boundaryField<T, MemorySpace>>
+	pFlow::boundaryField<T, MemorySpace>::create
+(
+	const boundaryBase& boundary, 
+	InternalFieldType& internal
+)
+{
+
+	word bType = angleBracketsNames("boundaryField", boundary.type());
+
+	if(boundaryBasevCtorSelector_.search(bType))
+	{
+		return boundaryBasevCtorSelector_[bType](boundary, internal);
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< bType << "for type "<< 
+			Yellow_Text(getTypeName<T>())	<< " dose not exist.\n"
+			<<"Avaiable ones are: \n\n"
+			,
+			boundaryBasevCtorSelector_
+		);
+		fatalExit;
+
+	}
+	return nullptr;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/boundaryField/boundaryField.hpp b/src/phasicFlow/containers/pointField/boundaryField/boundaryField.hpp
new file mode 100644
index 00000000..d9473a05
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryField/boundaryField.hpp
@@ -0,0 +1,135 @@
+/*------------------------------- 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 __boundaryField_hpp__
+#define __boundaryField_hpp__
+
+#include "observer.hpp"
+#include "boundaryBase.hpp"
+#include "internalField.hpp"
+
+namespace pFlow
+{
+
+template< class T, class MemorySpace = void>
+class boundaryField
+:
+    public observer 
+{
+public:
+	
+	using BoundaryFieldType = boundaryField<T, MemorySpace>;
+
+	using InternalFieldType = internalField<T, MemorySpace>;
+
+	using memory_space 		= typename InternalFieldType::memory_space;
+
+	using execution_space 	= typename InternalFieldType::execution_space;
+
+protected:
+
+    const boundaryBase&     boundary_;
+
+    /// @brief a ref to the internal field 
+    InternalFieldType& 			internal_;
+
+	static inline
+	const message defaultMessage_ = 
+	(
+		message::BNDR_RESET		
+	);
+
+public:
+
+	TypeInfo("boundaryField<none>");
+
+	boundaryField(
+		const boundaryBase& boundary, 
+		InternalFieldType& internal);
+	
+	create_vCtor
+	(
+		boundaryField,
+		boundaryBase,
+		(
+			const boundaryBase& boundary, 
+			InternalFieldType& internal
+		),
+		(boundary, internal)
+	);
+
+
+	add_vCtor
+	(
+		BoundaryFieldType,
+		BoundaryFieldType,
+		boundaryBase
+	);
+
+
+	bool hearChanges
+	(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+    	const anyList& varList
+	) override
+    {
+		
+		if(msg.equivalentTo(message::BNDR_REARRANGE))
+		{
+			// do nothing
+		}
+		if(msg.equivalentTo(message::BNDR_RESET))
+		{
+			//do nothing
+		}
+		return true;
+	}
+
+	auto size()const
+	{
+		return boundary_.size();
+	}
+
+	auto capacity()const
+	{
+		return boundary_.capacity();
+	}
+
+	virtual
+	void fill(const T& val)
+	{
+		return ;
+	}
+
+	static
+	uniquePtr<boundaryField> create(
+		const boundaryBase& boundary, 
+		InternalFieldType& internal);
+
+};
+
+}
+
+#include "boundaryField.cpp"
+
+#endif
+
diff --git a/src/phasicFlow/containers/pointField/boundaryField/createBoundaryFields.hpp b/src/phasicFlow/containers/pointField/boundaryField/createBoundaryFields.hpp
new file mode 100644
index 00000000..3403149d
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryField/createBoundaryFields.hpp
@@ -0,0 +1,36 @@
+/*------------------------------- 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 __createBoundaryFields_hpp__
+#define __createBoundaryFields_hpp__
+
+#include "boundaryField.hpp"
+#include "exitBoundaryField.hpp"
+
+#define createBaseBoundary(DataType, MemorySpaceType)          \
+    template class pFlow::boundaryField<DataType, MemorySpaceType>;
+    
+
+#define createBoundary(DataType, MemorySpaceType, BoundaryType)    \
+    template class pFlow::BoundaryType##BoundaryField<DataType, MemorySpaceType>;
+
+
+#endif //__createBoundaryFields_hpp__
+    
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField.cpp b/src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField.cpp
new file mode 100644
index 00000000..2556a8d8
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField.cpp
@@ -0,0 +1,31 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+template<class T, class MemorySpace>
+    pFlow::exitBoundaryField<T, MemorySpace>::exitBoundaryField
+(
+	const boundaryBase& boundary, 
+	InternalFieldType& internal
+)
+:
+    BoundaryFieldType(boundary, internal)
+{
+	this->addEvent(message::BNDR_DELETE);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField.hpp b/src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField.hpp
new file mode 100644
index 00000000..8c5fcb57
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryField/exitBoundaryField.hpp
@@ -0,0 +1,89 @@
+/*------------------------------- 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 __exitBoundaryField_hpp__
+#define __exitBoundaryField_hpp__
+
+#include "boundaryField.hpp"
+
+namespace pFlow
+{
+
+template< class T, class MemorySpace = void>
+class exitBoundaryField
+:
+    public boundaryField<T, MemorySpace> 
+{
+public:
+	
+    using ExitBoundaryFieldType = exitBoundaryField<T, MemorySpace>;
+
+	using BoundaryFieldType = boundaryField<T, MemorySpace>;
+
+	using InternalFieldType = typename BoundaryFieldType::InternalFieldType;
+
+	using memory_space 		= typename BoundaryFieldType::memory_space;
+
+	using execution_space 	= typename BoundaryFieldType::execution_space;
+
+   
+
+public:
+
+	TypeInfo("boundaryField<exit>");
+
+	exitBoundaryField(
+		const boundaryBase& boundary, 
+		InternalFieldType& internal);
+		
+
+	add_vCtor
+	(
+		BoundaryFieldType,
+		ExitBoundaryFieldType,
+		boundaryBase
+	);
+
+
+	bool hearChanges
+	(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+    	const anyList& varList
+	) override
+    {
+		BoundaryFieldType::hearChanges(t,dt,iter, msg,varList);
+		
+		if(msg.equivalentTo(message::BNDR_DELETE))
+		{
+			// do nothing;
+		}
+		
+		return true;
+	}
+
+};
+
+}
+
+#include "exitBoundaryField.cpp"
+
+#endif
diff --git a/src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField.cpp b/src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField.cpp
new file mode 100644
index 00000000..c6b449f9
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField.cpp
@@ -0,0 +1,32 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+template<class T, class MemorySpace>
+    pFlow::periodicBoundaryField<T, MemorySpace>::periodicBoundaryField
+(
+	const boundaryBase& boundary, 
+	InternalFieldType& internal
+)
+:
+	BoundaryFieldType(boundary, internal)
+{
+	this->addEvent(message::BNDR_APPEND)
+		 .addEvent(message::BNDR_TRANSFER);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField.hpp b/src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField.hpp
new file mode 100644
index 00000000..9d93f2b2
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryField/periodicBoundaryField.hpp
@@ -0,0 +1,92 @@
+/*------------------------------- 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 __periodicBoundaryField_hpp__
+#define __periodicBoundaryField_hpp__
+
+#include "boundaryField.hpp"
+
+namespace pFlow
+{
+
+template< class T, class MemorySpace = void>
+class periodicBoundaryField
+:
+    public boundaryField<T, MemorySpace> 
+{
+public:
+	
+    using periodicBoundaryFieldType = periodicBoundaryField<T, MemorySpace>;
+
+	using BoundaryFieldType = boundaryField<T, MemorySpace>;
+
+	using InternalFieldType = typename BoundaryFieldType::InternalFieldType;
+
+	using memory_space 		= typename BoundaryFieldType::memory_space;
+
+	using execution_space 	= typename BoundaryFieldType::execution_space;
+
+   
+
+public:
+
+	TypeInfo("boundaryField<periodic>");
+
+	periodicBoundaryField(
+		const boundaryBase& boundary, 
+		InternalFieldType& internal);
+		
+
+	add_vCtor
+	(
+		BoundaryFieldType,
+		periodicBoundaryFieldType,
+		boundaryBase
+	);
+
+
+	bool hearChanges
+	(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+    	const anyList& varList
+	) override
+    {
+		BoundaryFieldType::hearChanges(t,dt,iter, msg,varList);
+		
+		if(msg.equivalentTo(message::BNDR_APPEND))
+		{
+			// do nothing;
+		}
+		if(msg.equivalentTo(message::BNDR_TRANSFER))
+		{
+			//do nothing 
+		}
+		return true;
+	}
+
+};
+
+}
+
+#include "periodicBoundaryField.cpp"
+
+#endif
diff --git a/src/phasicFlow/containers/pointField/boundaryFieldList.hpp b/src/phasicFlow/containers/pointField/boundaryFieldList.hpp
new file mode 100644
index 00000000..4de85bf6
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/boundaryFieldList.hpp
@@ -0,0 +1,75 @@
+/*------------------------------- 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 __boundaryFieldList_hpp__
+#define __boundaryFieldList_hpp__
+
+#include "boundaryField.hpp"
+#include "boundaryList.hpp"
+#include "ListPtr.hpp"
+
+namespace pFlow
+{
+
+template< class T, class MemorySpace = void >
+class boundaryFieldList
+:
+    public ListPtr< boundaryField<T, MemorySpace> >
+{
+public:
+
+    using BoundaryFieldType = boundaryField<T, MemorySpace>;
+
+    using InternalFieldType = typename BoundaryFieldType::InternalFieldType;
+    
+
+protected:
+
+    const boundaryList&         boundaries_;
+
+public:
+
+    boundaryFieldList(const boundaryList& boundaries, InternalFieldType& internal)
+    :
+        ListPtr<BoundaryFieldType>(boundaries.size()),
+        boundaries_(boundaries)
+    {
+        for(auto i=0; i<boundaries.size(); i++)
+        {
+            this->set
+            (
+                i, 
+                BoundaryFieldType::create(boundaries_[i], internal)
+            );
+        }
+    }
+
+    void fill(const T& val)
+    {
+        for(auto& bf: *this)
+        {
+            bf->fill(val);
+        }
+    }
+
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/internalField.cpp b/src/phasicFlow/containers/pointField/internalField.cpp
new file mode 100644
index 00000000..99bd7860
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/internalField.cpp
@@ -0,0 +1,150 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+template<class T, class MemorySpace>
+pFlow::internalField<T, MemorySpace>::internalField
+(
+	const word& name, 
+	const internalPoints& internal
+)
+:
+    observer
+    (
+		&internal, 
+		defaultMessage_
+    ),
+	field_
+	(
+		name,
+		"ineternalField",
+		internal.capacity(),
+		internal.size(),
+		RESERVE()
+	),
+	internalPoints_(internal)
+{}
+
+template<class T, class MemorySpace>
+pFlow::internalField<T, MemorySpace>::internalField
+(
+	const word &name, 
+	const internalPoints &internal, 
+	const T &val
+)
+:
+	observer
+    (
+		&internal, 
+		defaultMessage_
+    ),
+	field_
+	(
+		name,
+		"ineternalField",
+		internal.capacity(),
+		internal.size(),
+		RESERVE()
+	),
+	internalPoints_(internal)
+{
+	fillInternal(val);
+} 
+
+
+template <class T, class MemorySpace>
+typename pFlow::internalField<T, MemorySpace>::FieldTypeHost 
+	pFlow::internalField<T, MemorySpace>::activeValuesHost() const
+{
+	auto maskH = internalPoints_.activePointsMaskHost();
+    auto fieldH = field_.hostView();
+
+	FieldTypeHost aField
+	(
+		field_.name(), 
+		field_.fieldKey(),
+		maskH.numActive(),
+		maskH.numActive(),
+		RESERVE()
+	);
+
+    auto aRange = maskH.activeRange();
+
+	uint32 n = 0;
+    for(auto i=aRange.start(); i<aRange.end(); i++)
+    {
+        if( maskH.isActive(i) )
+        {
+            aField[n] = fieldH[i];
+            n++;
+        }
+    }
+    return aField;
+}
+
+template <class T, class MemorySpace>
+bool pFlow::internalField<T, MemorySpace>:: hearChanges
+(
+	real t,
+	real dt,
+	uint32 iter,
+	const message& msg, 
+	const anyList& varList
+)
+{
+	if(msg.equivalentTo(message::CAP_CHANGED))
+	{
+		auto newCap = varList.getObject<uint32>(
+			message::eventName(message::CAP_CHANGED));
+
+		field_.reserve(newCap);
+	}
+	if(msg.equivalentTo(message::SIZE_CHANGED))
+	{
+		auto newSize = varList.getObject<uint32>(
+			message::eventName(message::SIZE_CHANGED));
+		field_.resize(newSize);
+	}
+	if(msg.equivalentTo(message::ITEM_DELETE))
+	{
+		// do nothing
+	}
+	if(msg.equivalentTo(message::ITEM_REARRANGE))
+	{
+		notImplementedFunction;
+		return false;
+	}
+	if(msg.equivalentTo(message::ITEM_INSERT))
+	{
+		notImplementedFunction;
+		return false;
+	}
+	return true;
+}
+
+template<class T, class MemorySpace>
+bool pFlow::internalField<T, MemorySpace>::write
+(
+	iOstream& os, 
+	const IOPattern& iop
+)const
+{
+	auto aField = activeValuesHost();
+	return aField.write(os, iop);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/internalField.hpp b/src/phasicFlow/containers/pointField/internalField.hpp
new file mode 100644
index 00000000..92ba1bf6
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/internalField.hpp
@@ -0,0 +1,207 @@
+/*------------------------------- 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 __internalField_hpp__
+#define __internalField_hpp__
+
+#include "internalPoints.hpp"
+#include "Field.hpp"
+#include "observer.hpp"
+#include "dataIO.hpp"
+#include "anyList.hpp"
+
+
+namespace pFlow
+{
+
+template<class T, class MemorySpace=void>
+class internalField
+:
+    public observer
+{
+
+public:
+	
+	using InternalFieldType = internalField<T, MemorySpace>;
+
+	using FieldType         = Field<T, MemorySpace>;
+
+	using FieldTypeHost 	= Field<T, HostSpace>;
+  	
+	using VectorType  		= typename FieldType::VectorType;
+
+	using memory_space 		= typename FieldType::memory_space;
+
+	using execution_space 	= typename FieldType::execution_space;
+
+protected:
+
+    FieldType           	field_;
+
+    const internalPoints&   internalPoints_;
+
+	static inline
+	const message defaultMessage_ = 
+	(
+		message::CAP_CHANGED+
+		message::SIZE_CHANGED+
+		message::ITEM_INSERT+
+		message::ITEM_REARRANGE+
+		message::ITEM_DELETE
+	);
+
+public:
+
+	internalField(
+		const word& name, 
+		const internalPoints& internal);
+	
+	internalField(
+		const word& name, 
+		const internalPoints& internal,
+		const T& val);
+	
+	inline 
+	const auto& deviceViewAll()const
+	{
+		return field_.deviceViewAll();
+	}
+	inline
+	auto deviceView()const
+	{
+		return field_.deviceView();
+	}
+
+	inline
+	auto hostView()const
+	{
+		return field_.hostView();
+	}
+
+	inline
+	const FieldType& field()const
+	{
+		return field_;
+	}
+
+	inline
+	FieldType& field()
+	{
+		return field_;
+	}
+
+	const pFlagTypeDevice& activePointsMaskDevice()const
+	{
+		return internalPoints_.activePointsMaskDevice();
+	}
+	
+	const pFlagTypeHost& activePointsMaskHost()const
+	{
+		return internalPoints_.activePointsMaskHost();
+	}
+
+	FieldTypeHost activeValuesHost()const;
+
+	inline
+	auto size()const
+	{
+		return field_.size();
+	}
+
+	inline
+	auto capacity()const
+	{
+		return field_.capacity();
+	}
+
+	inline 
+	word name()const
+	{
+		return field_.name();
+	}
+
+	inline 
+	word fieldKey()const
+	{
+		return field_.fieldKey();
+	}
+
+	inline
+	auto activeRange()const
+	{
+		return internalPoints_.activeRange();
+	}
+
+	inline
+	auto isAllActive()const
+	{
+		return internalPoints_.isAllActive();
+	}
+
+	inline 
+	void fillInternal(const T& val)
+	{
+		field_.fillField(activeRange(), val);
+	}
+
+	inline 
+	bool insertSetElement(uint32IndexContainer indices, const T& val)
+	{
+		return field_.insertSetElement(indices, val);
+	}
+
+	bool hearChanges
+	(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+		const anyList& varList
+	) override;
+	
+
+	//// - IO
+
+	bool write(iOstream& os, const IOPattern& iop)const;
+
+};
+
+template<class T, class MemorySpace>
+inline
+iOstream& operator<<
+(
+	iOstream& os, 
+	const internalField<T,  MemorySpace>& ifeild
+)
+{
+	if( !ifeild.write(os, IOPattern::AllProcessorsDifferent) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+
+	return os;
+}
+
+} // pFlow
+
+#include "internalField.cpp"
+#include "internalFieldAlgorithms.hpp"
+
+#endif // __internalField_hpp__
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/internalFieldAlgorithms.hpp b/src/phasicFlow/containers/pointField/internalFieldAlgorithms.hpp
new file mode 100644
index 00000000..118fb21c
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/internalFieldAlgorithms.hpp
@@ -0,0 +1,256 @@
+/*------------------------------- 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 __internalFieldAlgorithms_hpp__
+#define __internalFieldAlgorithms_hpp__
+
+namespace pFlow
+{
+
+template<class T, class MemorySpace>
+inline 
+T min(const internalField<T,MemorySpace>& iField)
+{   
+    using exeSpace = typename internalField<T,MemorySpace>::execution_space;
+
+    using policy = Kokkos::RangePolicy<
+			exeSpace,
+			Kokkos::IndexType<uint32> >;
+
+    if constexpr(isDeviceAccessible<exeSpace>())
+    {
+        // this is a device view 
+        auto maskD = iField.activePointsMaskDevice();
+        auto aRange = maskD.activeRange();
+        auto filed = iField.field().deviceViewAll();
+
+        T minElement;
+        
+        Kokkos::parallel_reduce(
+		"min(internalField)",
+		policy(aRange.start(), aRange.end() ),
+		LAMBDA_HD(uint32 i, T& minUpdate)
+        {
+			if( maskD(i) )
+                if(filed[i] < minUpdate) minUpdate = filed[i];
+		},
+		Kokkos::Min<T>(minElement));
+	    return minElement;
+    }
+    else
+    {
+        // this is a host view 
+        auto maskH = iField.activePointsMaskHost();
+        auto aRange = maskH.activeRange();
+        auto filed = iField.field().deviceViewAll();
+        T minElement;
+        Kokkos::parallel_reduce(
+            "min(internalField)",
+            policy(aRange.start(), aRange.end()),
+            LAMBDA_HD(uint32 i, T& minUpdate)
+            {
+                if( maskH(i) )
+                    if(filed[i] < minUpdate) minUpdate = filed[i];
+            },
+            Kokkos::Min<T>(minElement));
+
+	    return minElement;
+    }
+}
+
+template<class T, class MemorySpace>
+inline 
+T max(const internalField<T,MemorySpace>& iField)
+{   
+    using exeSpace = typename internalField<T,MemorySpace>::execution_space;
+
+    using policy = Kokkos::RangePolicy<
+			exeSpace,
+			Kokkos::IndexType<uint32> >;
+
+    if constexpr(isDeviceAccessible<exeSpace>())
+    {
+        // this is a device view 
+        auto maskD = iField.activePointsMaskDevice();
+        auto aRange = maskD.activeRange();
+        auto filed = iField.field().deviceViewAll();
+
+        T maxElement;
+        
+        Kokkos::parallel_reduce(
+		"max(internalField)",
+		policy(aRange.start(), aRange.end() ),
+		LAMBDA_HD(uint32 i, T& maxUpdate)
+        {
+			if( maskD(i) )
+                if( maxUpdate <filed[i]) maxUpdate = filed[i];
+		},
+		Kokkos::Max<T>(maxElement));
+	    return maxElement;
+    }
+    else
+    {
+        // this is a host view 
+        auto maskH = iField.activePointsMaskHost();
+        auto aRange = maskH.activeRange();
+        auto filed = iField.field().deviceViewAll();
+
+        T maxElement;
+        
+        Kokkos::parallel_reduce(
+		"max(internalField)",
+		policy(aRange.start(), aRange.end() ),
+		LAMBDA_HD(uint32 i, T& maxUpdate)
+        {
+			if( maskH(i) )
+                if( maxUpdate <filed[i]) maxUpdate = filed[i];
+		},
+		Kokkos::Max<T>(maxElement));
+	    return maxElement;
+    }
+}
+
+
+template<class T, class MemorySpace>
+inline 
+Pair<T,T> minMax(const internalField<T,MemorySpace>& iField)
+{   
+    using exeSpace = typename internalField<T,MemorySpace>::execution_space;
+
+    using policy = Kokkos::RangePolicy<
+			exeSpace,
+			Kokkos::IndexType<uint32> >;
+
+    if constexpr(isDeviceAccessible<exeSpace>())
+    {
+        // this is a device view 
+        auto maskD = iField.activePointsMaskDevice();
+        auto aRange = maskD.activeRange();
+        auto filed = iField.field().deviceViewAll();
+
+        T minElement;
+        T maxElement;
+        
+        Kokkos::parallel_reduce(
+		"minMax(internalField)",
+		policy(aRange.start(), aRange.end() ),
+		LAMBDA_HD(uint32 i, T& minUpdate, T& maxUpdate)
+        {
+			if( maskD(i) )
+            {
+                if(maxUpdate < filed[i]) maxUpdate = filed[i];
+                if(filed[i] < minUpdate) minUpdate = filed[i];
+            }
+                
+		},
+		Kokkos::Min<T>(minElement),
+        Kokkos::Max<T>(maxElement)
+        );
+	    return {minElement, maxElement};
+    }
+    else
+    {
+        // this is a host view 
+        auto maskH = iField.activePointsMaskHost();
+        auto aRange = maskH.activeRange();
+        auto filed = iField.field().deviceViewAll();
+
+        T minElement;
+        T maxElement;
+        
+        Kokkos::parallel_reduce(
+		"minMax(internalField)",
+		policy(aRange.start(), aRange.end() ),
+		LAMBDA_HD(uint32 i, T& minUpdate, T& maxUpdate)
+        {
+			if( maskH(i) )
+            {
+                if(maxUpdate < filed[i]) maxUpdate = filed[i];
+                if(filed[i] < minUpdate) minUpdate = filed[i];
+            }
+                
+		},
+		Kokkos::Min<T>(minElement),
+        Kokkos::Max<T>(maxElement)
+        );
+	    return {minElement, maxElement};
+    }
+}
+
+template<class T, class MemorySpace>
+inline 
+void fillSequence(internalField<T,MemorySpace>& iField, const T& startVal)
+{
+    using exeSpace = typename internalField<T,MemorySpace>::execution_space;
+
+    using policy = Kokkos::RangePolicy<
+			exeSpace,
+			Kokkos::IndexType<uint32> >;
+
+    if constexpr(isDeviceAccessible<exeSpace>())
+    {               
+        auto maskD = iField.activePointsMaskDevice();
+        auto aRange = maskD.activeRange();
+        auto field = iField.field().deviceViewAll();
+        auto aPoints = maskD.getActivePoints();
+        exclusiveScan(aPoints,0, aRange.end(), aPoints,0);
+        
+        Kokkos::parallel_for(
+            "internalField::fillSequence",
+            policy(aRange.start(), aRange.end() ),
+            LAMBDA_HD(uint32 i)
+            {
+                if(maskD(i))
+                {
+                    field[i] = aPoints[i]+startVal;
+                }
+            });
+        Kokkos::fence();
+    }
+    else
+    {
+        // this is a host view 
+        auto maskH = iField.activePointsMaskHost();
+        auto aRange = maskH.activeRange();
+        auto field = iField.field().deviceViewAll();
+        auto aPoints = maskH.getActivePoints();
+        exclusiveScan(aPoints,0, aRange.end(), aPoints,0);
+        
+        Kokkos::parallel_for(
+            "internalField::fillSequence",
+            policy(aRange.start(), aRange.end() ),
+            LAMBDA_HD(uint32 i)
+            {
+                if(maskH(i))
+                {
+                    field[i] = aPoints[i]+startVal;
+                }
+            });
+        Kokkos::fence();
+    }
+}
+
+}
+
+
+
+
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/pointField copy.hpp b/src/phasicFlow/containers/pointField/pointField copy.hpp
new file mode 100644
index 00000000..791b5b32
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/pointField copy.hpp	
@@ -0,0 +1,204 @@
+/*------------------------------- 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 __internalField_hpp__
+#define __internalField_hpp__
+
+#include "pointStructure.hpp"
+#include "Field.hpp"
+#include "observer.hpp"
+
+
+namespace pFlow
+{
+
+template<template<class, class> class VectorField, class T, class MemorySpace=void>
+class internalField
+:
+	public observer,
+	public Field<VectorField, T, MemorySpace>
+{
+public:
+	
+	using pointFieldType 	= pointField<VectorField, T, MemorySpace>;
+	
+	using FieldType         = Field<VectorField, T, MemorySpace>;
+
+    using boundaryFieldListType = boundaryFieldList<VectorField, T, MemorySpace>;
+  	
+  	using VectorType  		= typename FieldType::VectorType;
+
+	using iterator        	= typename FieldType::iterator;
+
+  	using const_iterator   	= typename FieldType::const_iterator;
+
+	using reference       	= typename FieldType::reference;
+  	
+  	using const_reference  	= typename FieldType::const_reference;
+
+	using value_type       	= typename FieldType::value_type;
+  	
+  	using pointer         	= typename FieldType::pointer;
+  	
+  	using const_pointer    	= typename FieldType::const_pointer;
+
+protected:
+
+    //// - data members 
+
+        /// @brief list of boundaries
+        boundaryFieldListType       boundaryFieldList_;
+        
+		/// @brief  refrence to point structure 
+		const pointStructure&       pStruct_;
+
+		/// @brief value when a new item is added to field
+		T 	defaultValue_;
+
+
+public:
+ 
+	// - type info
+	TypeInfoTemplateNV2("pointField", T, VectorType::memoerySpaceName());
+
+	
+	//// - Constructors
+
+		// - construct a field from pointStructure and set defaultValue_ and field value to defVal
+		pointField(
+			const objectFile& objf, 
+            pointStructure& pStruct, 
+            const T& defVal);
+
+		// - construct from iIOEntity, pointStructure and a value
+		/*pointField( const pointStructure& pStruct, const T& val, const T& defVal, bool subscribe = true);
+
+		// - construct from another pointField
+		//   subscribe to events if true
+		pointField( const pointField& src, bool subscribe);
+
+
+		// - copy construct 
+		pointField(const pointField& src);
+
+		// - no move construct
+		pointField(pointField&& src) = delete;
+
+
+		// assignment, only assign the VectorField and preserve other parts of this 
+		pointField& operator = (const pointField& rhs);
+
+		// no move assignment 
+		pointField& operator = (pointField&&) = delete;		
+
+
+		inline uniquePtr<pointFieldType> clone() const
+		{
+			return makeUnique<pointFieldType>(*this);
+		}
+
+		inline pointFieldType* clonePtr()const
+		{
+			return new pointFieldType(*this);
+		}
+
+	//// - Methods
+
+		// - reference to pointStructure
+		inline const pointStructure& pStruct()const {
+			return pStruct_;
+		}
+
+		// if all points are active 
+		INLINE_FUNCTION_H
+		bool allActive()const {	
+			return pStruct_.allActive();
+		}
+		
+
+		INLINE_FUNCTION_H
+		bool isActive(label i)const {
+			return pStruct_.isActive(i);
+		}
+
+		const auto& pointFlag()const
+		{
+			return pStruct_.pointFlag();
+		}
+
+		range activeRange()const
+		{
+			return pStruct_.activeRange();
+		}
+
+		// - update the field if any changes occure in pStruct 
+		//   for now it checks for deleted points
+		bool update(const eventMessage& msg);
+
+
+	//// -  IO operations
+		bool readPointField(iIstream& is);
+
+		bool writePointField(iOstream& os)const;
+
+
+		bool read(iIstream& is)
+		{
+			return readPointField(is);
+		}
+
+		bool write(iOstream& os)const
+		{
+			return writePointField(os);
+		}*/
+};
+
+/*template<template<class, class> class VectorField, class T, class MemorySpace>
+iIstream& operator >> (iIstream & is, pointField<VectorField, T, MemorySpace> & pF )
+{
+	if( !pF.read(is))
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		"error in reading pointField from file. \n";
+		fatalExit;
+	}
+
+	return is;
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+iOstream& operator << (iOstream& os, const pointField<VectorField, T, MemorySpace>& pF )
+{
+	if(! pF.write(os) )
+	{
+		ioErrorInFile( os.name(), os.lineNumber() )<<
+		"error in writing pointField into file. \n";
+		fatalExit;
+	}
+
+	return os;
+}*/
+
+}
+
+#include "pointField.cpp"
+//#include "pointFieldAlgorithms.hpp"
+
+#endif //  __pointField_hpp__
diff --git a/src/phasicFlow/containers/pointField/pointField.cpp b/src/phasicFlow/containers/pointField/pointField.cpp
index bc0a62e0..0a6315ab 100644
--- a/src/phasicFlow/containers/pointField/pointField.cpp
+++ b/src/phasicFlow/containers/pointField/pointField.cpp
@@ -18,119 +18,273 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
-template<template<class, class> class VectorField, class T, class MemorySpace>
-bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField
+template<class T, class MemorySpace>
+pFlow::pointField<T, MemorySpace>::pointField
 (
-	iIstream& is
-)
-{
-	
-	return FieldType::readField(is, pStruct_.size(), false);
-}
-
-template<template<class, class> class VectorField, class T, class MemorySpace>
-bool pFlow::pointField<VectorField, T, MemorySpace>::writePointField
-(
-	iOstream& os
-)const
-{
-	return FieldType::write(os);
-}
-
-
-
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::pointField<VectorField, T, MemorySpace>::pointField
-(
-	const pointStructure& pStruct,
-	const T& defVal,
-	bool subscribe
+    const objectFile& objf, 
+	pointStructure& pStruct, 
+	const T& defVal
 )
 :
-	eventObserver(pStruct, subscribe),
-	FieldType(pStruct.capacity(), pStruct.size(), RESERVE()),
+	IOobject
+	(
+		objf,
+		pStruct.ioPattern(),
+		pStruct.owner()
+	),
+	InternalFieldType
+	(
+		objf.name(),
+		pStruct
+	),
+	boundaryFieldList_(pStruct.boundaries(), *this),
 	pStruct_(pStruct),
 	defaultValue_(defVal)
 {
-	// set value 
-	this->fill(defVal);
+    
+    if(IOobject::implyRead())
+    {
+        REPORT(1)<< "Reading field "<< Green_Text(IOobject::name())<<
+        " from "<<IOobject::path()<<END_REPORT;
+    }
+    else
+    {
+        REPORT(1)<< "Creating field "<< Green_Text(IOobject::name())<<END_REPORT;
+    }
+    if( !IOobject::readObject() )
+    {
+        fatalErrorInFunction<<
+        "Error in reading from file "<<IOobject::path()<<endl;
+        fatalExit;
+    }    
+
 }
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::pointField<VectorField, T, MemorySpace>::pointField
+template<class T, class MemorySpace>
+pFlow::pointField<T, MemorySpace>::pointField
 (
-	const pointStructure& pStruct,
-	const T& val,
-	const T& defVal,
-	bool subscribe
+    const objectFile& objf,
+    repository* owner,
+    pointStructure& pStruct,
+    const T& defVal
 )
 :
-	eventObserver(pStruct, subscribe),
-	FieldType(pStruct.capacity(), pStruct.size(), RESERVE()),
+	IOobject
+	(
+		objf,
+		pStruct.ioPattern(),
+		owner
+	),
+	InternalFieldType
+	(
+		objf.name(),
+		pStruct
+	),
+	boundaryFieldList_(pStruct.boundaries(), *this),
 	pStruct_(pStruct),
 	defaultValue_(defVal)
 {
-	this->fill(val);
+    if(IOobject::implyRead())
+    {
+        REPORT(1)<< "Reading field "<< Green_Text(IOobject::name())<<
+        " from "<<IOobject::path()<<END_REPORT;
+    }
+    else
+    {
+        REPORT(1)<< "Creating field "<< Green_Text(IOobject::name())<<END_REPORT;
+    }
+    if( !IOobject::readObject() )
+    {
+        fatalErrorInFunction<<
+        "Error in reading from file "<<IOobject::path()<<endl;
+        fatalExit;
+    }
 }
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::pointField<VectorField, T, MemorySpace>::pointField
+template<class T, class MemorySpace>
+pFlow::pointField<T, MemorySpace>::pointField
 (
-	const pointField& src,
-	bool subscribe
+	const objectFile &objf, 
+	pointStructure &pStruct, 
+	const T& defVal,
+	const T& val
 )
 :
-	eventObserver(src.pStruct(), subscribe),
-	FieldType(src),
-	pStruct_(src.pStruct()),
-	defaultValue_(src.defaultValue_)
-{}
-
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::pointField<VectorField, T, MemorySpace>::pointField(const pointField& src)
-:
-	pointField<VectorField, T, MemorySpace>(src, src.subscribed())
-{}
-
-
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::pointField<VectorField, T, MemorySpace>& pFlow::pointField<VectorField, T, MemorySpace>::operator = 
-(
-	const pointField& rhs
-)
+	IOobject
+	(
+		objectFile
+		(
+			objf.name(),
+			objf.localPath(),
+			objectFile::READ_NEVER,
+			objf.wFlag()
+		),
+		pStruct.ioPattern(),
+		pStruct.owner()
+	),
+	InternalFieldType
+	(
+		objf.name(),
+		pStruct,
+		val
+	),
+	boundaryFieldList_(pStruct.boundaries(), *this),
+	pStruct_(pStruct),
+	defaultValue_(defVal)
 {
-	if(this == &rhs) return *this;
-	
-	this->VectorField() = rhs.VectorField();
-	return *this;
+
 }
 
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-bool pFlow::pointField<VectorField, T, MemorySpace>::update(const eventMessage& msg)
+ /*
+
+
+
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField
+ (
+     const pointStructure& pStruct,
+     const T& defVal,
+     bool subscribe
+ )
+ :
+     eventObserver(pStruct, subscribe),
+     FieldType(pStruct.capacity(), pStruct.size(), RESERVE()),
+     pStruct_(pStruct),
+     defaultValue_(defVal)
+ {
+     // set value
+     this->fill(defVal);
+ }
+
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField
+ (
+     const pointStructure& pStruct,
+     const T& val,
+     const T& defVal,
+     bool subscribe
+ )
+ :
+     eventObserver(pStruct, subscribe),
+     FieldType(pStruct.capacity(), pStruct.size(), RESERVE()),
+     pStruct_(pStruct),
+     defaultValue_(defVal)
+ {
+     this->fill(val);
+ }
+
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField
+ (
+     const pointField& src,
+     bool subscribe
+ )
+ :
+     eventObserver(src.pStruct(), subscribe),
+     FieldType(src),
+     pStruct_(src.pStruct()),
+     defaultValue_(src.defaultValue_)
+ {}
+
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField(const pointField& src)
+ :
+     pointField<T, MemorySpace>(src, src.subscribed())
+ {}
+
+
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>& pFlow::pointField<T, MemorySpace>::operator =
+ (
+     const pointField& rhs
+ )
+ {
+     if(this == &rhs) return *this;
+
+     this->VectorField() = rhs.VectorField();
+     return *this;
+ }
+
+
+ template<class T, class MemorySpace>
+ bool pFlow::pointField<T, MemorySpace>::update(const eventMessage& msg)
+ {
+
+     if( msg.isDeleted() )
+     {
+
+     }
+     else if( msg.isInsert())
+     {
+         const auto newElems = pStruct().insertedPointIndex();
+         //Vector<T> vals( newElems.size(), defaultValue_);
+         return this->insertSetElement(newElems, defaultValue_);
+     }
+
+     if(msg.isRearranged())
+     {
+         auto sortedIndex = pStruct().mortonSortedIndex();
+         this->sortItems(sortedIndex);
+         return true;
+     }
+
+     return true;
+ }*/
+
+template <class T, class MemorySpace>
+bool pFlow::pointField<T, MemorySpace>::readPointField
+(
+    iIstream &is,
+    const IOPattern &iop
+)
 {
- 
-	if( msg.isDeleted() )
+	typename InternalFieldType::FieldTypeHost fRead
+    (
+        InternalFieldType::name(),
+        InternalFieldType::fieldKey()
+    );
+    
+	if( !fRead.read(is, iop))
 	{
-		/*const auto& dp = pStruct_.markedDeletePoints();
-		return this->deleteElement(dp);
-		notImplementedFunction;*/
-	}
-	else if( msg.isInsert())
-	{
-		const auto newElems = pStruct().insertedPointIndex();
-		//Vector<T> vals( newElems.size(), defaultValue_);
-		return this->insertSetElement(newElems, defaultValue_);
+		fatalErrorInFunction<<
+		"Error in reading pointPosition from stream "<< is.name()<<endl;
+		return false;
 	}
 
-	if(msg.isRearranged())
-	{
-		auto sortedIndex = pStruct().mortonSortedIndex();
-		this->sortItems(sortedIndex);
-		return true;
-	}
-	
+	auto thisN = pStruct_.simDomain().initialNumberInThis();
+
+	typename InternalFieldType::FieldTypeHost internal
+    (
+        InternalFieldType::name(),
+        InternalFieldType::fieldKey(),
+        thisN, 
+        thisN, 
+        RESERVE()
+    );
+
+	auto pSpan  = fRead.getSpan(); 
+    auto iSpan  = internal.getSpan();
+    
+    if(!pStruct_.simDomain().initialTransferBlockData(pSpan, iSpan))
+    {
+        fatalErrorInFunction<<
+        "Error in transfering the block data for field "<<
+		InternalFieldType::name()<<endl;
+        return false;
+    }
+
+	this->field_.assignFromHost(internal);
+
 	return true;
 }
 
+template<class T, class MemorySpace>
+bool pFlow::pointField<T, MemorySpace>::writePointField
+(
+	iOstream& os,
+	const IOPattern& iop
+)const
+{
+    return InternalFieldType::write(os, iop);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/pointField.hpp b/src/phasicFlow/containers/pointField/pointField.hpp
index 5c074243..c6191dc8 100644
--- a/src/phasicFlow/containers/pointField/pointField.hpp
+++ b/src/phasicFlow/containers/pointField/pointField.hpp
@@ -22,147 +22,115 @@ Licence:
 #define __pointField_hpp__
 
 
-#include "Field.hpp"
 #include "pointStructure.hpp"
-#include "error.hpp"
+#include "internalField.hpp"
+#include "boundaryFieldList.hpp"
+
 
 namespace pFlow
 {
 
-
-
-template<template<class, class> class VectorField, class T, class MemorySpace=void>
+template<class T, class MemorySpace=void>
 class pointField
 :
-	public eventObserver,
-	public Field<VectorField, T, MemorySpace>
+	public IOobject,
+	public internalField<T, MemorySpace>
 {
 public:
 	
-	using pointFieldType 	= pointField<VectorField, T, MemorySpace>;
-	
-	using FieldType         = Field<VectorField, T, MemorySpace>;
-  	
-  	using VectorType  		= typename FieldType::VectorType;
+	using PointFieldType 	= pointField<T, MemorySpace>;
 
-	using iterator        	= typename FieldType::iterator;
+	using InternalFieldType = internalField<T, MemorySpace>;
 
-  	using constIterator   	= typename FieldType::constIterator;
+	using boundaryFieldListType = boundaryFieldList<T, MemorySpace>;
 
-	using reference       	= typename FieldType::reference;
-  	
-  	using constReference  	= typename FieldType::constReference;
+	using FieldType 		= typename InternalFieldType::FieldType;
 
-	using valueType       	= typename FieldType::valueType;
-  	
-  	using pointer         	= typename FieldType::pointer;
-  	
-  	using constPointer    	= typename FieldType::constPointer;
+	using VectorType  		= typename InternalFieldType::VectorType;
 
-protected:
+	using memory_space 		= typename InternalFieldType::memory_space;
 
-	////- data members
-		const pointStructure& pStruct_;
+	using execution_space 	= typename InternalFieldType::execution_space;
 
-		// - value when a new item is added to field
+private:
+
+    //// - data members 
+
+        /// @brief list of boundaries
+        boundaryFieldListType       boundaryFieldList_;
+        
+		/// @brief  refrence to point structure 
+		const pointStructure&       pStruct_;
+
+		/// @brief value when a new item is added to field
 		T 	defaultValue_;
 
 
 public:
- 
+	
+	
 	// - type info
-	TypeInfoTemplateNV2("pointField", T, VectorType::memoerySpaceName());
+	TypeInfoTemplate111("pointField", T, VectorType::memoerySpaceName());
 
 	
 	//// - Constructors
 
 		// - construct a field from pointStructure and set defaultValue_ and field value to defVal
-		pointField( const pointStructure& pStruct, const T& defVal, bool subscribe = true);
-
-		// - construct from iIOEntity, pointStructure and a value
-		pointField( const pointStructure& pStruct, const T& val, const T& defVal, bool subscribe = true);
-
-		// - construct from another pointField
-		//   subscribe to events if true
-		pointField( const pointField& src, bool subscribe);
-
-
-		// - copy construct 
-		pointField(const pointField& src);
-
-		// - no move construct
-		pointField(pointField&& src) = delete;
-
-
-		// assignment, only assign the VectorField and preserve other parts of this 
-		pointField& operator = (const pointField& rhs);
-
-		// no move assignment 
-		pointField& operator = (pointField&&) = delete;		
-
-
-		inline uniquePtr<pointFieldType> clone() const
-		{
-			return makeUnique<pointFieldType>(*this);
-		}
-
-		inline pointFieldType* clonePtr()const
-		{
-			return new pointFieldType(*this);
-		}
+		pointField(
+			const objectFile& objf, 
+            pointStructure& pStruct, 
+            const T& defVal);
+		
+		pointField(
+			const objectFile& objf,
+			repository* owner,
+			pointStructure& pStruct,
+			const T& defVal);
+		
+		pointField(
+			const objectFile& objf,
+			pointStructure& pStruct,
+			const T& defVal,
+			const T& val);
+		
+		
 
 	//// - Methods
+	
+		const auto& internal()const
+		{
+			return static_cast<const InternalFieldType&>(*this);
+		}
 
 		// - reference to pointStructure
 		inline const pointStructure& pStruct()const {
 			return pStruct_;
 		}
 
-		// if all points are active 
-		INLINE_FUNCTION_H
-		bool allActive()const {	
-			return pStruct_.allActive();
-		}
-		
-
-		INLINE_FUNCTION_H
-		bool isActive(label i)const {
-			return pStruct_.isActive(i);
-		}
-
-		const auto& pointFlag()const
+		void fill(const T& val)
 		{
-			return pStruct_.pointFlag();
+			InternalFieldType::fillInternal(val);
+			boundaryFieldList_.fill(val);
 		}
 
-		range activeRange()const
-		{
-			return pStruct_.activeRange();
-		}
-
-		// - update the field if any changes occure in pStruct 
-		//   for now it checks for deleted points
-		bool update(const eventMessage& msg);
-
-
 	//// -  IO operations
-		bool readPointField(iIstream& is);
+		bool readPointField(iIstream& is, const IOPattern& iop);
 
-		bool writePointField(iOstream& os)const;
+		bool writePointField(iOstream& os, const IOPattern& iop)const;
 
 
-		bool read(iIstream& is)
+		bool read(iIstream& is, const IOPattern& iop)override
 		{
-			return readPointField(is);
+			return readPointField(is, iop);
 		}
 
-		bool write(iOstream& os)const
+		bool write(iOstream& os, const IOPattern& iop)const override
 		{
-			return writePointField(os);
+			return writePointField(os, iop);
 		}
 };
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
+/*template<template<class, class> class VectorField, class T, class MemorySpace>
 iIstream& operator >> (iIstream & is, pointField<VectorField, T, MemorySpace> & pF )
 {
 	if( !pF.read(is))
@@ -173,12 +141,12 @@ iIstream& operator >> (iIstream & is, pointField<VectorField, T, MemorySpace> &
 	}
 
 	return is;
-}
+}*/
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-iOstream& operator << (iOstream& os, const pointField<VectorField, T, MemorySpace>& pF )
+template<class T, class MemorySpace>
+iOstream& operator << (iOstream& os, const pointField<T, MemorySpace>& pF )
 {
-	if(! pF.write(os) )
+	if(! pF.write(os, IOPattern::AllProcessorsDifferent) )
 	{
 		ioErrorInFile( os.name(), os.lineNumber() )<<
 		"error in writing pointField into file. \n";
@@ -191,6 +159,6 @@ iOstream& operator << (iOstream& os, const pointField<VectorField, T, MemorySpac
 }
 
 #include "pointField.cpp"
-#include "pointFieldAlgorithms.hpp"
+//#include "pointFieldAlgorithms.hpp"
 
 #endif //  __pointField_hpp__
diff --git a/src/phasicFlow/containers/pointField/pointFieldAlgorithms.hpp b/src/phasicFlow/containers/pointField/pointFieldAlgorithms.hpp
index 022e35f1..ce3765d2 100644
--- a/src/phasicFlow/containers/pointField/pointFieldAlgorithms.hpp
+++ b/src/phasicFlow/containers/pointField/pointFieldAlgorithms.hpp
@@ -109,15 +109,15 @@ T maxActive(const pointField<VectorSingle, T, MemorySpace>& pField)
 	{
 		if(len < sizeToSerial__ ) // serial execution instead of lunching parallel execution 
 			return maxActive_serial(
-				pField.deviceVectorAll(),
-				pField.pointFlag().hostVectorAll(),
+				pField.deviceViewAll(),
+				pField.pointFlag().hostViewAll(),
 				static_cast<size_t>(0),
 				len
 				);
 		else
 			return maxActiveH(
-				pField.deviceVectorAll(),
-				pField.pointFlag().hostVectorAll(),
+				pField.deviceViewAll(),
+				pField.pointFlag().hostViewAll(),
 				static_cast<size_t>(0),
 				len
 				);
@@ -125,8 +125,8 @@ T maxActive(const pointField<VectorSingle, T, MemorySpace>& pField)
 	else
 	{
 		return maxActiveD(
-			pField.deviceVectorAll(),
-			pField.pointFlag().deviceVectorAll(),
+			pField.deviceViewAll(),
+			pField.pointFlag().deviceViewAll(),
 			static_cast<size_t>(0),
 			len
 			);
@@ -148,23 +148,23 @@ T maxActive(const pointField<VectorDual, T, MemorySpace>& pField)
 	{
 		if( len < sizeToSerial__)
 			return maxActive_serial(
-				pField.hostVectorAll(),
-				pField.pointFlag().hostVectorAll(),
+				pField.hostViewAll(),
+				pField.pointFlag().hostViewAll(),
 				static_cast<size_t>(0),
 				len
 				);
 		else
 			return maxActiveH(
-				pField.hostVectorAll(),
-				pField.pointFlag().hostVectorAll(),
+				pField.hostViewAll(),
+				pField.pointFlag().hostViewAll(),
 				static_cast<size_t>(0),
 				len
 				);
 	}else
 	{
 		return maxActiveD(
-				pField.deviceVectorAll(),
-				pField.pointFlag().deviceVectorAll(),
+				pField.deviceViewAll(),
+				pField.pointFlag().deviceViewAll(),
 				static_cast<size_t>(0),
 				len
 				);
diff --git a/src/phasicFlow/containers/pointField/pointField_old.hpp b/src/phasicFlow/containers/pointField/pointField_old.hpp
new file mode 100644
index 00000000..5c074243
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/pointField_old.hpp
@@ -0,0 +1,196 @@
+/*------------------------------- 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 __pointField_hpp__
+#define __pointField_hpp__
+
+
+#include "Field.hpp"
+#include "pointStructure.hpp"
+#include "error.hpp"
+
+namespace pFlow
+{
+
+
+
+template<template<class, class> class VectorField, class T, class MemorySpace=void>
+class pointField
+:
+	public eventObserver,
+	public Field<VectorField, T, MemorySpace>
+{
+public:
+	
+	using pointFieldType 	= pointField<VectorField, T, MemorySpace>;
+	
+	using FieldType         = Field<VectorField, T, MemorySpace>;
+  	
+  	using VectorType  		= typename FieldType::VectorType;
+
+	using iterator        	= typename FieldType::iterator;
+
+  	using constIterator   	= typename FieldType::constIterator;
+
+	using reference       	= typename FieldType::reference;
+  	
+  	using constReference  	= typename FieldType::constReference;
+
+	using valueType       	= typename FieldType::valueType;
+  	
+  	using pointer         	= typename FieldType::pointer;
+  	
+  	using constPointer    	= typename FieldType::constPointer;
+
+protected:
+
+	////- data members
+		const pointStructure& pStruct_;
+
+		// - value when a new item is added to field
+		T 	defaultValue_;
+
+
+public:
+ 
+	// - type info
+	TypeInfoTemplateNV2("pointField", T, VectorType::memoerySpaceName());
+
+	
+	//// - Constructors
+
+		// - construct a field from pointStructure and set defaultValue_ and field value to defVal
+		pointField( const pointStructure& pStruct, const T& defVal, bool subscribe = true);
+
+		// - construct from iIOEntity, pointStructure and a value
+		pointField( const pointStructure& pStruct, const T& val, const T& defVal, bool subscribe = true);
+
+		// - construct from another pointField
+		//   subscribe to events if true
+		pointField( const pointField& src, bool subscribe);
+
+
+		// - copy construct 
+		pointField(const pointField& src);
+
+		// - no move construct
+		pointField(pointField&& src) = delete;
+
+
+		// assignment, only assign the VectorField and preserve other parts of this 
+		pointField& operator = (const pointField& rhs);
+
+		// no move assignment 
+		pointField& operator = (pointField&&) = delete;		
+
+
+		inline uniquePtr<pointFieldType> clone() const
+		{
+			return makeUnique<pointFieldType>(*this);
+		}
+
+		inline pointFieldType* clonePtr()const
+		{
+			return new pointFieldType(*this);
+		}
+
+	//// - Methods
+
+		// - reference to pointStructure
+		inline const pointStructure& pStruct()const {
+			return pStruct_;
+		}
+
+		// if all points are active 
+		INLINE_FUNCTION_H
+		bool allActive()const {	
+			return pStruct_.allActive();
+		}
+		
+
+		INLINE_FUNCTION_H
+		bool isActive(label i)const {
+			return pStruct_.isActive(i);
+		}
+
+		const auto& pointFlag()const
+		{
+			return pStruct_.pointFlag();
+		}
+
+		range activeRange()const
+		{
+			return pStruct_.activeRange();
+		}
+
+		// - update the field if any changes occure in pStruct 
+		//   for now it checks for deleted points
+		bool update(const eventMessage& msg);
+
+
+	//// -  IO operations
+		bool readPointField(iIstream& is);
+
+		bool writePointField(iOstream& os)const;
+
+
+		bool read(iIstream& is)
+		{
+			return readPointField(is);
+		}
+
+		bool write(iOstream& os)const
+		{
+			return writePointField(os);
+		}
+};
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+iIstream& operator >> (iIstream & is, pointField<VectorField, T, MemorySpace> & pF )
+{
+	if( !pF.read(is))
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		"error in reading pointField from file. \n";
+		fatalExit;
+	}
+
+	return is;
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+iOstream& operator << (iOstream& os, const pointField<VectorField, T, MemorySpace>& pF )
+{
+	if(! pF.write(os) )
+	{
+		ioErrorInFile( os.name(), os.lineNumber() )<<
+		"error in writing pointField into file. \n";
+		fatalExit;
+	}
+
+	return os;
+}
+
+}
+
+#include "pointField.cpp"
+#include "pointFieldAlgorithms.hpp"
+
+#endif //  __pointField_hpp__
diff --git a/src/phasicFlow/containers/pointField/pointFields.cpp b/src/phasicFlow/containers/pointField/pointFields.cpp
index da0084b7..f116e5ee 100644
--- a/src/phasicFlow/containers/pointField/pointFields.cpp
+++ b/src/phasicFlow/containers/pointField/pointFields.cpp
@@ -20,39 +20,82 @@ Licence:
 
 
 #include "pointFields.hpp"
+#include "createBoundaryFields.hpp"
+#include "periodicBoundaryField.hpp"
+
+#define createAllBoundary(DataType, MemorySpaceType)          \
+    template class pFlow::exitBoundaryField<DataType, MemorySpaceType>; \
+    template class pFlow::periodicBoundaryField<DataType, MemorySpaceType>;
+
+template class pFlow::pointField<pFlow::int8, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::int8, pFlow::HostSpace);
+createAllBoundary(pFlow::int8, pFlow::HostSpace);
+
+template class pFlow::pointField<pFlow::int8>; 
+createBaseBoundary(pFlow::int8, void);
+createAllBoundary(pFlow::int8, void);
 
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8>; 
+template class pFlow::pointField<pFlow::uint8, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::uint8, pFlow::HostSpace);
+createAllBoundary(pFlow::uint8, pFlow::HostSpace);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>; 
+template class pFlow::pointField<pFlow::uint8>; 
+createBaseBoundary(pFlow::uint8, void);
+createAllBoundary(pFlow::uint8, void);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int16>; 
+template class pFlow::pointField<pFlow::int32, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::int32, pFlow::HostSpace);
+createAllBoundary(pFlow::int32, pFlow::HostSpace);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int16, pFlow::HostSpace>; 
+template class pFlow::pointField<pFlow::int32>; 
+createBaseBoundary(pFlow::int32, void);
+createAllBoundary(pFlow::int32, void);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int32>; 
+template class pFlow::pointField<pFlow::uint32, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::uint32, pFlow::HostSpace);
+createAllBoundary(pFlow::uint32, pFlow::HostSpace);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int32, pFlow::HostSpace>; 
+template class pFlow::pointField<pFlow::uint32>; 
+createBaseBoundary(pFlow::uint32, void);
+createAllBoundary(pFlow::uint32, void);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int64>; 
+template class pFlow::pointField<pFlow::uint64, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::uint64, pFlow::HostSpace);
+createAllBoundary(pFlow::uint64, pFlow::HostSpace);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int64, pFlow::HostSpace>; 
+template class pFlow::pointField<pFlow::uint64>; 
+createBaseBoundary(pFlow::uint64, void);
+createAllBoundary(pFlow::uint64, void);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::uint32>; 
-
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::uint32, pFlow::HostSpace>;
-
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::label>; 
-
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::label, pFlow::HostSpace>;
-
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::real>; 
-
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>;
-
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::realx3>; 
-
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::realx3, pFlow::HostSpace>;
+template class pFlow::pointField<pFlow::real, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::real, pFlow::HostSpace);
+createAllBoundary(pFlow::real, pFlow::HostSpace);
 
 
+template class pFlow::pointField<pFlow::real>; 
+createBaseBoundary(pFlow::real, void);
+createAllBoundary(pFlow::real, void);
 
+template class pFlow::pointField<pFlow::realx3, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::realx3, pFlow::HostSpace);
+createAllBoundary(pFlow::realx3, pFlow::HostSpace);
+
+
+template class pFlow::pointField<pFlow::realx3>; 
+createBaseBoundary(pFlow::realx3, void);
+createAllBoundary(pFlow::realx3, void);
+
+
+template class pFlow::pointField<pFlow::realx4, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::realx4, pFlow::HostSpace);
+createAllBoundary(pFlow::realx4, pFlow::HostSpace);
+
+
+template class pFlow::pointField<pFlow::realx4>; 
+createBaseBoundary(pFlow::realx4, void);
+createAllBoundary(pFlow::realx4, void);
+
+template class pFlow::pointField<pFlow::word, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::word, pFlow::HostSpace);
+createAllBoundary(pFlow::word, pFlow::HostSpace);
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/pointFields.hpp b/src/phasicFlow/containers/pointField/pointFields.hpp
index a3183143..26e0d52a 100644
--- a/src/phasicFlow/containers/pointField/pointFields.hpp
+++ b/src/phasicFlow/containers/pointField/pointFields.hpp
@@ -30,66 +30,40 @@ namespace pFlow
 {
 
 template<typename T>
-  using pointField_H = pointField<VectorSingle, T, HostSpace>;
+  using pointField_H = pointField<T, HostSpace>;
 
 template<typename T>
-  using pointField_D = pointField<VectorSingle, T>;
-
-template<typename T>
-  using pointField_HD = pointField<VectorDual, T>;
+  using pointField_D = pointField<T>;
 
 
-using int8PointField_D 		= pointField<VectorSingle, int8>;
+using int8PointField_D 		= pointField_D<int8>;
+using int8PointField_H 		= pointField_H<int8>;
 
-using int8PointField_H 		= pointField<VectorSingle, int8, HostSpace>;
+using uint8PointField_D 		= pointField_D<uint8>;
+using uint8PointField_H 		= pointField_H<uint8>;
 
-using int16PointField_D 	= pointField<VectorSingle, int16>;
+using int32PointField_D 		= pointField_D<int32>;
+using int32PointField_H 		= pointField_H<int32>;
 
-using int16PointField_H 	= pointField<VectorSingle, int16, HostSpace>;
+using uint32PointField_D 		= pointField_D<uint32>;
+using uint32PointField_H 		= pointField_H<uint32>;
 
-using int32PointField_D 	= pointField<VectorSingle, int32>;
+using int64PointField_D 		= pointField_D<int64>;
+using int64PointField_H 		= pointField_H<int64>;
 
-using int32PointField_H 	= pointField<VectorSingle, int32, HostSpace>;
+using uint64PointField_D 		= pointField_D<uint64>;
+using uint64PointField_H 		= pointField_H<uint64>;
 
-using int64PointField_D 	= pointField<VectorSingle, int64>;
+using realPointField_D 		= pointField_D<real>;
+using realPointField_H 		= pointField_H<real>;
 
-using int64PointField_H 	= pointField<VectorSingle, int64, HostSpace>;
+using realx3PointField_D 		= pointField_D<realx3>;
+using realx3PointField_H 		= pointField_H<realx3>;
 
-using uint32PointField_D 	= pointField<VectorSingle, uint32>;
+using realx4PointField_D 		= pointField_D<realx4>;
+using realx4PointField_H 		= pointField_H<realx4>;
 
-using uint32PointField_H 	= pointField<VectorSingle, uint32, HostSpace>;
-
-using labelPointField_D 	= pointField<VectorSingle, label>;
-
-using labelPointField_H  	= pointField<VectorSingle, label, HostSpace>;
-
-using realPointField_D 		= pointField<VectorSingle, real>;
-
-using realPointField_H 		= pointField<VectorSingle, real, HostSpace>;
-
-using realx3PointField_D 	= pointField<VectorSingle, realx3> ;
-
-using realx3PointField_H 	= pointField<VectorSingle, realx3, HostSpace>;
-
-using wordPointField_H 		= pointField<VectorSingle, word, HostSpace>;
-
-using int8PointField_HD 	= pointField<VectorDual, int8>;
-
-using int16PointField_HD 	= pointField<VectorDual, int16>;
-
-using int32PointField_HD 	= pointField<VectorDual, int32>;
-
-using int64PointField_HD 	= pointField<VectorDual, int64>;
-
-using uint32PointField_HD 	= pointField<VectorDual, uint32>;
-
-using labelPointField_HD 	= pointField<VectorDual, label>;
-
-using realPointField_HD 	= pointField<VectorDual, real>;
-
-using realx3PointField_HD 	= pointField<VectorDual, realx3>;
-
-using wordPointField 		= pointField<Vector, word, vecAllocator<word>>;
+using wordPointField_H      = pointField_H<word>;
 
 }
 
diff --git a/src/phasicFlow/containers/span/span.hpp b/src/phasicFlow/containers/span/span.hpp
index 63c89190..91deb71f 100644
--- a/src/phasicFlow/containers/span/span.hpp
+++ b/src/phasicFlow/containers/span/span.hpp
@@ -51,11 +51,11 @@ protected:
 
     T* data_ 		= nullptr;
 
-    label 	size_ 	= 0;
+    uint32 	size_ 	= 0;
 
 public:
     
-    TypeInfoTemplateNV("span", T);
+    TypeInfoTemplateNV11("span", T);
 
     /// Constructor
     INLINE_FUNCTION_HD
@@ -63,7 +63,7 @@ public:
 
 
     INLINE_FUNCTION_HD
-    span(T* data, label size)
+    span(T* data, uint32 size)
         : data_(data), size_(size)
     {}
 
@@ -77,11 +77,11 @@ public:
 
     /// move
     INLINE_FUNCTION_HD
-    span(span&&) = delete;
+    span(span&&) = default;
 
     /// assignment
     INLINE_FUNCTION_HD
-    span& operator=(span&) = delete;
+    span& operator=(span&) = default;
 
     
     INLINE_FUNCTION_HD
@@ -98,7 +98,7 @@ public:
 
     /// Returns the number of elements in the span
     INLINE_FUNCTION_HD
-    label size() const
+    uint32 size() const
     {
         return size_;
     }
@@ -131,6 +131,18 @@ public:
         return data_ + size_;
     }
 
+    INLINE_FUNCTION_HD
+    T& operator[](uint32 i)
+    {
+    	return data_[i];
+    }
+
+    INLINE_FUNCTION_HD
+    const T& operator[](uint32 i)const
+    {
+    	return data_[i];
+    }
+
     INLINE_FUNCTION_HD
     T& operator[](int32 i)
     {
@@ -143,37 +155,62 @@ public:
     	return data_[i];
     }
 
-    INLINE_FUNCTION_HD
-    T& operator[](label i)
-    {
-    	return data_[i];
-    }
-
-    INLINE_FUNCTION_HD
-    const T& operator[](label i)const
-    {
-    	return data_[i];
-    }
-
 };
 
-template<typename T>
-inline 
-iOstream& operator<<(iOstream& os, const span<T>& s)
+/*template<typename T, typename... properties, template<class, class...> class Container>
+size_t makeSpan(Container<T, properties...>& container)
 {
-    os << token::BEGIN_LIST;
-    for(size_t i=0; i<s.size(); i++)
-    {
-        os << s[i]<<token::NL;
-    }
-    
-    os << token::END_LIST;
-
-    os.check(FUNCTION_NAME);
-
-    return os;
+    return span<T>(container.data(), container.size());
 }
 
+template<typename T, typename... properties, template<class, class...> class Container>
+size_t makeSpan(const Container<T, properties...>& container)
+{
+    return span<T>(
+        const_cast<T*>(container.data()), 
+        container.size());
+}*/
+
+
+template<typename T>
+inline
+span<char> charSpan(span<T> s)
+{
+    auto el = sizeof(T);
+    return span<char>(
+        reinterpret_cast<char*>(s.data()),
+        s.size()*el);
+}
+
+template<typename T>
+inline
+span<const char> charSpan(span<const T> s)
+{
+    auto el = sizeof(T);
+    return span<const char>(
+        reinterpret_cast<const char*>(s.data()),
+        s.size()*el);
+}
+
+/*template<typename T, template<class> class Container>
+span<T> makeSpan(Container<T>& container)
+{
+    return span<T>(container.data(), container.size());
+}
+
+template<typename T, template<class> class Container>
+span<T> makeSpan(const Container<T>& container)
+{
+    return span<T>(
+        const_cast<T*>(container.data()), 
+        container.size());
+}*/
+
+
+
+
+
+
 } // pFlow
 
 #endif //__span_hpp__
diff --git a/src/phasicFlow/containers/symArrayHD/symArrayHD.hpp b/src/phasicFlow/containers/symArrayHD/symArrayHD.hpp
index d1d0ddd7..9c7d1a67 100644
--- a/src/phasicFlow/containers/symArrayHD/symArrayHD.hpp
+++ b/src/phasicFlow/containers/symArrayHD/symArrayHD.hpp
@@ -23,22 +23,11 @@ Licence:
 
 #include "KokkosTypes.hpp"
 
-
 #include "types.hpp"
 #include "typeInfo.hpp"
 #include "Vector.hpp"
 
 
-/*
-stores the elemnt of a symetric array in the following order in a 1D vector
-
- 0  1  2  3
-    4  5  6
-       7  8  
-          9
-
-*/
-
 namespace pFlow
 {
 
@@ -52,6 +41,15 @@ void SWAP(Type &x, Type& y)
 	x = temp;
 }
 
+/*
+stores the elemnt of a symetric array in the following order in a 1D vector
+
+ 0  1  2  3
+    4  5  6
+       7  8  
+          9
+
+*/
 template<typename T, typename MemorySpace=void>
 class symArray
 {
@@ -82,14 +80,14 @@ class symArray
   	using execution_space 	= typename ViewType::execution_space;
 
   	
-protected:
+private:
 
-	uint32 			n_=0;
+	uint32 			n_= 0;
 
 	ViewType 		view_;
 
 
-	constexpr static inline const char* memoerySpaceName()
+	constexpr static const char* memoerySpaceName()
   	{
   		return memory_space::name();
   	}
@@ -97,14 +95,14 @@ protected:
 public:
 
 	// - type info
-	TypeInfoTemplateNV2("symArray", T, memoerySpaceName());
+	TypeInfoTemplateNV111("symArray", T, memoerySpaceName());
 
 	//// constructors 
 	INLINE_FUNCTION_H
 	symArray();
 
 	INLINE_FUNCTION_H
-	symArray(uint32 n)
+	explicit symArray(uint32 n)
 	:
 		symArray("symArray",n)
 	{}
@@ -125,7 +123,7 @@ public:
 	}
 
 	INLINE_FUNCTION_H
-	symArray(word name, Vector<T> src)
+	symArray(word name, const Vector<T>& src)
 	:
 		view_(name)
 	{
@@ -137,19 +135,19 @@ public:
 		}
 	}
 
-	INLINE_FUNCTION_H
+	INLINE_FUNCTION_HD
 	symArray(const symArray&) = default;
 
-	INLINE_FUNCTION_H
+	INLINE_FUNCTION_HD
 	symArray& operator=(const symArray&) = default;
 
-	INLINE_FUNCTION_H
-	symArray(symArray&&) = delete;
+	INLINE_FUNCTION_HD
+	symArray(symArray&&) = default;
 
-	INLINE_FUNCTION_H
-	symArray& operator=(symArray&&) = delete;
+	INLINE_FUNCTION_HD
+	symArray& operator=(symArray&&) = default;
 
-	INLINE_FUNCTION_H
+	INLINE_FUNCTION_HD
 	~symArray()=default;
 
 	
@@ -219,10 +217,10 @@ public:
 		bool write(iOstream& os)const
 		{
 			
-			int32 s = numElem(n_);
-			Vector<T, noConstructAllocator<T>> vecToFile(s);
+			uint32 s = numElem(n_);
+			Vector<T> vecToFile(view_.label(),s);
 			
-			const auto dVec = Kokkos::subview(view_, kPair<int32,int32>(0, s));
+			const auto dVec = Kokkos::subview(view_, Pair<uint32,uint32>(0, s));
 			hostViewType1D<T> mirror(vecToFile.data(), vecToFile.size());
 			Kokkos::deep_copy(mirror,dVec);
 
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceField.cpp b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.cpp
index 26830089..8ba0abf4 100644
--- a/src/phasicFlow/containers/triSurfaceField/triSurfaceField.cpp
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.cpp
@@ -1,3 +1,4 @@
+#include "triSurfaceField.hpp"
 /*------------------------------- phasicFlow ---------------------------------
       O        C enter of
      O O       E ngineering and
@@ -18,7 +19,153 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
+template<class T, class MemorySpace>
+pFlow::triSurfaceField<T,MemorySpace>::triSurfaceField
+( 
+	const objectFile& objf,
+	multiTriSurface& surface, 
+	const T& defVal
+)
+:
+	triSurfaceField
+	(
+		objf,
+		surface.owner(),
+		surface,
+		defVal
+	)
+{
+
+}
+
+template<class T, class MemorySpace>
+pFlow::triSurfaceField<T,MemorySpace>::triSurfaceField
+( 
+	const objectFile& objf,
+	repository* owner,
+	multiTriSurface& surface, 
+	const T& defVal
+)
+:
+	IOobject
+	(
+		objf,
+		IOPattern::AllProcessorsSimilar,
+		owner
+	),
+	observer
+	(
+		&surface,
+		message::Default()
+	),
+	field_
+	(
+		objf.name(),
+		"value",
+		surface.capacity(),
+		surface.size(),
+		RESERVE()
+	),
+	surface_(surface),
+	defaultValue_(defVal)
+{
+	if(IOobject::implyRead())
+    {
+        REPORT(1)<< "Reading triSurfaceField "<< Green_Text(IOobject::name())<<
+        " from "<<IOobject::path()<<END_REPORT;
+    }
+    else
+    {
+        REPORT(1)<< "Creating triSurfaceField "<< Green_Text(IOobject::name())<<END_REPORT;
+    }
+    if( !IOobject::readObject() )
+    {
+        fatalErrorInFunction<<
+        "Error in reading from file "<<IOobject::path()<<endl;
+        fatalExit;
+    }
+} 
+
+template <class T, class MemorySpace>
+pFlow::triSurfaceField<T, MemorySpace>::triSurfaceField
+(
+	const objectFile &objf, 
+	multiTriSurface &surface, 
+	const T &val, 
+	const T &defVal
+)
+:
+	triSurfaceField
+	(
+		objf,
+		surface.owner(),
+		surface,
+		val, 
+		defVal
+	)	
+{}
+
+template <class T, class MemorySpace>
+pFlow::triSurfaceField<T, MemorySpace>::triSurfaceField
+(
+	const objectFile &objf, 
+	repository *owner, 
+	multiTriSurface &surface, 
+	const T &val, 
+	const T &defVal
+)
+:
+	IOobject
+	(
+		objectFile
+		(
+			objf.name(),
+			objf.localPath(),
+			objectFile::READ_NEVER,
+			objf.wFlag()
+		),
+		IOPattern::AllProcessorsSimilar,
+		owner
+	),
+	observer
+	(
+		&surface,
+		message::Default()
+	),
+	field_
+	(
+		objf.name(),
+		"value",
+		surface.capacity(),
+		surface.size(),
+		val
+	),
+	surface_(surface),
+	defaultValue_(defVal)
+{
+}
+
+template <class T, class MemorySpace>
+bool pFlow::triSurfaceField<T, MemorySpace>::write
+(
+	iOstream &is, 
+	const IOPattern &iop
+) const
+{
+	return field_.write(is, iop);
+}
+
+template <class T, class MemorySpace>
+bool pFlow::triSurfaceField<T, MemorySpace>::read
+(
+	iIstream &is, 
+	const IOPattern &iop
+)
+{
+    return field_.read(is, iop);
+}
+
+/*template<template<class, class> class VectorField, class T, class MemorySpace>
 pFlow::triSurfaceField<VectorField, T, MemorySpace>::triSurfaceField
 (
 	const triSurface& surface,
@@ -116,4 +263,4 @@ bool pFlow::triSurfaceField<VectorField, T, MemorySpace>::writeTriSurfaceField
 )const
 {
 	return FieldType::write(os);
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceField.hpp b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.hpp
index 8dc2899b..54c4c0db 100644
--- a/src/phasicFlow/containers/triSurfaceField/triSurfaceField.hpp
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.hpp
@@ -22,7 +22,8 @@ Licence:
 #define __trieSurfaceField_hpp__
 
 #include "Field.hpp"
-#include "triSurface.hpp"
+#include "multiTriSurface.hpp"
+#include "observer.hpp"
 #include "error.hpp"
 
 
@@ -30,119 +31,160 @@ namespace pFlow
 {
 
 
-template<template<class, class> class VectorField, class T, class MemorySpace=void>
+template<class T, class MemorySpace=void>
 class triSurfaceField
 :
-	public eventObserver,	
-	public Field<VectorField, T, MemorySpace>
+	public IOobject,
+	public observer
 {
 public:
 	
-	using triSurfaceFieldType 	= triSurfaceField<VectorField, T, MemorySpace>;
+	using triSurfaceFieldType 	= triSurfaceField<T, MemorySpace>;
 	
-	using FieldType         	= Field<VectorField, T, MemorySpace>;
+	using FieldType         	= Field<T, MemorySpace>;
   	
   	using VectorType  			= typename FieldType::VectorType;
 
-	using iterator        = typename FieldType::iterator;
+	using memory_space 			= typename FieldType::memory_space;
 
-  	using constIterator   = typename FieldType::constIterator;
+	using execution_space 		= typename FieldType::execution_space;
 
-	using reference       = typename FieldType::reference;
-  	
-  	using constReference  = typename FieldType::constReference;
-
-	using valueType       = typename FieldType::valueType;
-  	
-  	using pointer         = typename FieldType::pointer;
-  	
-  	using constPointer    = typename FieldType::constPointer;
-
-protected:
+private:
 
 	////- data members
-		const triSurface& surface_;
+
+		FieldType 				field_;
+
+		const multiTriSurface& 	surface_;
 
 		// - value when a new item is added to field
-		T 	defaultValue_;
+		T 						defaultValue_;
 
 
 public:
 	
 	// - type info
-	TypeInfoTemplateNV2("triSurfaceField", T, VectorType::memoerySpaceName());
+	TypeInfoTemplate111("triSurfaceField", T, VectorType::memoerySpaceName());
 
 	
 	//// CONSTRUCTORS
 
 		// - construct a field from tirSurface and set defaultValue_ and field value to defVal
-		triSurfaceField( const triSurface& surface, const T& defVal, bool subscribe = true);
+		triSurfaceField( 
+			const objectFile& objf,
+			multiTriSurface& surface, 
+			const T& defVal);
+
+		triSurfaceField( 
+			const objectFile& objf,
+			repository* owner,
+			multiTriSurface& surface, 
+			const T& defVal);
 
 		// - construct from iIOEntity, tirSurface and a value
-		triSurfaceField( const triSurface& surface, const T& val, const T& defVal, bool subscribe = true);
+		triSurfaceField( 
+			const objectFile& objf,
+			multiTriSurface& surface, 
+			const T& val, 
+			const T& defVal);
 
-		// - construct from another triSurfaceField
-		//   subscribe to events if true
-		triSurfaceField( const triSurfaceField& src, bool subscribe);
+		triSurfaceField( 
+			const objectFile& objf,
+			repository* owner,
+			multiTriSurface& surface, 
+			const T& val, 
+			const T& defVal);
 
+		~triSurfaceField()override = default;
 
-		// - copy construct 
-		triSurfaceField(const triSurfaceField& src);
-
-		// - no move construct
-		triSurfaceField(triSurfaceField&& src) = delete;
-
-
-		// assignment, only assign the VectorField and preserve other parts of this 
-		triSurfaceField& operator = (const triSurfaceField& rhs);
-
-		// no move assignment 
-		triSurfaceField& operator = (triSurfaceField&&) = delete;		
-
-
-		inline uniquePtr<triSurfaceFieldType> clone() const
-		{
-			return makeUnique<triSurfaceFieldType>(*this);
-		}
-
-		inline triSurfaceFieldType* clonePtr()const
-		{
-			return new triSurfaceFieldType(*this);
-		}
+			
 
 	//// - Methods
 
-		inline const triSurface& surface()const {
+		inline 
+		const auto& surface()const 
+		{
 			return surface_;
 		}
 
-		auto getTriangleAccessor()const
+		inline 
+		auto size()const
 		{
-			return surface_.getTriangleAccessor();
+			return field_.size();
 		}
 
-		bool update(const eventMessage& msg);
+		inline
+		auto capacity()const
+		{
+			return field_.capacity();
+		}
 
+		inline 
+		void assign(const std::vector<T>& vals)
+		{
+			if(vals.size() != surface_.size())
+			{
+				fatalErrorInFunction;
+				fatalExit;	
+			}
+			field_.assign(vals, surface_.capacity());
+		}
+		
+		inline 
+		const auto& deviceViewAll()const
+		{
+			return field_.deviceViewAll();
+		}
+		inline
+		auto deviceView()const
+		{
+			return field_.deviceView();
+		}
+
+		inline
+		auto hostView()const
+		{
+			return field_.hostView();
+		}
+
+		inline
+		const FieldType& field()const
+		{
+			return field_;
+		}
+
+		inline
+		FieldType& field()
+		{
+			return field_;
+		}
+
+		inline 
+		void fill(const T& val)
+		{
+			field_.fillField(val);
+		}
+
+		bool hearChanges(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+		const anyList& varList) override
+		{
+			notImplementedFunction;
+			return false;
+		}
 
 	//// -  IO operations
-		bool readTriSurfacceField(iIstream& is);
+		bool write(iOstream& is, const IOPattern& iop)const override;
 
-		bool writeTriSurfaceField(iOstream& os)const;
-
-
-		bool read(iIstream& is)
-		{
-			return readTriSurfacceField(is);
-		}
-
-		bool write(iOstream& os)const
-		{
-			return writeTriSurfaceField(os);
-		}
+    
+        bool read(iIstream& is, const IOPattern& iop) override;
 
 };
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
+/*template<template<class, class> class VectorField, class T, class MemorySpace>
 iIstream& operator >> (iIstream & is, triSurfaceField<VectorField, T, MemorySpace> & tsF )
 {
 	if( !tsF.read(is))
@@ -168,7 +210,7 @@ iOstream& operator << (iOstream& os, const triSurfaceField<VectorField, T, Memor
 	}
 
 	return os;
-}
+}*/
 
 }
 
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.cpp b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.cpp
index 742b7aaa..95b75805 100644
--- a/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.cpp
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.cpp
@@ -21,9 +21,9 @@ Licence:
 #include "triSurfaceFields.hpp"
 
 
-template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::real>;
+template class pFlow::triSurfaceField<pFlow::real>;
 
-template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>;
+/*template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>;
 
 template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::realx3>;
 
@@ -31,4 +31,4 @@ template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::realx3, pFlow:
 
 template class pFlow::triSurfaceField<pFlow::VectorDual, pFlow::real>;
 
-template class pFlow::triSurfaceField<pFlow::VectorDual, pFlow::realx3>;
\ No newline at end of file
+template class pFlow::triSurfaceField<pFlow::VectorDual, pFlow::realx3>;*/
\ No newline at end of file
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.hpp b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.hpp
index c3cd6bd9..15311602 100644
--- a/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.hpp
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.hpp
@@ -21,37 +21,26 @@ Licence:
 #ifndef __triSurfaceFields_hpp__ 
 #define __triSurfaceFields_hpp__
 
-#include "VectorSingle.hpp"
-#include "VectorDual.hpp"
-#include "triSurfaceField.hpp"
 #include "types.hpp"
+#include "VectorSingle.hpp"
+#include "triSurfaceField.hpp"
+
 
 namespace pFlow
 {
 
-using realTriSurfaceField_D 	= triSurfaceField<VectorSingle, real> ;
+using uint32TriSurfaceField_D 	= triSurfaceField<uint32> ;
 
-using realTriSurfaceField_H 	= triSurfaceField<VectorSingle, real, HostSpace> ;
+using uint32TriSurfaceField_H 	= triSurfaceField<uint32, HostSpace> ;
 
-using realx3TriSurfaceField_D 	= triSurfaceField<VectorSingle, realx3> ;
+using realTriSurfaceField_D 	= triSurfaceField<real> ;
 
-using realx3TriSurfaceField_H 	= triSurfaceField<VectorSingle, realx3, HostSpace> ;
+using realTriSurfaceField_H 	= triSurfaceField<real, HostSpace> ;
 
-using realTriSurfaceField_HD 	= triSurfaceField<VectorDual, real> ;
+using realx3TriSurfaceField_D 	= triSurfaceField<realx3> ;
 
-using realx3TriSurfaceField_HD 	= triSurfaceField<VectorDual, realx3> ;
+using realx3TriSurfaceField_H 	= triSurfaceField<realx3, HostSpace> ;
 
-using realTriSurfaceField 		= triSurfaceField<Vector, real, vecAllocator<real>> ;
-
-using realx3TriSurfaceField 	= triSurfaceField<Vector, realx3, vecAllocator<realx3>> ;
-
-using int8TriSurfaceField_D 	= triSurfaceField<VectorSingle, int8> ;
-
-using int8TriSurfaceField_H 	= triSurfaceField<VectorSingle, int8, HostSpace> ;
-
-using int8TriSurfaceField_HD 	= triSurfaceField<VectorDual, int8> ;
-
-using int8TriSurfaceField 		= triSurfaceField<Vector, int8, vecAllocator<real>> ;
 
 
 }
diff --git a/src/phasicFlow/repository/systemControl/Control.hpp b/src/phasicFlow/demComponent/demComponent.cpp
similarity index 68%
rename from src/phasicFlow/repository/systemControl/Control.hpp
rename to src/phasicFlow/demComponent/demComponent.cpp
index 58df40a4..9225eb17 100644
--- a/src/phasicFlow/repository/systemControl/Control.hpp
+++ b/src/phasicFlow/demComponent/demComponent.cpp
@@ -18,30 +18,29 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
-#ifndef __Control_hpp__
-#define __Control_hpp__
-
-
-// top-level entity repository for the whole application 
-// Each application that is executed in pFlow, should have 
-// settings/systemControl file in it. 
-// This  repository holds two main repositories: Time and settings 
-
+#include "demComponent.hpp"
 #include "systemControl.hpp"
-#include "timeFolder.hpp"
+#include "Time.hpp"
 
-namespace pFlow
+pFlow::demComponent::demComponent(const word& name, systemControl& control)
+:
+	control_(control),
+	time_(control.time()),
+	timers_(name, &control.timers()),
+  componentName_(name)
+{}
+
+pFlow::real pFlow::demComponent::dt()const
 {
-
-
-inline systemControl& Control()
-{
-	static systemControl control_;
-	return control_;
+	return time_.dt();
 }
 
-} // pFlow
+pFlow::real pFlow::demComponent::currentTime()const
+{
+   return time_.currentTime();
+}
 
-
-#endif // __Control_hpp__
+pFlow::uint32 pFlow::demComponent::currentIter() const
+{
+  return time_.currentIter();
+}
diff --git a/src/demComponent/demComponent.hpp b/src/phasicFlow/demComponent/demComponent.hpp
similarity index 88%
rename from src/demComponent/demComponent.hpp
rename to src/phasicFlow/demComponent/demComponent.hpp
index d5ad1635..cbab450e 100644
--- a/src/demComponent/demComponent.hpp
+++ b/src/phasicFlow/demComponent/demComponent.hpp
@@ -21,13 +21,15 @@ Licence:
 #ifndef __demComponent_hpp__ 
 #define __demComponent_hpp__
 
-#include "systemControl.hpp"
-
-
+#include "types.hpp"
+#include "typeInfo.hpp"
+#include "Timers.hpp"
 
 namespace pFlow
 {
 
+class systemControl;
+class Time;
 /**
  * A base class for every main component of DEM system.
  * 
@@ -38,19 +40,20 @@ namespace pFlow
  */
 class demComponent
 {
-protected:
-
-	// - Protected data members 
-
-		/// Name of the DEM component 
-		word 	componentName_;
-
+private:
+	// - Protected data members 		
+		
 		/// Reference to systemControl 
-		systemControl& control_;
+		systemControl& 	control_;
+
+		Time& 			time_;
 
 		/// All timers (if any) of this component
 		Timers 	timers_;
 
+		/// Name of the DEM component 
+		word 	componentName_;
+
 public:
 
 	/// Type info
@@ -59,13 +62,8 @@ public:
 	// - Constructors
 	
 		/// construct from components
-		demComponent(const word& name, systemControl& control)
-		:
-			componentName_(name),
-			control_(control),
-			timers_(name, &control.timers())
-		{}
-
+		demComponent(const word& name, systemControl& control);
+		
 		/// No copy constructor
 		demComponent(const demComponent&) = delete;
 
@@ -99,19 +97,26 @@ public:
 		}
 
 		/// Time step of integration
+		real dt()const;
+		
+		/// Current simulation time 
+		real currentTime()const;
+
+		uint32 currentIter()const;
+		
 		inline
-		real dt()const
+		const auto& time()const
 		{
-			return control_.time().dt();
+			return time_;
 		}
 
-		/// Current simulation time 
-		inline
-		real currentTime()const
+		inline 
+		auto& time()
 		{
-			return control_.time().currentTime();
+			return time_;
 		}
 
+
 		/// Const ref to timers
 		inline
 		const auto& timers() const
diff --git a/src/phasicFlow/dictionary/dictionary.cpp b/src/phasicFlow/dictionary/dictionary.cpp
index 4d9f5464..58a76958 100644
--- a/src/phasicFlow/dictionary/dictionary.cpp
+++ b/src/phasicFlow/dictionary/dictionary.cpp
@@ -299,6 +299,13 @@ pFlow::dictionary::dictionary
 
 }
 
+pFlow::dictionary::dictionary(const dictionary &src, bool global)
+:
+	dictionary(src)
+{
+	isGlobal_ = global;
+}
+
 pFlow::dictionary& pFlow::dictionary::operator=
 (
 	const dictionary& rhs
@@ -378,7 +385,8 @@ bool pFlow::dictionary::isFileDict()const
 bool  pFlow::dictionary::addPtr
 (
 	const word& keyword,
-	uniquePtr<iEntry>& entry
+	uniquePtr<iEntry>& entry,
+	bool warning
 )
 {
 
@@ -390,9 +398,13 @@ bool  pFlow::dictionary::addPtr
 	// search all entries for repeated keyword
 	if(auto [ptr, exist] = entries_.find(keyword); exist )
 	{
-		warningInFunction <<
-		"keyword " << keyword << " already exists in the dicrionary " <<
-		this->globalName() << ". The old entry will be replaced by the new one. \n";
+		if(warning)
+		{
+			warningInFunction <<
+			"keyword " << keyword << " already exists in the dicrionary " <<
+			this->globalName() << ". The old entry will be replaced by the new one. \n";
+		}
+		
 		// store the old pointer to entry
 		oldEntryPtr = ptr;
 	}
@@ -400,6 +412,7 @@ bool  pFlow::dictionary::addPtr
 	
 	if( entries_.insertReplace(keyword, entry) )
 	{
+	
 		if(oldEntryPtr)
 		{
 			// this should be replaced 
@@ -468,15 +481,6 @@ bool pFlow::dictionary::add
 	return addPtr(keyword, ptr);
 }
 
-bool pFlow::dictionary::add
-(
-	const word& keyword,
-	const int16& v
-)
-{
-	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
-	return addPtr(keyword, ptr);
-}
 
 bool pFlow::dictionary::add
 (
@@ -491,7 +495,7 @@ bool pFlow::dictionary::add
 bool pFlow::dictionary::add
 (
 	const word& keyword,
-	const label& v
+	const uint64& v
 )
 {
 	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
@@ -508,6 +512,15 @@ bool pFlow::dictionary::add
 	return addPtr(keyword, ptr);
 }
 
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const uint8& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}
 
 bool pFlow::dictionary::addDict
 (
diff --git a/src/phasicFlow/dictionary/dictionary.hpp b/src/phasicFlow/dictionary/dictionary.hpp
index 3ad26c06..9baba109 100644
--- a/src/phasicFlow/dictionary/dictionary.hpp
+++ b/src/phasicFlow/dictionary/dictionary.hpp
@@ -34,7 +34,36 @@ Licence:
 namespace pFlow
 {
 
-
+/**
+ *  Dictionary holds a set of data entries or sub-dictionaries that are enclosed 
+ * 	in a curely braces or are in a file. 
+ *  
+ *  data entry format is: 
+ *  ```
+ *  entryName 	value;
+ *  ```
+ *  and a dictionary in a file can be: 
+ * ```
+ * entryName2  value2;
+ * 
+ * entryName3  value3;
+ * 
+ * subDict1
+ * {
+ *    entryName4 value4;
+ *   
+ *    ....
+ *   
+ * }
+ * 
+ * subDict2
+ * {
+ 	* ...
+ * }
+ * 
+ * ```
+ * 
+ */
 class dictionary
 :
 	public iEntry
@@ -43,40 +72,42 @@ protected:
 
 	//// - Data members
 
-		// global name of dictionary, separated with dots
+		/// global name of dictionary, separated with dots
 		word name_;
 
-		// all the entries (data and dictionary) of the current dictionary
+		/// all the entries (data and dictionary) of the current dictionary
 		wordOrderedMapPtr<iEntry> entries_;
 
-		// entries in order of insertion
+		/// entries in order of insertion
 		List<iEntry*> orderedEntries_;
 
-		// - ref to parrent dictionary
+		/// ref to parrent dictionary
 		const dictionary& parDict_;
 
-		bool isGlobal_;
+		bool isGlobal_ = false;
 
 
-	//// - protected methods 
+	///// protected methods 
 
-		// - find an entry based on keyword
-		//   return nullptr if not found
+		/// find an entry based on keyword
+		///   return nullptr if not found
 		iEntry* findEntry(const word& keyword);
 
-		// - find and entry based on keyword
-		//   return nullptr if not found
+		/// find and entry based on keyword
+		///   return nullptr if not found
 		iEntry* findEntry(const word& keyword)const;
 
-		// - reads a dataEntry with keyword from dictionary
+		/// reads a dataEntry with keyword from dictionary
 		template<typename T>
 		bool readDataEntry( const word& keyword, T& val)const;
 
-		// - read dictionary from stream - without keyword
+		/// read dictionary from stream - without keyword
 		bool readDictionary(iIstream & is);
 
-		// - write dictionary to stream - with keyword
+		/// write dictionary to stream - with keyword
 		bool writeDictionary(iOstream& os, bool withBlock = true)const;
+
+        
 	
 
 public:
@@ -87,185 +118,193 @@ public:
 	TypeInfo("dictionary");
 
 	//// - Constructors
-
-		// - cunstructs a null dictionary
-		dictionary();
-
-		// - construct an empty dictionary with keyword
-		dictionary(const word& keyword);
-
-		// - construct an empty dictionary with keyword and make it global/fileDictionary (if true)
+		/// construct an empty dictionary with keyword and make it global/fileDictionary (if true)
 		dictionary(const word& keyword, bool global);
 
-		// - construct a dictionary with name and read it from file 
+		/// construct a dictionary with name and read it from file 
 		dictionary(const word& keyword, const fileSystem& file);
+		
+		/// cunstructs a null dictionary
+		dictionary();
 
-		// - cunstruct an empty dictionary with keyword and parDict
+		/// construct an empty dictionary with keyword
+		dictionary(const word& keyword);
+
+		/// cunstruct an empty dictionary with keyword and parDict
 		dictionary(const word& keyword, const dictionary& parDict);
 
-		// - cunstruct a dictionary with keyword and parDict and from stream
+		/// cunstruct a dictionary with keyword and parDict and from stream
 		dictionary( const word& keyword, const dictionary& parDict, iIstream& is);
 
-		// - copy construct with keyword and new parrent dict
-		//   discard the keyword and parDict of dict
+		/// copy construct with keyword and new parrent dict
+		/// discard the keyword and parDict of dict
 		dictionary(const word& keyword, const dictionary& parDict, const dictionary& dict);
 
-		// - copy construct as default behavior
-		// 	 entries_ are copied smoothly. set parrent dict to nullDict
+		/// copy construct as default behavior
+		/// entries_ are copied smoothly. set parrent dict to nullDict
 		dictionary(const dictionary& );
 
+		dictionary(const dictionary& src, bool global);
 
-		// - assignment preserve name of this dictionary 
-		// - only entries are transfered with ownership
+
+		/// assignment preserve name of this dictionary 
+		/// only entries are transfered with ownership
 		dictionary& operator=(const dictionary& rhs);
 
 
 	//// - Methods
 
-		// - pointer to this dictionary
+		/// pointer to this dictionary
 		virtual dictionary* dictPtr();
 		
-		// - pointer to this dictionary
+		/// pointer to this dictionary
 		virtual const dictionary* dictPtr() const;
 		
-		// - if this is a dictionary
+		/// if this is a dictionary
 		virtual bool isDictionary() const;
 
-		// - global name of entry, separated with dots
+		/// global name of entry, separated with dots
 		virtual word globalName()const;
 
-		// - const ref to parrent dictionary 
+		/// const ref to parrent dictionary 
 		virtual const dictionary& parrentDict() const;
 
-		// - ref to this dictionary, if it is a dictionary
+		/// ref to this dictionary, if it is a dictionary
 		virtual dictionary& dict();
 
-		// - const ref to this dictionary, if it is a dictionary
+		/// const ref to this dictionary, if it is a dictionary
 		virtual const dictionary& dict() const;
 
-		// - if dictionary is file dictionary, return false
+		/// if dictionary is file dictionary, return false
 		virtual bool isFileDict()const;
 
-		// - add a pointer entry (dictionary/dataEntry)
-		//   replaces this entry with existing one
-		bool addPtr(const word& keyword, uniquePtr<iEntry>& etry );
+		/// @brief add a pointer entry (dictionary/dataEntry)
+		///   replaces this entry with existing one and issue a warning
+		bool addPtr(const word& keyword, uniquePtr<iEntry>& etry, bool warning = true );
 
-		// - add a float dataEntry 
+
+		/// add a float dataEntry 
 		bool add(const word& keyword, const float& v);
 
-		// - add a double dataEntry
+		/// add a double dataEntry
 		bool add(const word& keyword, const double& v);
 
-		// - add a word dataEntry
+		/// add a word dataEntry
 		bool add(const word& keyword, const word& v);
 
-		// - add a int64 dataEntry
+		/// add a int64 dataEntry
 		bool add(const word& keyword, const int64& v);
 
-		// - add a int32 dataEntry
+		/// add a int32 dataEntry
 		bool add(const word& keyword, const int32& v);
 
-		// - add a int16 dataEntry
-		bool add(const word& keyword, const int16& v);
-
-		// - add a int8 dataEntry
+		/// add a int8 dataEntry
 		bool add(const word& keyword, const int8& v);
 
-		// - add a label dataEntry
-		bool add(const word& keyword, const label& v);
+		/// add a uint64 dataEntry
+		bool add(const word& keyword, const uint64& v);
 
-		// - add a uint32 dataEntry
+		/// add a uint32 dataEntry
 		bool add(const word& keyword, const uint32& v);
 
-		// add a dictionary with the specifiedd keyword
+		/// add a uint8 dataEntry
+		bool add(const word& keyword, const uint8& v);
+
+		/// @brief add a dictionary with the specifiedd keyword, if 
+		/// it exists, replace it.
 		bool addDict(const word& keyword, const dictionary& dict);
 
-		// - add a dataEntry of type T
+		/// add a dataEntry of type T
 		template<typename T>
 		bool add(const word& keyword, const T& v );
 
+		template<typename T>
+		bool addOrKeep(const word& keyword, const T& v);
+
+        template<typename T>
+        bool addOrReplace(const word& keyword, const T& v);
 
 		void clear();
 
-		// - pointer to a subdictionary 
-		//   fatalExit if not found
+		/// pointer to a subdictionary 
+		///  fatalExit if not found
 		dictionary* subDictPtr(const word& keyword);
 
-		// - ref to a subdictioanry 
-		//   fatalExit if not found 
+		/// ref to a subdictioanry 
+		///  fatalExit if not found 
 		dictionary& subDict(const word& keyword);
 
-		// - const ref to a subdictioanry 
-		//   fatalExit if not found 
+		/// const ref to a subdictioanry 
+		///  fatalExit if not found 
 		const dictionary& subDict(const word& keyword) const;
 
-		// - pointer to a dataEntry 
-		//   fatalExit if not found/not a dataEntry
+		/// pointer to a dataEntry 
+		///  fatalExit if not found/not a dataEntry
 		dataEntry* dataEntryPtr(const word& keyword);
 
-		// - ref to a subdictioanry 
-		//   fatalExit if not found/not a dataEntry 
+		/// ref to a subdictioanry 
+		///  fatalExit if not found/not a dataEntry 
 		dataEntry& dataEntryRef(const word& keyword);
 
-		// - const ref to a subdictioanry 
-		//   fatalExit if not found/not a dataEntry 
+		/// const ref to a subdictioanry 
+		///  fatalExit if not found/not a dataEntry 
 		const dataEntry& dataEntryRef(const word& keyword)const;
 
-		// - search for a sub-dict with keyword
-		//   create a new sub-dict if not found and return a ref to it
-		//   fatalExit if fails
+		/// search for a sub-dict with keyword
+		/// create a new sub-dict if not found and return a ref to it
+		/// fatalExit if fails
 		dictionary& subDictOrCreate(const word& keyword);
 		
-		// - get the value of data entry 
+		/// get the value of data entry 
 		template<typename T>
 		T getVal(const word& keyword) const;
 
-		// - get the value of data entry or 
-		//   if not found, set the value to setVal
+		/// get the value of data entry or 
+		/// if not found, set the value to setVal
 		template<typename T>
 		T getValOrSet(const word& keyword, const T& setVal)const;
 
-		// return number of entris in this dictionary
+		/// return number of entris in this dictionary
 		size_t numEntries()const;
 		
-		// return number of non-nullptr dataEntries
+		/// return number of non-nullptr dataEntries
 		size_t numDataEntries()const;
 
-		// return number of non-nullptr dictionaries
+		/// return number of non-nullptr dictionaries
 		size_t numDictionaries()const;
 
-		// return all keywords (non-nullptr) in this dictionary
+		/// return all keywords (non-nullptr) in this dictionary
 		wordList allKeywords()const;
 
-		// return a list of all dataEntries (non-nullptr) keywords
+		/// return a list of all dataEntries (non-nullptr) keywords
 		wordList dataEntryKeywords()const;
 
-		// return a list of all dictionary (non-null) keywords
+		/// return a list of all dictionary (non-null) keywords
 		wordList dictionaryKeywords()const;
 
-		// check if a sub-dictionary exists
+		/// check if a sub-dictionary exists
 		bool containsDictionay(const word& name)const;
 		
-		// check if a data entry exist
+		/// check if a data entry exist
 		bool containsDataEntry(const word& name)const;
 
-		// clone polymorphic object (here dictionary)
+		/// clone polymorphic object (here dictionary)
 		virtual uniquePtr<iEntry> clone() const;
 
 		virtual iEntry* clonePtr() const;
 
-		// - clone the polymorhpic object with parDict as the new parrent dictionary
+		/// clone the polymorhpic object with parDict as the new parrent dictionary
 		virtual uniquePtr<iEntry> clone(const dictionary& parDict)const;
 
 		virtual iEntry* clonePtr(const dictionary& parDict) const;
 
 
-	//// IO operations 
+	//// - IO operations 
 
-		// - read from stream
+		/// read from stream
 		virtual bool read(iIstream& is);
 
-		// - write to stream
+		/// write to stream
 		virtual bool write(iOstream& os) const;
 
 };
@@ -282,6 +321,19 @@ bool dictionary::add(const word& keyword, const T& v )
 }
 
 
+template<typename T>
+bool dictionary::addOrKeep(const word& keyword, const T& v )
+{
+	if(!containsDataEntry(keyword))
+	{
+		uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this ,v);
+		return addPtr(keyword, ptr);
+	}
+	
+	return true;
+}
+
+
 template<typename T>
 bool dictionary::readDataEntry
 (
@@ -338,7 +390,20 @@ T dictionary::getValOrSet
 	}
 }
 
+template <typename T>
+inline bool dictionary::addOrReplace
+(
+    const word &keyword, 
+    const T &v
+)
+{
+    uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this ,v);
+    return addPtr(keyword, ptr, false);
 }
 
 
+
+
+} // pFlow
+
 #endif // __dictionary_hpp__
diff --git a/src/phasicFlow/dictionary/entry/dataEntry.hpp b/src/phasicFlow/dictionary/entry/dataEntry.hpp
index 76a6d793..d7c29447 100644
--- a/src/phasicFlow/dictionary/entry/dataEntry.hpp
+++ b/src/phasicFlow/dictionary/entry/dataEntry.hpp
@@ -36,7 +36,15 @@ namespace pFlow
 
 class dictionary;
 
-
+/**
+ * Data entry to be used in dictionries. Its format is:
+ * 
+ * ```
+ * entryName   value;
+ * 
+ * entryName2  (list of values);
+ * ```
+ */
 class dataEntry
 :
 	public iEntry
@@ -46,19 +54,19 @@ protected:
 
 	//// - data memebers
 
-		// - ref to parrent dictionary
+		/// ref to parrent dictionary
 		const dictionary& parDict_;
 
-		// - list the tokens as input token stream
+		/// list the tokens as input token stream
 		iTstream tokenStream_;
 
 
 	//// - protected member functions
 
-		// - read dataEntry from stream
+		/// read dataEntry from stream
 		bool readDataEntry(iIstream& is);
 
-		// - write dataEntry to stream
+		/// write dataEntry to stream
 		bool writeDataEntry(iOstream& os) const;
 
 public:
@@ -67,57 +75,57 @@ public:
 
 	//// - constructors
 
-		// - construct null dataEntry
+		/// construct null dataEntry
 		dataEntry();
 
-		// - construct from keyword and parDict, empty dataEntry
+		/// construct from keyword and parDict, empty dataEntry
 		dataEntry(const word& keyword, const dictionary& parDict);
 
-		// - construct from keyword, parDict and input token stream
+		/// construct from keyword, parDict and input token stream
 		dataEntry(const word& keyWord, const dictionary& parDict, const iTstream& is);
 
 		//- construct from keyword, parDict and input stream
 		dataEntry(const word& keyWord, const dictionary& parDict, iIstream& is);
 		
-		// - construct from keyword, parDict and a single token
+		/// construct from keyword, parDict and a single token
 		dataEntry(const word& keyword, const dictionary& parDict, const token& tok);
 
-		// - construct from keyword, parDict, and data of type T
+		/// construct from keyword, parDict, and data of type T
 		template<typename T>
 		dataEntry(const word& keyword, const dictionary& parDict, const T& v);
 
-		// - copy construct with new keyword and parDict
+		/// copy construct with new keyword and parDict
 		dataEntry(const word& keyword, const dictionary& parDict, const dataEntry& entry );
 		
-		// - copy construct
+		/// copy construct
 		dataEntry(const dataEntry& src )= default;
 
 
 	//// - Methods
 	
-		// - global name of entry, separated with dots
+		/// global name of entry, separated with dots
 		virtual word globalName()const;
 
 		
-		// - access to token stream
+		/// access to token stream
 		virtual iTstream& stream();
 
-		// - not permited to be called
+		/// not permited to be called
 		virtual dictionary* dictPtr();
 		
-		// - not permited to be called
+		/// not permited to be called
 		virtual const dictionary* dictPtr() const;
 		
-		// - should returen false;
+		/// should returen false;
 		virtual bool isDictionary()const;
 		
-		// - const ref to parrent dictionary 
+		/// const ref to parrent dictionary 
 		virtual const dictionary& parrentDict() const;
 
-		// - not permited to be called
+		/// not permited to be called
 		virtual dictionary& dict();
 
-		// - not permited to be called
+		/// not permited to be called
 		virtual const dictionary& dict() const;
 
 		// clone the object
@@ -132,10 +140,10 @@ public:
 
 	//// - IO operations 
 
-		// - read from stream
+		/// read from stream
 		virtual bool read(iIstream& is);
 
-		// - write to stream
+		/// write to stream
 		virtual bool write(iOstream& os) const;
 
 };
diff --git a/src/phasicFlow/dictionary/entry/iEntry.hpp b/src/phasicFlow/dictionary/entry/iEntry.hpp
index c2e3bfa4..359131d4 100644
--- a/src/phasicFlow/dictionary/entry/iEntry.hpp
+++ b/src/phasicFlow/dictionary/entry/iEntry.hpp
@@ -35,6 +35,10 @@ namespace pFlow
 
 class dictionary;
 
+/**
+ *  Interface calss for data entry and dictionary  
+ * 
+ */
 class iEntry
 {
 
@@ -42,10 +46,10 @@ public:
 	
 	//// - public static methods
 
-		// - read a keyword from stream 
+		/// read a keyword from stream 
 		static bool readKeyword(iIstream &is, word& keyword, token& tok );
 
-		// - create an entry (dataEntry or dictionary) from stream 
+		/// create an entry (dataEntry or dictionary) from stream 
 		static bool createEntry(dictionary& parDict, iIstream& is, bool hasBlockToken = false);
 
 protected:
@@ -57,41 +61,42 @@ protected:
 
 public:
 	
-
+	/// Type info
 	TypeInfo("iEntry");
 
 	//// - Constructors
 
-		// - empty constructor
+		/// empty constructor
 		iEntry()
 		{}
 
-		// - construct with a keyword
+		/// construct with a keyword
 		iEntry(const word& key)
 		{
 			// this moved here due to a very strange core dumped error!
 			keyword_ = key;
 		}
 
-		// - destructor
+		/// destructor
 		virtual ~iEntry()
 		{}
 
 
 	//// - Methods
 
-		// - return keyword
+		/// return keyword
 		virtual const word& keyword() const
 		{
 			return keyword_;
 		}
 
-		// - return keyword
+		/// return keyword
 		virtual word& keyword()
 		{
 			return keyword_;
 		}
 
+		/// name/keyword of entry 
 		virtual word name()const
 		{
 			return keyword();
@@ -100,49 +105,50 @@ public:
 		// global name of entry, separated with dots
 		virtual word globalName()const = 0;
 
-		// - pointer to this dictionary
+		/// pointer to this dictionary
 		virtual dictionary* dictPtr()
 		{
 			return nullptr;
 		}
 
-		// - const pointer to this dictionary
+		/// const pointer to this dictionary
 		virtual const dictionary* dictPtr() const
 		{
 			return nullptr;
 		}
 
-		// - if this is a dictionary
+		/// if this is a dictionary
 		virtual bool isDictionary() const
 		{
 			return false;
 		}
 
-		// - const ref to parrent dictionary 
+		/// const ref to parrent dictionary 
 		virtual const dictionary& parrentDict() const = 0;
 		
-		// - ref to this dictionary, if it is a dictionary
+		/// ref to this dictionary, if it is a dictionary
 		virtual dictionary& dict() = 0;
 
-		// - const ref to this dictionary, if it is a dicrionary
+		/// const ref to this dictionary, if it is a dicrionary
 		virtual const dictionary& dict() const = 0;
 
-		// clone the object
+		/// clone the object
 		virtual iEntry* clonePtr() const = 0;
 
 		virtual uniquePtr<iEntry> clone() const = 0;
 
-		// clone the object and change its ownership to parDict 
+		/// clone the object and change its ownership to parDict 
 		virtual iEntry* clonePtr(const dictionary& parDict) const = 0;
 
+		/// clone the object and change its ownership to parDict 
 		virtual uniquePtr<iEntry> clone(const dictionary& parDict)const = 0;
 
 	//// - IO operatoins
 
-		// read from stream
+		/// read from stream
 		virtual bool read(iIstream& is) = 0;
 
-		// write to stream
+		/// write to stream
 		virtual bool write(iOstream& os) const =0;
 
 };
@@ -150,11 +156,10 @@ public:
 
 iOstream& operator << (iOstream& os, const iEntry& e);
 
-
 iIstream& operator >> (iIstream& is, iEntry& e);
 
 
-}
+} // pFlow
 
 
 #endif //__iEntry_hpp__
diff --git a/src/phasicFlow/dictionary/fileDictionary.cpp b/src/phasicFlow/dictionary/fileDictionary.cpp
new file mode 100644
index 00000000..0b4eb37c
--- /dev/null
+++ b/src/phasicFlow/dictionary/fileDictionary.cpp
@@ -0,0 +1,78 @@
+#include "fileDictionary.hpp"
+
+
+pFlow::fileDictionary::fileDictionary
+(
+    const objectFile & of, 
+    repository* owner
+)
+:
+    IOobject
+    (
+        of, 
+        IOPattern::AllProcessorsSimilar, 
+        owner
+    ),
+    dictionary
+    (
+        of.name(), 
+        true
+    )
+{
+    dictionary::name_ = IOobject::path().wordPath();
+    if(!IOobject::readObject())
+    {
+        fatalErrorInFunction<<
+        "Error in reading from dictionary "<< globalName()<<endl;
+        fatalExit;
+    }
+}
+
+pFlow::fileDictionary::fileDictionary(const word &keyword, const fileSystem &file)
+:
+    fileDictionary
+    (
+        objectFile
+        (
+            keyword,
+            file,
+            objectFile::READ_ALWAYS,
+            objectFile::WRITE_NEVER
+        ),
+        nullptr
+    )
+{}
+
+pFlow::fileDictionary::fileDictionary
+(
+    const objectFile &objf, 
+    const dictionary &dict, 
+    repository *owner
+)
+:
+    IOobject
+    (
+        objectFile
+        (
+            objf.name(),
+            objf.localPath(),
+            objectFile::READ_NEVER,
+            objf.wFlag()
+        ), 
+        IOPattern::AllProcessorsSimilar, 
+        owner
+    ),
+    dictionary(dict, true)
+{
+    dictionary::name_ = IOobject::path().wordPath();
+}
+
+bool pFlow::fileDictionary::read(iIstream &is, const IOPattern &iop)
+{
+    return dictionary::read(is);
+}
+
+bool pFlow::fileDictionary::write(iOstream &os, const IOPattern &iop) const
+{
+    return dictionary::write(os);
+}
diff --git a/src/Interaction/interaction/interactionBase.hpp b/src/phasicFlow/dictionary/fileDictionary.hpp
similarity index 56%
rename from src/Interaction/interaction/interactionBase.hpp
rename to src/phasicFlow/dictionary/fileDictionary.hpp
index b5c9651e..b8685dfd 100644
--- a/src/Interaction/interaction/interactionBase.hpp
+++ b/src/phasicFlow/dictionary/fileDictionary.hpp
@@ -17,68 +17,44 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
+#ifndef __fileDictionary_hpp__
+#define __fileDictionary_hpp__
 
-#ifndef __interactionBase_hpp__ 
-#define __interactionBase_hpp__
-
-#include "interactionTypes.hpp"
-#include "particles.hpp"
-#include "geometry.hpp"
+#include "dictionary.hpp"
+#include "IOobject.hpp"
 
 namespace pFlow
 {
 
-class interactionBase
+class fileDictionary
+:
+    public IOobject,
+    public dictionary
 {
 public:
 
-	using IndexType    			= CELL_INDEX_TYPE;
+    TypeInfo("fileDictionary");
 
-	using IdType  				= ID_TYPE;
+    /// construct an empty dictionary with keyword and make it global/fileDictionary
+	fileDictionary(const objectFile & of, repository* owner = nullptr);
 
-	using ExecutionSpace 	 	= DefaultExecutionSpace;
+	/// construct a dictionary with name and read it from file 
+	fileDictionary(const word& keyword, const fileSystem& file);
 
-protected:
+  fileDictionary(
+    const objectFile& objf, 
+    const dictionary& dict, 
+    repository* owner=nullptr);
 
-	const particles& 		particles_;
+    /// read from stream 
+    bool read(iIstream& is, const IOPattern& iop) override;
 
-	const geometry& 		geometry_;
+	/// write to stream
+	
+    bool write(iOstream& os, const IOPattern& iop) const override;
 
-public:
-
-	interactionBase(
-		const particles& prtcl,
-		const geometry& geom)
-	:
-		particles_(prtcl),
-		geometry_(geom)
-	{}
-
-	inline
-	const auto& pStruct()const
-	{
-		return particles_.pStruct();
-	}
-
-	inline
-	const auto& surface()const
-	{
-		return geometry_.surface();
-	}
-
-	inline 
-	const auto& Particles()const
-	{
-		return particles_;
-	}
-
-	inline auto& Geometry()const
-	{
-		return geometry_;
-	}
 };
 
 }
 
-
-#endif //__interactionBase_hpp__
+#endif //__fileDictionary_hpp__
\ No newline at end of file
diff --git a/src/phasicFlow/eventManagement/eventManagement.hpp b/src/phasicFlow/eventManagement/eventManagement.hpp
new file mode 100644
index 00000000..3b07b2be
--- /dev/null
+++ b/src/phasicFlow/eventManagement/eventManagement.hpp
@@ -0,0 +1,16 @@
+#ifndef __eventManagement_hpp__
+#define __eventManagement_hpp__
+
+#include "subscriber.hpp"
+#include "observer.hpp"
+#include "pointMessage.hpp"
+
+namespace pFlow
+{
+
+using pointSubcriber = subscriber<pointMessage>
+
+}
+
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/eventManagement/message.hpp b/src/phasicFlow/eventManagement/message.hpp
new file mode 100644
index 00000000..7d811fc5
--- /dev/null
+++ b/src/phasicFlow/eventManagement/message.hpp
@@ -0,0 +1,210 @@
+/*------------------------------- 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 __message_hpp__
+#define __message_hpp__
+
+#include <bitset>
+#include <array>
+
+#include "types.hpp"
+#include "iOstream.hpp"
+
+
+namespace pFlow
+{
+
+class message
+{
+public:
+	enum EVENT : size_t
+	{
+		DEFAULT 		= 0,
+		CAP_CHANGED 	= 1,  // internal points capacity changed 
+		SIZE_CHANGED 	= 2,  // internal points size changed
+		ITEM_DELETE	 	= 3,  // internal points item deleted 
+		ITEM_INSERT  	= 4,  // internal points item inserted 
+		RANGE_CHANGED   = 5,  // internal points range changed 
+		ITEM_REARRANGE  = 6,  // internal points item rearrange
+		ITEM_FLAGCHANGED= 7,  // internal points item flag changed, this occurs when transfer occurs
+		BNDR_REARRANGE 	= 8,  // boundary indices rearrange 
+		BNDR_TRANSFER   = 9,  // boundary indices transfered
+		BNDR_RESET		= 10,  // boundary indices reset entirely  
+		BNDR_DELETE 	= 11,  // boundary indices deleted
+		BNDR_APPEND		= 12
+	};
+
+	
+private:
+
+	static constexpr size_t numberOfEvents_ = 13;
+
+	std::bitset<numberOfEvents_> events_{0x0000};
+	
+	static
+	inline const std::array<word,numberOfEvents_> eventNames_
+	{
+		"",
+		"capacity",
+		"size",
+		"deletedIndices",
+		"insertedIndices",
+		"range",
+		"rearrangedIndices",
+		"transferredIndices",
+		"rearrangedIndices",
+		"transferredIndices",
+		"",
+		"deletedIndices",
+		"appendedIndices"
+	};
+
+public:
+
+	message()=default;
+
+	message(EVENT evnt)
+	{
+		add(evnt);
+	}
+
+	message(size_t i )
+	{
+		if(i<numberOfEvents_)
+		{
+			events_.set(i);
+		}
+	}
+
+	message(const message&) = default;
+
+	message(message&&) = default;
+
+	message& operator=(const message&) = default;
+
+	message& operator=(message&&) = default;
+
+	~message()=default;
+
+	inline message& add( EVENT evnt)
+	{
+		events_.set(static_cast<size_t>(evnt));
+		return *this;
+	}
+
+	inline message& remove(EVENT evnt)
+	{
+		events_.set(static_cast<size_t>(evnt), false);
+		return *this;
+	}
+
+	inline bool equivalentTo( EVENT evnt )const
+	{
+		return equivalentTo(static_cast<size_t>(evnt));
+	}
+
+	inline bool equivalentTo(size_t i)const
+	{
+		return events_.test(i);
+	}
+
+	inline bool isNull()const
+	{
+		return events_.none();
+	}
+
+	inline auto size()const
+	{
+		return events_.size();
+	}
+
+	inline
+	message& operator+(EVENT evnt)
+	{
+		return add(evnt);
+	}
+
+	inline
+	message& operator-(EVENT evnt)
+	{
+		return remove(evnt);
+	}
+
+	inline 
+	message& operator+(const message& msg)
+	{
+		for(size_t i=0uL; i< events_.size(); i++)
+		{
+			if(msg.equivalentTo(i))
+			{
+				events_.set(i);
+			}
+		}
+		return *this;
+	}
+	
+	static
+	auto constexpr numEvents()
+	{
+		return numberOfEvents_;
+	}
+	static 
+	message Default()
+	{
+		message msg;
+		return msg+DEFAULT;
+	}
+
+	static 
+	message Empty()	
+	{
+		message msg;
+		return msg;
+	}
+
+	static
+	const word& eventName(size_t event)
+	{
+		return eventNames_[event];
+	}
+	
+};
+
+inline
+iOstream& operator<<(iOstream& os, const message& msg)
+{
+	for(size_t i=msg.size(); i>0; i--)
+	{
+		os<< msg.equivalentTo(i-1)? '1':0;
+	}
+	os<<endl;
+
+	return os;
+}
+
+inline
+message operator + (message::EVENT evnt1, message::EVENT evnt2)
+{
+	message msg = message::Empty().add(evnt1).add(evnt2);
+	return msg;
+}
+
+}
+
+#endif // __eventMessage_hpp__
diff --git a/src/phasicFlow/eventManagement/observer.cpp b/src/phasicFlow/eventManagement/observer.cpp
new file mode 100644
index 00000000..d7bf299a
--- /dev/null
+++ b/src/phasicFlow/eventManagement/observer.cpp
@@ -0,0 +1,98 @@
+/*------------------------------- 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 "observer.hpp"
+#include "subscriber.hpp"
+
+const pFlow::subscriber *pFlow::observer::changeSubscriber(const subscriber *newSub)
+{
+	const subscriber* old = subscriber_;
+	subscriber_ = newSub;
+    return old;
+}
+
+pFlow::observer::observer(message msg) : subscriber_(nullptr),
+                                         message_(msg)
+{}
+
+pFlow::observer::observer
+(
+	const subscriber* subscrbr,
+	message msg
+)
+{
+	addToSubscriber(subscrbr, msg);
+}
+
+pFlow::observer::~observer()
+{
+	if(subscriber_)
+		subscriber_->unsubscribe(this);
+	invalidateSubscriber();
+}
+
+pFlow::observer &pFlow::observer::addEvent(message::EVENT event)
+{
+    if( !message_.equivalentTo(event) )
+	{
+		message_.add(event);
+		if(!subscriber_->subscribe(message(event),this))
+		{
+			fatalErrorInFunction<<
+			"error when subcribing event from observer "<<endl;
+			fatalExit;
+		}
+	}
+	return *this;
+}
+
+void pFlow::observer::addToSubscriber
+(
+	const subscriber* subscrbr, 
+	message msg
+)
+{
+	if(subscriber_)
+		subscriber_->unsubscribe(this);
+	invalidateSubscriber();
+
+	subscriber_ = subscrbr;
+	message_ = msg;
+
+	if(subscriber_)
+	{
+		if(!subscriber_->subscribe(message_, this))
+		{
+			fatalErrorInFunction<<
+			"error in subscribing an observer"<<endl;
+			fatalExit;
+		}
+	}	
+}
+
+bool pFlow::observer::addToSubscriber(const subscriber& subscrbr)
+{
+	if(subscriber_)
+		subscriber_->unsubscribe(this);
+	invalidateSubscriber();
+
+	subscriber_ = &subscrbr;
+	return subscriber_->subscribe(message_, this);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/eventManagement/observer.hpp b/src/phasicFlow/eventManagement/observer.hpp
new file mode 100644
index 00000000..0c193f4c
--- /dev/null
+++ b/src/phasicFlow/eventManagement/observer.hpp
@@ -0,0 +1,101 @@
+/*------------------------------- 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 __observer_hpp__
+#define __observer_hpp__
+
+#include "message.hpp"
+
+namespace pFlow
+{
+
+class subscriber;
+class anyList;
+
+class observer
+{
+private:
+	
+
+	/// pointer to subscriber 
+	const subscriber* 	subscriber_ = nullptr;
+	
+	/// list of events in the message 
+	message 			message_;
+
+	friend subscriber;
+	
+	const subscriber* changeSubscriber(const subscriber* newSub);
+
+	inline void invalidateSubscriber()
+	{
+		subscriber_ = nullptr;
+	}
+
+public:
+
+	observer(message msg);
+
+	observer(
+		const subscriber* subscrbr, 
+		message msg);
+
+	virtual 
+	~observer();
+
+	void subscribe(
+		const subscriber* subscrbr, 
+		message msg);
+	
+	observer& addEvent(message::EVENT event);
+
+	inline 
+	bool subscribed()const 
+	{
+		return subscriber_!=nullptr;
+	}
+
+	void addToSubscriber(
+		const subscriber* subscrbr, 
+		message msg);
+
+	bool addToSubscriber(const subscriber& subscriber);
+	
+	
+
+	static
+	constexpr auto numEvents()
+	{
+		return message::numEvents();
+	} 
+
+	virtual bool hearChanges(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+		const anyList& varList)=0;
+};
+
+} // pFlow
+
+
+#endif // __observer_hpp__
diff --git a/src/phasicFlow/eventManagement/subscriber.cpp b/src/phasicFlow/eventManagement/subscriber.cpp
new file mode 100644
index 00000000..6393e974
--- /dev/null
+++ b/src/phasicFlow/eventManagement/subscriber.cpp
@@ -0,0 +1,187 @@
+/*------------------------------- 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 "subscriber.hpp"
+#include "anyList.hpp"
+#include "observer.hpp"
+#include "message.hpp"
+
+pFlow::subscriber::subscriber(const subscriber & src)
+:
+	subName_(src.subName_)
+{
+}
+
+pFlow::subscriber::subscriber(subscriber && src)
+:
+	observerList_(std::move(src.observerList_)),
+	subName_(std::move(src.subName_))
+{
+	
+	for(size_t i=0; i<observerList_.size(); i++)
+	{
+		for( auto obsvr: observerList_[i] )
+		{
+			if(obsvr) obsvr->changeSubscriber(this);
+		}
+	}
+}
+
+pFlow::subscriber &pFlow::subscriber::operator=(const subscriber & rhs)
+{
+    this->subName_ = rhs.subName_;
+	return *this;
+}
+
+pFlow::subscriber &pFlow::subscriber::operator=(subscriber && rhs)
+{
+    this->subName_ = std::move(rhs.subName_);
+	this->observerList_ = std::move(rhs.observerList_);
+
+	for(size_t i=0; i<observerList_.size(); i++)
+	{
+		for( auto obsvr: observerList_[i] )
+		{
+			if(obsvr) obsvr->changeSubscriber(this);
+		}
+	}
+
+	return *this;
+}	
+
+pFlow::subscriber::~subscriber()
+{
+	for(size_t i=0; i<observerList_.size(); i++)
+	{
+		for( auto obsvr: observerList_[i] )
+		{
+			if(obsvr)
+			{
+				obsvr->invalidateSubscriber();
+			}
+		}
+	}
+}
+
+bool pFlow::subscriber::subscribe
+(
+	message 	msg,
+	observer* 	obsevr
+)const
+{
+	// do not subscribe nullptr 
+	if(!obsevr)return false;
+
+	for(size_t i=0; i<msg.size(); i++)
+	{
+		if(msg.equivalentTo(i))
+		{
+			if(!observerList_[i].search(obsevr))
+			{
+				observerList_[i].push_back(obsevr);
+			}
+		}
+	}
+	return true;
+}
+
+bool pFlow::subscriber::unsubscribe
+(
+	observer* obsrvr
+)const
+{
+	if(obsrvr)
+	{
+		for(size_t i=0; i<observerList_.size(); i++)
+		{
+			if( auto iter = observerList_[i].find(obsrvr); iter!= observerList_[i].end())
+			{
+				(*iter)->invalidateSubscriber();
+				observerList_[i].erase(iter);
+			}
+		}
+	}
+	return true;
+}
+
+bool pFlow::subscriber::notify
+(
+	uint32 iter,
+	real t,
+	real dt,
+	const message msg, 
+	const anyList& varList
+)
+{
+	
+	for(size_t i=0; i<msg.size(); i++)
+	{
+		if(msg.equivalentTo(i))
+		{
+			for( auto obsvr: observerList_[i] )
+			{
+				obsvr->hearChanges
+				(
+					t,
+					dt,
+					iter,
+					message(i),
+					varList
+				);
+			}
+		}
+	}
+
+	return true;
+}
+
+/*bool pFlow::subscriber::notify
+(
+	const eventMessage &msg
+)
+{
+	for ( auto& observer:observerList_ )
+	{
+		if(observer)
+			if( !observer->update(msg) ) return false;
+	}
+
+	return true;
+}
+
+bool pFlow::eventSubscriber::notify
+(
+	const eventMessage& msg,
+	const List<eventObserver*>& exclutionList
+)
+{
+	Set<eventObserver*> sortedExcList(exclutionList.begin(),exclutionList.end());
+
+	for(auto& observer:observerList_)
+	{
+		if( observer && sortedExcList.count(observer) == 0 )
+		{
+			if(!observer->update(msg)) return false;
+		}
+	}
+
+	return true;
+}*/
\ No newline at end of file
diff --git a/src/phasicFlow/eventManagement/subscriber.hpp b/src/phasicFlow/eventManagement/subscriber.hpp
new file mode 100644
index 00000000..6507de01
--- /dev/null
+++ b/src/phasicFlow/eventManagement/subscriber.hpp
@@ -0,0 +1,86 @@
+/*------------------------------- 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 __subscriber_hpp__
+#define __subscriber_hpp__
+
+
+
+#include <array>
+
+#include "List.hpp"
+#include "message.hpp"
+
+namespace pFlow
+{
+
+class observer;
+class anyList;
+
+class subscriber
+{
+private:
+
+	// - list of subsribed objectd that recieve updage messages 
+	mutable std::array<List<observer*>,message::numEvents()> observerList_;
+
+	word subName_;
+
+public:
+
+	subscriber(const word& name)
+	:
+		subName_(name)
+	{}
+
+	/// Copy constructor, only copies the name, not the list 
+	subscriber(const subscriber&);
+
+	/// @brief Move constructor, moves the name and the list,
+	/// also change the subriber of the object in the list 
+	subscriber(subscriber&&);
+
+	/// Copy assignemnt, only assign the name, do not assign the list 
+	subscriber& operator = (const subscriber&);
+
+	/// @brief Move assignment, move assign name and list,
+	/// also change the subcriber of the object in the list 
+	subscriber& operator = (subscriber&&);
+
+	virtual ~subscriber();
+
+	virtual bool subscribe(message msg, observer* obsevr)const;
+
+	virtual bool unsubscribe(observer* obsevr)const;
+
+	bool notify(
+		uint32 iter,
+		real t,
+		real dt,
+		const message msg, 
+		const anyList& varList);
+	
+
+};
+
+} // pFlow
+
+
+
+#endif // __eventSubscriber_hpp__
diff --git a/src/phasicFlow/fileSystem/fileSystem.cpp b/src/phasicFlow/fileSystem/fileSystem.cpp
index 0e82fe80..c1abf154 100644
--- a/src/phasicFlow/fileSystem/fileSystem.cpp
+++ b/src/phasicFlow/fileSystem/fileSystem.cpp
@@ -21,7 +21,7 @@ Licence:
 
 #include "fileSystem.hpp"
 #include "error.hpp"
-#include "iOstream.hpp"
+#include "streams.hpp"
 
 
 bool pFlow::fileSystem::checkFileName(const word& name)
@@ -41,6 +41,17 @@ bool pFlow::fileSystem::checkFileName(const word& name)
 }
 
 
+/// From full path 
+pFlow::fileSystem::fileSystem(const word & wPath)
+:
+	path_(wPath),
+	isDir_(std::filesystem::is_directory(path_))
+{
+	if( !isDir_ && !checkFileName(fileName()))
+	{
+		fatalExit;
+	}
+}
 
 pFlow::fileSystem::fileSystem( const word& dir, const word& file)
 {
@@ -74,10 +85,9 @@ pFlow::fileSystem::fileSystem( const char* dir, const char* file)
 
 pFlow::fileSystem::fileSystem( const pathType& path )
 :
-	path_(path)
-{
-	isDir_ = isDirectory(*this);
-}
+	path_(path),
+	isDir_(std::filesystem::is_directory(path_))
+{}
 
 pFlow::fileSystem pFlow::fileSystem::dirPath() const
 {
@@ -175,9 +185,7 @@ bool pFlow::fileSystem::dirExist
 	
 }
 
-bool pFlow::fileSystem::exist
-(
-)const
+bool pFlow::fileSystem::exist()const
 {
 	try
 	{
@@ -267,7 +275,7 @@ pFlow::fileSystem pFlow::operator /
 	const fileSystem& fs2 
 )
 {
-	fileSystem::pathType cmbPath(fs1.dirPath().path_ / fs2.dirPath().path_);
+	fileSystem::pathType cmbPath(fs1.dirPath().path_ / fs2.path_);
 
 	return fileSystem( cmbPath.c_str() );
 
@@ -284,13 +292,13 @@ pFlow::fileSystem pFlow::operator +
 	return path;
 }
 
-pFlow::iOstream& pFlow::operator << (iOstream& os, fileSystem fs)
+pFlow::iOstream& pFlow::operator << (iOstream& os, const fileSystem& fs)
 {
 	os << fs.path_.c_str();
 	return os;
 }
 
-std::ostream& pFlow::operator << (std::ostream& os, fileSystem fs)
+std::ostream& pFlow::operator << (std::ostream& os, const fileSystem& fs)
 {
 	os << fs.path_.c_str();
 	return os;
@@ -321,7 +329,7 @@ pFlow::fileSystemList pFlow::subDirectories
 		auto dOps = std::filesystem::directory_options::skip_permission_denied;
 		for( auto& subPath: std::filesystem::directory_iterator(path.path(), dOps) )
 		{
-			if(isDirectory( subPath.path() ) )
+			if(isDirectory( fileSystem(subPath.path()) ) )
 			{
 				dirs.emplace_back(subPath.path());
 			}
diff --git a/src/phasicFlow/fileSystem/fileSystem.hpp b/src/phasicFlow/fileSystem/fileSystem.hpp
index 655bc0e8..9eb70122 100644
--- a/src/phasicFlow/fileSystem/fileSystem.hpp
+++ b/src/phasicFlow/fileSystem/fileSystem.hpp
@@ -29,21 +29,20 @@ Licence:
 namespace pFlow
 {
 
-
+// - Forward 
 class iOstream;
-class ostream;
 class fileSystem;
 
 iOstream& operator <<
 (
 	iOstream& os,
-	fileSystem fs
+	const fileSystem& fs
 );
 
 std::ostream& operator <<
 (
 	std::ostream& os,
-	fileSystem fs
+	const fileSystem& fs
 );
 
 
@@ -59,29 +58,40 @@ fileSystem operator +
 	const word fName
 );
 
-// a class to manage file/directory names 
+/**
+ * Manages file pathes, manupulate and combines them. 
+ * 
+ */
 class fileSystem
 {
+public:
+	
+	using 	pathType = std::filesystem::path;
+
 protected:
 	
-	std::filesystem::path path_;
-	bool isDir_;
-
-
-	// protected static variables
-	inline static word notPermittedCharsFile = word(" ") + word("\t\n\0;:?*/<>\"?\'");
+	/// File path 
+	pathType 	path_;
 	
-	// protected methods 
+	/// Is this a directory path?
+	bool 		isDir_;
 
+
+	/// Not premitted chars in file name 	
+	inline static word notPermittedCharsFile = word(" ") + word("&\t\n;:?*/<>\"?\'");
+	
+	/// Is name is valid for a file? 
 	bool static validFileName(const word& name)
 	{
-		return name.find_first_of(notPermittedCharsFile);
+		return name.find_first_of(notPermittedCharsFile)==word::npos;
 	}
 
+	/// Is a valid file name?
 	bool static checkFileName(const word& name);
 
 public:
 
+	/// return current working directory 
 	inline static fileSystem CWD() 
 	{
 		return fileSystem(std::filesystem::current_path().c_str());
@@ -89,92 +99,108 @@ public:
 	
 public:
 
+	//// - Constructors 
 
-	typedef std::filesystem::path 	pathType;
+		/// Default
+		fileSystem():
+			path_(),
+			isDir_(true)
+		{}
 
+		/// From full path 
+		explicit
+		fileSystem(const word & wPath);
 
-	fileSystem():
-		path_(),
-		isDir_(true)
-	{}
-	// Constructors
-	fileSystem( const word& dir, const word& file = "");
-	fileSystem( const char* dir, const char* file = "");
-	fileSystem( const pathType& path );
+		/// From dir and file name 
+		fileSystem( const word& dir, const word& file);
+		
+		/// From dir and file name 
+		fileSystem( const char* dir, const char* file="");
 
-	fileSystem(const fileSystem&) = default;
+		/// Copy
+		explicit
+		fileSystem( const pathType& path );
+
+		/// Copy 
+		fileSystem(const fileSystem&) = default;
+		
+		/// Move 
+		fileSystem(fileSystem&&) = default;
+
+		/// Copy assignment 
+		fileSystem& operator = (const fileSystem&) = default;
+
+		/// Move assignment 
+		fileSystem& operator = (fileSystem&&) = default;
+
+		/// Destructor 
+		~fileSystem() = default;
 	
-	fileSystem(fileSystem&&) = default;
+	//// - Methods
+		
+		/// Is directory?
+		bool isDir() const
+		{
+			return isDir_;
+		}
+		
+		/// Const access to path
+		const pathType& path()const
+		{
+			return path_;
+		}
 
-	fileSystem& operator = (const fileSystem&) = default;
+		/// Path in word type 
+		word wordPath()const
+		{
+			return word(path_.c_str());
+		}
 
-	fileSystem& operator = (fileSystem&&) = default;
+		/// Dir part of the path 
+		fileSystem dirPath() const;
 
-	~fileSystem() = default;
+		/// File name part of the path (if any)
+		word fileName() const;
+
+		/// Absolute path of this
+		fileSystem absolute()const;
+
+
+		/// Canonical path of this (it should exist)
+		fileSystem canonical()const;
+
+		/// Only operate on dir path
+		/// Check if the dir path exists
+		bool dirExist()const;	
+
+		/// Check if the path exists
+		bool exist()const;
+
+		/// Operate on dir path only
+		/// Create dir based on the path and returns the canonical path
+		fileSystem createDirs()const;
+
+
+		/// If this is dir path, add the filename to dir path
+		/// if it is file path, replace the file name 
+		void operator += (const word& fileName);
+
+		/// It operates on dir path only
+		/// Add the dir path of fs to this 
+		void operator /=(const fileSystem& fs );
+
+		/// Create a dir path from dir path of fs1 and fas2 in the 
+		/// form of fs1/fs2 
+		friend fileSystem operator /(const fileSystem& fs1, const fileSystem& fs2 );
+
+
+		/// Return the dir path of this
+		fileSystem operator()(bool retDir = true) const;
 	
-	// Methods
-	bool isDir() const
-	{
-		return isDir_;
-	}
-	
-	const pathType& path()const
-	{
-		return path_;
-	}
+	//// - IO
+	friend iOstream& operator << (iOstream& os, const fileSystem& fs);
 
-	word wordPath()const
-	{
-		return word(path_.c_str());
-	}
-
-	// dir path of this
-	fileSystem dirPath() const;
-
-	// file name of this (if any)
-	word fileName() const;
-
-	// absolute path of this
-	fileSystem absolute()const;
-
-
-	//fileSystem relative()const;
-
-	// canonical path of this (it should exist)
-	fileSystem canonical()const;
-
-	// only operate on dir path
-	// check if the dir path exists
-	bool dirExist()const;	
-
-	// check if the path exists
-	bool exist()const;
-
-	// operate on dir path only
-	// create dir based on the path and returns the canonical path
-	fileSystem createDirs()const;
-
-
-	// if this is dir path, add the filename to dir path
-	// if it is file path, replace the file name 
-	void operator += (const word& fileName);
-
-	// it operates on dir path only
-	// it adds the dir path of fs to this 
-	void operator /=(const fileSystem& fs );
-
-	// Create a dir path from dir path of fs1 and fas2 in the 
-	// form of fs1/fs2 
-	friend fileSystem operator /(const fileSystem& fs1, const fileSystem& fs2 );
-
-
-	// return the dir path of this
-	fileSystem operator()(bool retDir = true) const;
-	
-
-	friend iOstream& operator << (iOstream& os, fileSystem fs);
-
-	friend std::ostream& operator << (std::ostream& os, fileSystem fs);
+	friend std::ostream& operator << (std::ostream& os, const fileSystem& fs);
 	
 };
 
@@ -182,18 +208,22 @@ public:
 using fileSystemList = List<fileSystem>;
 
 
-
+/// Free function to reture current working directory 
 inline fileSystem CWD()
 {
 	return fileSystem::CWD();
 }
 
+/// Free function to check if the path is dir path
 bool isDirectory(const fileSystem& path);
 
+/// free function to check if the path is regular file 
 bool isRegularFile(const fileSystem& path);
 
+/// A list of sub-directories that exist in path. 
 fileSystemList subDirectories(const fileSystem& path);
 
+/// A list of file paths that exist in the path.
 fileSystemList containingFiles(const fileSystem& path);
 
 } // pFlow
diff --git a/src/phasicFlow/globals/error.cpp b/src/phasicFlow/globals/error.cpp
index 0f9cde3d..1f4bd234 100644
--- a/src/phasicFlow/globals/error.cpp
+++ b/src/phasicFlow/globals/error.cpp
@@ -21,19 +21,26 @@ Licence:
 #include <iostream>
 #include <stdlib.h>
 
+
+#include <Kokkos_Core.hpp>
+
 #include "error.hpp"
+#include "processors.hpp"
 #include "streams.hpp"
 
 
-static pFlow::Ostream& errorStream   = pFlow::errReport;
+
+//static pFlow::Ostream& errorStream   = pFlow::errReport;
+
+static pFlow::Ostream& errorStream   = pFlow::pOutput;
 
 
 pFlow::iOstream& fatalErrorMessage(const char* fileName, int linNumber )
 {	
 	
 	errorStream<<"\n>>> Fatal error in phasicFlow\n" <<
-				 "Error occured in source file "<< redText(fileName) <<
-				 " at line "<<redText(linNumber)<<'\n';
+				 "Error occured in source file "<< Red_Text(fileName) <<
+				 " at line "<<Red_Text(linNumber)<<'\n';
 	return errorStream;
 
 }
@@ -42,9 +49,9 @@ pFlow::iOstream& fatalErrorInMessage(const char* fnName, const char* fileName, i
 {	
 
 	errorStream<<"\n>>> Fatal error in phasicFlow\n" <<
-	 			 " Error is issued in function " << redText(fnName)<<
-	 			 ", located in file "<< redText(fileName) <<
-	             " at line "<< redText(linNumber) << '\n';
+	 			 " Error is issued in function " << Red_Text(fnName)<<
+	 			 ", located in file "<< Red_Text(fileName) <<
+	             " at line "<< Red_Text(linNumber) << '\n';
 	return errorStream;
 }
 
@@ -52,9 +59,9 @@ pFlow::iOstream& notImplementedErrorMessage(const char*fnName, const char* fileN
 {
 
 	errorStream<<"\n>>> Fatal error in phasicFlow\n";
-	errorStream<<" Function "<< redText(fnName) << " has not implmented yet!\n" <<
-				 " Function definition is in source file "<< redText(fileName) << 
-	             " at line "<< redText(lineNumber) <<'\n';
+	errorStream<<" Function "<< Red_Text(fnName) << " has not been implemented yet!\n" <<
+				 " File "<< Yellow_Text(fileName) << 
+	             " at line "<< Yellow_Text(lineNumber) <<'\n';
 	return errorStream;
 }
 
@@ -63,10 +70,10 @@ pFlow::iOstream& ioErrorMessage(const char* fileName, int fileLineNumber, const
 {
 	
 	errorStream<<"\n>>> Fatal IO file error\n"<<
-				 " IO error at number "<<redText(fileLineNumber)<<
-				 " of file " << redText(fileName)<<'\n';
-	errorStream<<" IO operation is peformed from function "<<redText(fnName) <<
-	             " in file "<< redText(fName)<< " at line "<< redText(lNumber) <<'\n';
+				 " IO error at number "<<Red_Text(fileLineNumber)<<
+				 " of file " << Red_Text(fileName)<<'\n';
+	errorStream<<" IO operation is peformed from function "<<Red_Text(fnName) <<
+	             " in file "<< Red_Text(fName)<< " at line "<< Red_Text(lNumber) <<'\n';
 	return errorStream;
 }
 
@@ -80,17 +87,24 @@ pFlow::iOstream& warningMessage(const char* fnName, const char* fileName, int li
 {
 	
 	errorStream<<"\n>>> Warning in phasicFlow\n"<<
-				 " Warning is issued in function " << yellowText(fnName)<<
-	             " in source file "<< yellowText(fileName) <<
-	             " at line "<< yellowText(linNumber) <<'\n';
+				 " Warning is issued in function " << Yellow_Text(fnName)<<
+	             " in source file "<< Yellow_Text(fileName) <<
+	             " at line "<< Yellow_Text(linNumber) <<'\n';
 	return errorStream;
 }
 
-pFlow::iOstream& reportAndExit()
+pFlow::iOstream& reportAndExit(int errorCode)
 {
 	errorStream<<"\n>>> phasicFlow is exiting . . ." << pFlow::endl;
-	exit(EXIT_FAILURE);
+	fatalExitPhasicFlow(errorCode);
 	return errorStream;
 }
 
+int fatalExitPhasicFlow(int errorCode)
+{
+	// Kokkos should be finalized first
+	Kokkos::finalize();
 
+	pFlow::processors::abort(errorCode);
+	return errorCode;
+}
diff --git a/src/phasicFlow/globals/error.hpp b/src/phasicFlow/globals/error.hpp
index 52f56157..540e7719 100644
--- a/src/phasicFlow/globals/error.hpp
+++ b/src/phasicFlow/globals/error.hpp
@@ -18,7 +18,6 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
 #ifndef __error_hpp__
 #define __error_hpp__
 
@@ -26,36 +25,17 @@ Licence:
 #include "builtinTypes.hpp"
 
 
+//- Forward decleartions 
 namespace pFlow
 {
 	class iOstream;	
 }
 
 
-// reports a fatal error and exit the applicaiton 
-#define fatalError \
-	fatalErrorMessage(__FILE__, __LINE__)
+//- Decleartions 
 
-#define fatalErrorIn( functionName ) \
-	fatalErrorInMessage((functionName), __FILE__, __LINE__ )
-
-#define fatalErrorInFunction fatalErrorIn(FUNCTION_NAME)
-
-#define Not_Implemented(functionName) \
-    notImplementedErrorMessage ((functionName), __FILE__, __LINE__ )
-        
-#define notImplementedFunction Not_Implemented(FUNCTION_NAME);
-
-#define ioErrorInFile( fileName, lineNumber) \
-	ioErrorMessage( fileName, lineNumber, FUNCTION_NAME, __FILE__, __LINE__ )
-
-#define warningIn( functionName ) \
-	warningMessage((functionName), __FILE__, __LINE__ )
-
-#define warningInFunction warningIn(FUNCTION_NAME)
-
-#define fatalExit \
-	reportAndExit()
+/// Take actions to fatal exit phasicFlow
+int fatalExitPhasicFlow(int errorCode = EXIT_FAILURE);
 
 pFlow::iOstream& fatalErrorMessage(const char* fileName, int linNumber );
 pFlow::iOstream& fatalErrorInMessage(const char* fnName, const char* fileName, int linNumber );
@@ -63,6 +43,40 @@ pFlow::iOstream& notImplementedErrorMessage(const char*fnName, const char* fileN
 pFlow::iOstream& ioErrorMessage(const pFlow::word& fileName, int fileLineNumber, const char* fnName, const char* fName, int lNumber);
 pFlow::iOstream& ioErrorMessage(const char* fileName, int fileLineNumber, const char* fnName, const char* fName, int lNumber);
 pFlow::iOstream& warningMessage(const char* fnName, const char* fileName, int linNumber );
-pFlow::iOstream& reportAndExit();
+pFlow::iOstream& reportAndExit(int errorCode = EXIT_FAILURE);
+
+
+/// Report a fatal error and exit the applicaiton 
+#define fatalError \
+	fatalErrorMessage(__FILE__, __LINE__)
+
+/// Report a fatal error and supplied function name and exit the application 
+#define fatalErrorIn( functionName ) \
+	fatalErrorInMessage((functionName), __FILE__, __LINE__ )
+
+/// Report a fatal error and function name and exit the application 
+#define fatalErrorInFunction fatalErrorIn(FUNCTION_NAME)
+
+/// Report that a function is yet not implemented with supplied function name. 
+#define Not_Implemented(functionName) \
+    notImplementedErrorMessage ((functionName), __FILE__, __LINE__ )
+
+/// Report that a function is yet not implemented. 
+#define notImplementedFunction Not_Implemented(FUNCTION_NAME)
+
+/// Report an error in file operation with supplied fileName and lineNumber. 
+#define ioErrorInFile( fileName, lineNumber) \
+	ioErrorMessage( fileName, lineNumber, FUNCTION_NAME, __FILE__, __LINE__ )
+
+/// Report a warning with supplied function name
+#define warningIn( functionName ) \
+	warningMessage((functionName), __FILE__, __LINE__ )
+
+/// Report a warning
+#define warningInFunction warningIn(FUNCTION_NAME)
+
+/// Fatal exit 
+#define fatalExit \
+	reportAndExit()
 
 #endif
diff --git a/src/phasicFlow/globals/globalSettings.hpp b/src/phasicFlow/globals/globalSettings.hpp
index 64a17455..cb9e19ea 100755
--- a/src/phasicFlow/globals/globalSettings.hpp
+++ b/src/phasicFlow/globals/globalSettings.hpp
@@ -25,10 +25,7 @@ Licence:
 
 namespace pFlow
 {
-
-const inline double vectorGrowthFactor__ = 1.1;
-
-
+const inline double vectorGrowthFactor__ = 1.2;
 }
 
 
diff --git a/src/phasicFlow/globals/pFlowMacros.hpp b/src/phasicFlow/globals/pFlowMacros.hpp
index fd3a5bf6..544fc150 100755
--- a/src/phasicFlow/globals/pFlowMacros.hpp
+++ b/src/phasicFlow/globals/pFlowMacros.hpp
@@ -70,7 +70,7 @@ Licence:
 
 #define ForAll(i, container) for(auto i=0; i < container.size(); ++i)
 
-#ifdef USE_STD_PARALLEL_ALG
+#ifdef pFlow_STD_Parallel_Alg
 static inline const bool useStdParallel__ = true;
 #else
 static inline const bool useStdParallel__ = false;
diff --git a/src/phasicFlow/globals/vocabs.hpp b/src/phasicFlow/globals/vocabs.hpp
index 8ac68538..f1ffede1 100755
--- a/src/phasicFlow/globals/vocabs.hpp
+++ b/src/phasicFlow/globals/vocabs.hpp
@@ -37,8 +37,9 @@ const inline char* integrationFolder__  	= "integration";
 
 // file names
 const inline char* settingsFile__			= "settingsDict";
+const inline char* domainFile__     		= "domainDict";
 const inline char* insertionFile__ 			= "particleInsertion";
-const inline char* sphereShapeFile__  		= "sphereShape";
+const inline char* shapeFile__          	= "shapes";
 const inline char* pointStructureFile__ 	= "pStructure";
 const inline char* triSurfaceFile__ 		= "triSurface";
 const inline char* createParticles__		= "createParticles";
diff --git a/src/phasicFlow/processors/localProcessors.cpp b/src/phasicFlow/processors/localProcessors.cpp
new file mode 100644
index 00000000..0dc7e658
--- /dev/null
+++ b/src/phasicFlow/processors/localProcessors.cpp
@@ -0,0 +1,117 @@
+#include "localProcessors.hpp"
+
+pFlow::localProcessors::localProcessors(const word &name)
+:
+    processors(),
+    localSize_(processors::globalSize()),
+    localRank_(processors::globalRank()),
+    name_(name)
+{
+#ifdef pFlow_Build_MPI
+    parrentCommunicator_ = pFlow::MPI::CommWorld;
+    localCommunicator_ = pFlow::MPI::CommWorld;
+#endif
+
+}
+
+pFlow::localProcessors::localProcessors
+(
+    const word &name, 
+    const std::vector<int> &ranks
+)
+:
+    processors(),
+    name_(name)
+{
+#ifdef pFlow_Build_MPI
+    parrentCommunicator_ = pFlow::MPI::CommWorld;
+    
+    if(ranks.size()> this->globalSize() )
+    {
+        fatalErrorInFunction<<
+        "the size of ranks is larger than parrent communicator size "<<endl;
+        fatalExit;
+    }
+
+    pFlow::MPI::Group globalGroup;
+    MPI_Comm_group(parrentCommunicator_, &globalGroup);
+
+    pFlow::MPI::Group localGroup;
+    MPI_Group_incl(globalGroup, ranks.size(), ranks.data(), &localGroup);
+ 
+    // Create the new communicator from that group of processes.
+    
+    CheckMPI( MPI_Comm_create(parrentCommunicator_, localGroup, &localCommunicator_), true);
+    
+    isPartOfLocal_ = localCommunicator_ != MPI::CommNull;
+    
+    if(isPartOfLocal_)
+    {
+        MPI_Comm_set_name(localCommunicator_, name.c_str());
+
+        MPI_Comm_size(localCommunicator_, &localSize_);
+        MPI_Comm_rank(localCommunicator_, &localRank_);
+    }
+
+#else
+
+    if(ranks.size()> 1 )
+    {
+        fatalErrorInFunction<< 
+        "rank size for processors should not be greater than 1.";
+        fatalExit;
+    }
+    localSize_ = processors::globalSize();
+    localRank_ = processors::globalRank();
+
+#endif
+}
+
+#ifdef pFlow_Build_MPI
+
+pFlow::localProcessors::localProcessors
+(
+    pFlow::MPI::Comm parrentComm, 
+    const word &name, 
+    const std::vector<int> &ranks
+)
+:
+    processors(),
+    name_(name)
+{
+    parrentCommunicator_ = parrentComm;
+    
+    int parSize;
+
+    MPI_Comm_size(parrentCommunicator_, &parSize);
+
+    if(ranks.size()> parSize )
+    {
+        fatalErrorInFunction<<
+        "the size of ranks is larger than parrent communicator size "<<endl;
+        fatalExit;
+    }
+
+    pFlow::MPI::Group parGroup;
+    MPI_Comm_group(parrentCommunicator_, &parGroup);
+
+    pFlow::MPI::Group localGroup;
+    MPI_Group_incl(parGroup, ranks.size(), ranks.data(), &localGroup);
+ 
+    // Create the new communicator from that group of processes.
+    
+    CheckMPI( MPI_Comm_create(parrentCommunicator_, localGroup, &localCommunicator_), true);
+    
+    isPartOfLocal_ = localCommunicator_ != MPI::CommNull;
+    
+    if(isPartOfLocal_)
+    {
+        MPI_Comm_set_name(localCommunicator_, name.c_str());
+
+        MPI_Comm_size(localCommunicator_, &localSize_);
+        MPI_Comm_rank(localCommunicator_, &localRank_);
+    }
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/processors/localProcessors.hpp b/src/phasicFlow/processors/localProcessors.hpp
new file mode 100644
index 00000000..41e07f9e
--- /dev/null
+++ b/src/phasicFlow/processors/localProcessors.hpp
@@ -0,0 +1,152 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+#ifndef __pFlowProcessors_hpp__
+#define __pFlowProcessors_hpp__
+
+
+#include "processors.hpp"
+#include "types.hpp"
+
+#ifdef pFlow_Build_MPI
+    #include "mpiTypes.hpp"
+#endif
+
+
+namespace pFlow
+{
+
+class localProcessors
+:
+    public processors
+{
+private:
+
+#ifdef pFlow_Build_MPI
+    pFlow::MPI::Comm    parrentCommunicator_;
+
+    pFlow::MPI::Comm    localCommunicator_;
+#endif
+
+    int localSize_ = 1 ;
+
+    int localRank_ = 0;
+
+    bool isPartOfLocal_ = true;
+
+    word name_;
+
+public:
+
+        /// @brief Construct a local processor communication similar 
+        /// to global with specified name
+        /// @param name a given name to the local communicator 
+        localProcessors(const word& name);
+
+        
+        /// @brief Construct a local processor communication from global
+        /// communicator using a name and ranks 
+        /// @param name a given name to the local communicator 
+        /// @param ranks ranks to be included in the new communicator 
+        localProcessors(
+            const word& name, 
+            const std::vector<int>& ranks);
+
+    #ifdef pFlow_Build_MPI
+        localProcessors(
+            pFlow::MPI::Comm parrentComm, 
+            const word& name, 
+            const std::vector<int>& ranks);
+    #endif
+
+    // - Access 
+
+        /// @brief return name of the local communicator 
+        inline 
+        const auto& name()const
+        {
+            return name_;
+        }
+
+        inline
+        auto localRank()const
+        {
+            return localRank_;
+        }
+
+        inline 
+        auto localSize()const
+        {
+            return localSize_;
+        }
+
+    // - Methods 
+
+        inline
+        bool localMaster()const
+        {
+            return localRank_ == localMasterNo();
+        }
+
+        inline 
+        int localMasterNo()const
+        {
+            return 0;
+        }
+
+        inline 
+        bool localParallel()const
+        {
+            return localSize_>1;
+        }
+
+        inline
+        const char* localRunTypeName()
+        {
+            if(localParallel())
+                return "MPI";
+            else
+                return "regular";
+        }
+
+        inline
+        bool isThisActive()const
+        {
+            return isPartOfLocal_;
+        }
+
+    #ifdef pFlow_Build_MPI
+        inline 
+        auto parrentCommunicator()const
+        {
+            return parrentCommunicator_;
+        }
+
+        inline 
+        auto localCommunicator()const
+        {
+            return localCommunicator_;
+        }
+    #endif
+
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/processors/pFlowProcessors.cpp b/src/phasicFlow/processors/pFlowProcessors.cpp
new file mode 100644
index 00000000..73201b50
--- /dev/null
+++ b/src/phasicFlow/processors/pFlowProcessors.cpp
@@ -0,0 +1,18 @@
+#include "pFlowProcessors.hpp"
+
+static pFlow::localProcessors pFlowProcessors__{"pFlowProcessors"};
+
+pFlow::localProcessors& pFlow::pFlowProcessors()
+{
+    return pFlowProcessors__;
+}
+
+void pFlow::initialize_pFlowProcessors()
+{
+    pFlowProcessors__ = localProcessors("pFlowProcessors");
+}
+
+void pFlow::initialize_pFlowProcessors(const std::vector<int>& ranks)
+{
+    pFlowProcessors__ = localProcessors("pFlowProcessors", ranks);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/processors/pFlowProcessors.hpp b/src/phasicFlow/processors/pFlowProcessors.hpp
new file mode 100644
index 00000000..12ae1942
--- /dev/null
+++ b/src/phasicFlow/processors/pFlowProcessors.hpp
@@ -0,0 +1,14 @@
+
+#include "localProcessors.hpp"
+
+
+namespace pFlow
+{
+
+localProcessors& pFlowProcessors();
+
+void initialize_pFlowProcessors();
+
+void initialize_pFlowProcessors(const std::vector<int>& ranks);
+
+}
\ No newline at end of file
diff --git a/src/phasicFlow/processors/processors.cpp b/src/phasicFlow/processors/processors.cpp
new file mode 100644
index 00000000..67f71bb2
--- /dev/null
+++ b/src/phasicFlow/processors/processors.cpp
@@ -0,0 +1,183 @@
+/*------------------------------- 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 "phasicFlowConfig.H"
+
+#ifdef pFlow_Build_MPI
+	#include "mpiCommunication.hpp"
+#endif
+
+// from PhasicFlow
+#include "error.hpp"
+#include "processors.hpp"
+#include "streams.hpp"
+
+static int numVarsInitialized__ = 0;
+
+#ifdef pFlow_Build_MPI
+
+    pFlow::MPI::DataType pFlow::MPI::realx3Type__;
+    pFlow::MPI::DataType pFlow::MPI::realx4Type__;
+    pFlow::MPI::DataType pFlow::MPI::int32x3Type__;
+    
+#endif
+
+void pFlow::processors::initProcessors(int argc, char *argv[])
+{
+
+#ifdef pFlow_Build_MPI
+	if(!processors::isInitialized())
+	{
+		CheckMPI(MPI_Init(&argc, &argv), true);
+		initProcessorsCelled_ = true;
+
+        argc_ = argc;
+        argv_ = argv;
+
+		MPI_Comm_rank(MPI_COMM_WORLD, &processors::globalRank_);
+        MPI_Comm_size(MPI_COMM_WORLD, &processors::globalSize_);
+        
+		
+		if(processors::globalParallel())
+		{
+			pFlow::pOutput.activatePrefix();
+			pFlow::pOutput.setPrefixNum(processors::globalRank_);	
+		}
+		
+		pFlow::mOutput.setMasterSlave(processors::globalMaster());
+		pFlow::errReport.setMasterSlave(processors::globalMaster());
+
+        MPI_Type_contiguous(3, pFlow::MPI::Type<real>(), &pFlow::MPI::realx3Type__);
+		MPI_Type_commit(&pFlow::MPI::realx3Type__);
+
+        MPI_Type_contiguous(4, pFlow::MPI::Type<real>(), &pFlow::MPI::realx4Type__);
+		MPI_Type_commit(&pFlow::MPI::realx3Type__);
+
+		MPI_Type_contiguous(3, pFlow::MPI::Type<int32>(), &pFlow::MPI::int32x3Type__);
+		MPI_Type_commit(&pFlow::MPI::int32x3Type__);
+
+	}
+#else
+
+#endif
+
+}
+
+void pFlow::processors::finalizeProcessors()
+{
+
+#ifdef pFlow_Build_MPI
+	if(initProcessorsCelled_ && !isFinalized())
+	{
+        MPI::TypeFree(&pFlow::MPI::realx3Type__);
+        MPI::TypeFree(&pFlow::MPI::realx4Type__);
+		MPI::TypeFree(&pFlow::MPI::int32x3Type__);
+		CheckMPI(MPI_Finalize(), true);
+	}
+#else
+
+#endif
+}
+
+pFlow::processors::processors()
+{
+
+#ifdef pFlow_Build_MPI	
+	if(globalParallel() && !isInitialized())
+	{
+		fatalErrorInFunction<<
+		"MPI communication is not initialized yet!"<<endl;
+		processors::abort(MPI_ERR_OP);
+	}
+#endif
+	
+}
+
+pFlow::processors::~processors()
+{}
+
+
+bool pFlow::processors::isInitialized()
+{
+	
+#ifdef pFlow_Build_MPI
+	int res;
+	MPI_Initialized(&res);
+	return res;
+#endif
+	return false;
+
+}
+
+bool pFlow::processors::isFinalized()
+{
+
+#ifdef pFlow_Build_MPI
+	int res;
+	MPI_Finalized(&res);
+	return res;
+#endif
+	return false;
+
+}
+
+void pFlow::processors::abort(int error)
+{
+
+#ifdef pFlow_Build_MPI
+	int flag=0;
+	MPI_Initialized(&flag);
+	if(flag == 1)
+	{
+		MPI_Abort(MPI_COMM_WORLD, error);
+		MPI_Finalize();
+  }
+    exit(error);
+#else
+    exit(error);
+#endif
+
+}
+
+bool pFlow::checkMPI(const char* funcName, int error, bool forceAbort, const char* fileName, int lineNumebr)
+{
+
+#ifdef pFlow_Build_MPI
+	
+	if(error == MPI_SUCCESS) return true;
+	fatalErrorInMessage(funcName, fileName, lineNumebr);
+	
+	if(!forceAbort) return false;
+	reportAndExit(error);
+	
+	return false;
+
+#else
+
+	return true;
+
+#endif
+}
+
+
+
+
+
+
diff --git a/src/phasicFlow/processors/processors.hpp b/src/phasicFlow/processors/processors.hpp
new file mode 100644
index 00000000..60ae64a8
--- /dev/null
+++ b/src/phasicFlow/processors/processors.hpp
@@ -0,0 +1,173 @@
+/*------------------------------- 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 __processors_H__
+#define __processors_H__ 
+
+
+
+namespace pFlow
+{
+	// - Forward
+	bool checkMPI
+	(
+		const char* funcName,
+		int 				error, 
+		bool 				forceAbort, 
+		const char* fileName, 
+		int 				lineNumebr
+	);
+}
+
+// - Macro for automating line and file logs
+#define CheckMPI(caller, fAbort)\
+   pFlow::checkMPI(#caller, (caller), fAbort, __FILE__, __LINE__);
+
+
+namespace pFlow
+{
+
+/**
+ * This class holds the information about the global execution 
+ * world and number of processors in communication.
+ * 
+ */
+class processors
+{
+private:
+
+	/// Is the static member initProcessors is called
+	static inline 
+	bool initProcessorsCelled_ = false;
+
+	/// Global rank of the current processor
+	static inline
+	int globalRank_ = 0;
+
+	/// The global size of all processors 
+	static inline
+	int globalSize_ = 1;
+
+    static inline
+    int argc_ = 0;
+
+    static inline 
+    char** argv_ = nullptr;
+
+public:
+
+	/// Initialize MPI processors
+	static 
+	void initProcessors(int argc, char *argv[]);
+
+	/// Finalize MPI processors 
+	static
+	void finalizeProcessors();
+
+	/// Constructor 
+	processors();
+	
+	/// Destructor 
+	~processors();
+	
+	/// Master processors number (globaly in MPI).
+	static inline
+	int globalMasterNo()
+	{
+		return 0;
+	}
+
+	/// Is this a parallel MPI run.
+	static inline
+	bool globalParallel()
+	{
+		return processors::globalSize()>1;
+	}
+	
+	static inline
+	const char* globalRunTypeName()
+	{
+		if(globalParallel())
+		{
+			return "MPI";
+		}
+		else
+		{
+			return "regular";
+		}
+	}
+	/// Is MPI initialized?
+	static
+	bool isInitialized();
+	
+	/// Is MPI finalized?
+	static
+	bool isFinalized();
+	
+	/// Is this processor the master processor?
+	static inline
+	bool globalMaster()
+	{
+		return processors::globalRank() == processors::globalMasterNo();
+	}
+	
+	/// Global size of processors
+	static inline
+	int globalSize()
+	{
+		return globalSize_;
+	}
+	
+	/// Rank of the processor in the global MPI
+	static inline
+	int globalRank()
+	{
+		return globalRank_;
+	}
+
+    static inline
+    int argc()
+    {
+        return argc_;
+    }
+
+    static inline 
+    char** argv()
+    {
+        return argv_;
+    }
+
+	/// Abort MPI run or regular run
+	static
+	void abort(int error);
+
+/*#ifdef pFlow_Build_MPI
+    static inline 
+    auto worldCommunicator()
+    {
+      return pFlow::MPI::CommWorld;  
+    }
+#endif*/
+
+}; //processors
+
+
+} // pFlow
+
+#endif //__processors_H__
\ No newline at end of file
diff --git a/src/phasicFlow/random/randomInt32/uniformRandomInt32.hpp b/src/phasicFlow/random/randomInt32/uniformRandomUint32.hpp
similarity index 77%
rename from src/phasicFlow/random/randomInt32/uniformRandomInt32.hpp
rename to src/phasicFlow/random/randomInt32/uniformRandomUint32.hpp
index 86408dcf..86564d93 100644
--- a/src/phasicFlow/random/randomInt32/uniformRandomInt32.hpp
+++ b/src/phasicFlow/random/randomInt32/uniformRandomUint32.hpp
@@ -18,8 +18,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __uniformRandomInt32_hpp__
-#define __uniformRandomInt32_hpp__
+#ifndef __uniformRandomUint32_hpp__
+#define __uniformRandomUint32_hpp__
 
 #include <random>
 
@@ -29,35 +29,35 @@ Licence:
 namespace pFlow
 {
 
-class uniformRandomInt32
+class uniformRandomUint32
 {
 protected:
 
  	std::mt19937_64 engineGen_;
 
- 	std::uniform_int_distribution<int32> distrbution_;
+ 	std::uniform_int_distribution<uint32> distrbution_;
 
 public:
 
 	// type info
 	TypeInfoNV("uniform");
 
-	explicit uniformRandomInt32(int32 min, int32 max)
+	explicit uniformRandomUint32(uint32 min, uint32 max)
 	:
 		engineGen_(std::random_device()()),
 		distrbution_(min, max)
 	{}
 
-	~uniformRandomInt32()= default;
+	~uniformRandomUint32()= default;
 
-	inline real  randomNumber() 
+	inline uint32  randomNumber() 
 	{
 		return  distrbution_(engineGen_);
 	}
 	
-	inline int32x3 randomNumber3()
+	inline triple<uint32> randomNumber3()
 	{
-		return int32x3
+		return triple<uint32>
 		(
 			randomNumber(),
 			randomNumber(),
@@ -65,9 +65,9 @@ public:
 		);
 	}	
 
-	inline realx3 operator()()
+	inline triple<uint32> operator()()
 	{
-		return randomNumber();
+		return randomNumber3();
 	}
 
 	
diff --git a/src/phasicFlow/ranges/intervalRange.hpp b/src/phasicFlow/ranges/intervalRange.hpp
index ca40826f..0108713d 100644
--- a/src/phasicFlow/ranges/intervalRange.hpp
+++ b/src/phasicFlow/ranges/intervalRange.hpp
@@ -43,7 +43,7 @@ protected:
 	static inline const T minVal = largestNegative<T>();
 public:
 
-	TypeInfoTemplateNV("intervalRange",T);
+	TypeInfoTemplateNV11("intervalRange",T);
 
 	intervalRange(T begin, T end)
 	:
diff --git a/src/phasicFlow/ranges/stridedRange.hpp b/src/phasicFlow/ranges/stridedRange.hpp
index 5ecf7367..02df31d2 100644
--- a/src/phasicFlow/ranges/stridedRange.hpp
+++ b/src/phasicFlow/ranges/stridedRange.hpp
@@ -25,6 +25,7 @@ Licence:
 #include "typeInfo.hpp"
 #include "dictionary.hpp"
 
+#include "streams.hpp"
 
 namespace pFlow
 {
@@ -35,18 +36,20 @@ stridedRange
 {
 protected:
 
-	T 		begin_;
+	T 		begin_ = 0;
 
-	T 		end_;
+	T 		end_ = 1;
 
-	T 		stride_;
+	T 		stride_ = 1;
 
 	static inline const T maxVal = largestPositive<T>();
 	static inline const T minVal = largestNegative<T>();
 
 public:
 
-	TypeInfoTemplateNV("stridedRange",T);
+	TypeInfoTemplateNV11("stridedRange",T);
+
+	stridedRange()=default;
 
 	stridedRange(T begin, T end, T stride)
 	:
@@ -76,9 +79,9 @@ public:
 
 	stridedRange(const dictionary& dict)
 	:
-		begin_(dict.getVal<label>("begin")),
-		end_(dict.getVal<label>("end")),
-		stride_(dict.getVal<label>("stride"))
+		begin_(dict.getVal<T>("begin")),
+		end_(dict.getVal<T>("end")),
+		stride_(dict.getVal<T>("stride"))
 	{}
 		
 	inline 
@@ -96,12 +99,21 @@ public:
 	{
 		return stride_;
 	}
+	
+	inline
+	bool isInRange(T val)const
+	{
+		return val>= begin_ && val<= end_;
+	}
+
 	inline
 	bool isMember(T val, T epsilon = 0)const
 	{
+		
+		if(!isInRange(val)) return false;
+		if(T dist = val-begin_; abs(dist%stride_)<= epsilon) return true;
 		if(equal(val,begin_))return true;
 		if(equal(val,end_))return true;
-		if(abs(mod(val-begin_,stride_))<= epsilon) return true;
 		return false;
 	}
 
@@ -137,6 +149,22 @@ public:
 	}
 };
 
+template<>
+inline
+bool stridedRange<real>::isMember(real val, real epsilon)const
+	{
+
+	if(!isInRange(val)) return false;
+	real dist = val-begin_;
+	if(abs(
+		(dist-(static_cast<uint64>((dist+0.01*epsilon)/stride_)*stride_))
+		)<= epsilon) return true;
+	if(equal(val,begin_))return true;
+	if(equal(val,end_))return true;
+	return false;
+}
+
+
 }
 
 #endif  //__stridedRange_hpp__ 
diff --git a/src/phasicFlow/repository/IOobject/IOPattern.cpp b/src/phasicFlow/repository/IOobject/IOPattern.cpp
new file mode 100644
index 00000000..bc240534
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/IOPattern.cpp
@@ -0,0 +1,35 @@
+/*------------------------------- 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 "processors.hpp"
+#include "IOPattern.hpp"
+
+pFlow::IOPattern::IOPattern( IOType iotype)
+:
+	ioType_(iotype),
+	globalSize_(processors::globalSize()),
+	globalRank_(processors::globalRank()),
+	isMaster_(processors::globalMaster()),
+	isParallel_(processors::globalParallel())
+{}
+
+pFlow::word pFlow::IOPattern::exeMode()
+{
+    return processors::globalRunTypeName();
+}
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/IOPattern.hpp b/src/phasicFlow/repository/IOobject/IOPattern.hpp
new file mode 100644
index 00000000..9bd46e09
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/IOPattern.hpp
@@ -0,0 +1,185 @@
+/*------------------------------- 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 __IOPattern_hpp__
+#define __IOPattern_hpp__
+
+
+
+#include "types.hpp"
+
+namespace pFlow
+{
+
+
+class IOPattern
+{
+public:
+
+	/**
+	 * Type of input/output
+	 * 
+	 * MasterProcessorOnly: Read or write is done on master processor
+	 *    and the data on master processor is affected.
+	 * 
+	 * MasterProcessorDistribute: Read is done on master processor, but 
+	 * the data should be distributed between processors based on an externally 
+	 * specified pattern. Write is done on master processors and the data is 
+	 * collected from all processors (collection is done based on the externally 
+	 * specified pattern). 
+	 * 
+	 * AllProcessorsSimilar: Read is done on all processors and processors 
+	 *    read the same data. Write is done on master processor, since 
+	 *    all processors have the same copy of data. 
+	 */
+	enum IOType : int
+	{
+		MasterProcessorOnly			= 0,
+		AllProcessorsSimilar 		= 1,
+		MasterProcessorDistribute	= 4,
+		AllProcessorsDifferent      = 8 // this is used for << and >> operators for 
+									// standard input and output streams 
+	};
+
+private:
+
+	IOType 		    ioType_;
+
+	int  			globalSize_ = 1;
+
+	int 			globalRank_ = 0;
+
+	bool 			isMaster_ = true;
+
+	bool 			isParallel_ = false;
+
+public:
+
+	IOPattern( IOPattern::IOType iotype);
+	
+	IOPattern(const IOPattern&)=default;
+
+	IOPattern(IOPattern&&) = default;
+
+	IOPattern& operator=(const IOPattern&)=default;
+
+	IOPattern& operator=(IOPattern&&)=default;
+
+	~IOPattern() = default;
+
+	inline
+	bool isMasterProcessorOnly()const
+	{
+		return ioType_ == MasterProcessorOnly;
+	}
+
+	inline
+	bool isAllProcessorSimilar()const
+	{
+		return ioType_ == AllProcessorsSimilar;
+	}
+
+	inline
+	bool isMasterProcessorDistribute()const
+	{
+		return ioType_ == MasterProcessorDistribute;
+	}
+
+	inline
+	bool isAllProcessorsDifferent()const
+	{
+		return ioType_ == AllProcessorsDifferent;
+	}
+
+	inline
+	bool isMaster()const
+	{
+		return isMaster_;
+	}
+
+	inline 
+	bool isParallel()const
+	{
+		return isParallel_;
+	}
+
+    inline
+    bool thisCallRead()const
+    {
+        if(isMasterProcessorOnly() && !isMaster())return false;
+        return true;
+    }
+
+	inline 
+	bool thisCallWrite()const
+	{
+		if(isMasterProcessorOnly()&& !isMaster())return false;
+		return true;
+	}
+
+	inline
+	bool thisProcReadData()const
+	{
+		if(isMasterProcessorOnly() && !isMaster())return false;
+        if(isMasterProcessorDistribute()&& !isMaster())return false; 
+		return true;
+	}
+
+	inline
+	bool thisProcWriteData()const
+	{
+		if(isAllProcessorsDifferent()) return true;
+        if(isMasterProcessorDistribute())return true;
+		return isMaster();
+	}
+
+	inline 
+	bool thisProcReadHeader()const
+	{
+		return thisProcReadData();
+	}
+
+	inline
+	bool thisProcWriteHeader()const
+	{
+		return isMaster();
+	}
+
+	inline 
+	auto globalSize()const
+	{
+		return globalSize_;
+	}
+
+	inline 
+	auto globalRank()const
+	{
+		return globalRank_;
+	}
+
+	static 
+	word exeMode();
+
+
+};
+
+}
+
+#endif //__IOPattern_hpp__
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/IOfileHeader.cpp b/src/phasicFlow/repository/IOobject/IOfileHeader.cpp
index 2aae5642..96a49f67 100644
--- a/src/phasicFlow/repository/IOobject/IOfileHeader.cpp
+++ b/src/phasicFlow/repository/IOobject/IOfileHeader.cpp
@@ -12,7 +12,7 @@ Licence:
   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 
+  phasicFlow is distribute+d 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.
 
@@ -31,14 +31,12 @@ pFlow::uniquePtr<pFlow::iFstream> pFlow::IOfileHeader::inStream()const
 
 pFlow::uniquePtr<pFlow::oFstream> pFlow::IOfileHeader::outStream()const
 {
-
-	
 	auto osPtr = makeUnique<oFstream>(path(), outFileBinary());
 	
-	if(osPtr && owner_)
+	if(osPtr && owner())
 	{
-	 	auto outPrecision = owner_->outFilePrecision();
-	 	osPtr->precision(outPrecision);
+	 	auto outPrecision = owner()->outFilePrecision();
+	 	osPtr->precision(static_cast<int>(outPrecision));
 	}
 
 	return osPtr;
@@ -46,34 +44,32 @@ pFlow::uniquePtr<pFlow::oFstream> pFlow::IOfileHeader::outStream()const
 
 pFlow::IOfileHeader::IOfileHeader
 (
-	const objectFile& objf,
-	const repository* owner
+	const objectFile& objf
 )
 :
-	objectFile(objf),
-	owner_(owner)
+	objectFile(objf)
 {}
 
 pFlow::fileSystem pFlow::IOfileHeader::path() const
 {
 	fileSystem f;
 
-	if( owner_ )
+	if( owner() )
 	{
-		f = owner_->path()/localPath();	
+		f = owner()->path()/localPath();	
 
 	}else
 	{
 		f = localPath();
 	}
-	f += name_;
+	f += name();
 	return f;
 }
 
 bool pFlow::IOfileHeader::outFileBinary()const
 {
-	if(owner_)
-		return owner_->outFileBinary();
+	if(owner())
+		return owner()->outFileBinary();
 	else
 		return false;
 }
@@ -120,6 +116,8 @@ bool pFlow::IOfileHeader::implyRead() const
 
 bool pFlow::IOfileHeader::implyWrite() const
 {
+	if( isExcluded( name() ) ) return false;
+	if( isIncluded( name() ) ) return true;
 	return isWriteAlways();
 }
 
@@ -133,10 +131,25 @@ bool pFlow::IOfileHeader::readIfPresent()const
 	return fileExist() && isReadIfPresent();
 }
 
-
-bool pFlow::IOfileHeader::writeHeader(iOstream& os, const word& typeName) const
+bool pFlow::IOfileHeader::writeHeader()const
 {
 
+	if( !this->readWriteHeader() ) return false;
+	if( !implyWrite() ) return false;
+
+	return true;
+}
+
+bool pFlow::IOfileHeader::writeHeader
+(
+	iOstream& os, 
+	const word& typeName, 
+	bool forceWrite
+) const
+{
+
+	if(!forceWrite && !writeHeader()) return true;
+	
 	writeBanner(os);
 
 	os.writeWordEntry("objectType", typeName );
@@ -158,14 +171,23 @@ bool pFlow::IOfileHeader::writeHeader(iOstream& os, const word& typeName) const
 	return true;
 }
 
-bool pFlow::IOfileHeader::writeHeader(iOstream& os) const
+bool pFlow::IOfileHeader::writeHeader(iOstream& os, bool forceWrite) const
 {
-	return writeHeader(os, objectType_);
+	return writeHeader(os, objectType_, forceWrite);
+}
+
+bool pFlow::IOfileHeader::readHeader()const
+{
+	if( !implyRead())return false;
+	if( !this->readWriteHeader() ) return false;
+    return true;
 }
 
 bool pFlow::IOfileHeader::readHeader(iIstream& is, bool silent)
 {
-	
+
+	if(!readHeader()) return true;
+    
 	if( !is.findTokenAndNextSilent("objectName", objectName_) )
 	{
 		if(!silent)
@@ -201,7 +223,7 @@ bool pFlow::IOfileHeader::readHeader(iIstream& is, bool silent)
 	}
 
 	return true;
-}
+} 
 
 bool pFlow::IOfileHeader::writeBanner(iOstream& os)const
 {
diff --git a/src/phasicFlow/repository/IOobject/IOfileHeader.hpp b/src/phasicFlow/repository/IOobject/IOfileHeader.hpp
index fea5cb66..1d2a1e4c 100644
--- a/src/phasicFlow/repository/IOobject/IOfileHeader.hpp
+++ b/src/phasicFlow/repository/IOobject/IOfileHeader.hpp
@@ -40,9 +40,7 @@ protected:
 	
 
 	//// - data members 
-		// owner repository
-		const repository* 	owner_ = nullptr;
-		
+
 		// object name read from file 
 		word objectName_;
 
@@ -63,7 +61,7 @@ protected:
 public:
 
 	// with owner 
-	IOfileHeader(const objectFile& objf, const repository* owner = nullptr);
+	IOfileHeader(const objectFile& objf);
 
 	// - object name
 	const word& objectName()const
@@ -78,11 +76,24 @@ public:
 	}
 
 	// - pointer to owner repository 
-	const repository* owner()const 
+	virtual 
+    const repository* owner()const
+    {
+        return nullptr;
+    }
+
+	virtual
+	bool isIncluded(const word& objName)const
 	{
-		return owner_;
+		return false;
 	}
 
+	virtual
+	bool isExcluded(const word& objName)const
+	{
+		return false;
+	}
+	
 	// - path to file name 
 	fileSystem path() const;
 
@@ -95,31 +106,41 @@ public:
 	//   read the header of the file to check if it is ok
 	bool headerOk(bool silent = false);
 	
-	// - imply read 
+	/// Imply read 
 	bool implyRead() const;
 
-	// - imply write 
+	/// Imply write 
 	bool implyWrite() const;
 	
-	// - check if file exists
+	/// Check if file exists
 	bool fileExist() const;
 	
-	// - check read if present 
+	/// Check read if present 
 	bool readIfPresent()const;
 
-	// - write the header in the  file , typeName comes from caller
-	bool writeHeader(iOstream& os, const word& typeName) const;
+	/// Check if the header should be written to file
+	/// True: on master + implyWrite + readWriteHeader = true
+	/// False: otherwise
+	bool writeHeader()const;
 
-	// - write the header in the  file, typeName comes from the one read from file 
-	bool writeHeader(iOstream& os) const;
-	
-	// - read the header in the file 
+	/// Write the header to the file , typeName comes from caller
+	bool writeHeader(iOstream& os, const word& typeName, bool forceWrite = false ) const;
+
+	/// Write the header to the file, typeName comes from the one read from file 
+	bool writeHeader(iOstream& os, bool forceWrite = false) const;
+
+	/// Check if header should be read from file
+	bool readHeader()const;
+
+	/// Read the header in the file
 	bool readHeader(iIstream& is, bool silent=false);
+
 	
-	// - write the banner 
+	
+	/// write the banner 
 	bool writeBanner(iOstream& os)const;
 
-	// - wirte a separator line 
+	/// wirte a separator line 
 	bool writeSeparator(iOstream& os)const;
 
 };
diff --git a/src/phasicFlow/repository/IOobject/IOobject.cpp b/src/phasicFlow/repository/IOobject/IOobject.cpp
index e49d757c..c3956d1e 100644
--- a/src/phasicFlow/repository/IOobject/IOobject.cpp
+++ b/src/phasicFlow/repository/IOobject/IOobject.cpp
@@ -24,113 +24,148 @@ Licence:
 
 pFlow::IOobject::IOobject
 (
-	const objectFile& objf,
-	const repository* owner,
-	uniquePtr<iObject>&& obj
+    const objectFile&   objf, 
+    const IOPattern&    iop, 
+    repository*   owner
 )
 :
-	IOfileHeader(objf, owner),
-	object_(obj.release())
+	IOfileHeader(objf),
+	ioPattern_(iop),
+    owner_(owner)
 {
-
-	if(!read(this->readWriteHeader()))
-	{
-		fatalErrorInFunction<<
-		"error in reading " << name() << " from path " << path()<<endl;
-		fatalExit;
-	}
+    
+    if(owner_&& !owner->addToRepository(this))
+    {
+        fatalErrorInFunction<<
+        "failed to add object "<< objf.name()<< 
+        " to repository "<< owner->name()<<endl;
+        fatalExit;
+    }
 }
 
+pFlow::IOobject::~IOobject()
+{
+    if(owner_)
+    {
+        owner_->removeFromRepository(this);
+    }
+}
 
-pFlow::IOobject::IOobject
+pFlow::repository* pFlow::IOobject::releaseOwner
 (
-	const objectFile& objf,
-	const repository* owner,
-	uniquePtr<IOobject>&& obj
+    bool fromOwner
 )
-:
-	IOfileHeader(objf, owner),
-	object_( obj->object_.release())
+{   
+    auto* old = owner_;
+    if(old && !fromOwner)
+    {
+        old->removeFromRepository(this);
+    }
+    owner_ = nullptr;
+    return old;
+}
+
+bool pFlow::IOobject::isIncluded(const word& objName)const 
 {
+    if(owner_)
+        return owner_->isIncluded(objName);
+    return false;
 }
 
 
-bool pFlow::IOobject::isObjectValid()const
+bool pFlow::IOobject::isExcluded(const word& objName)const 
 {
-	return object_.get() != nullptr;
+    if(owner_)
+        return owner_->isExcluded(objName);
+    return false;
 }
 
-bool pFlow::IOobject::read(bool rdHdr)
+bool pFlow::IOobject::readObject(bool rdHdr)
 {
-
-	if( implyRead() )
-	{
-		if( rdHdr )
-		{	
-			if( auto ptrIS = inStream(); ptrIS )
-			{
-				if(!readHeader(ptrIS()))return false;
-				ptrIS.reset(nullptr);
-			}
-			else
-			{
-				warningInFunction<<
-				"could not open file " << path() <<endl;
-				return false;
-			}
-		}
-
-		if( auto ptrIS = inStream(); ptrIS )
-		{
-			if(!read(ptrIS(), rdHdr))return false;
-			
-		}
-		else
-		{
-			warningInFunction<<
-			"could not open file " << path() <<endl;
-			return false;
-		}
-	}	
+    if(!implyRead())return true;
 	
+    if( rdHdr && ioPattern().thisCallRead())
+    {	
+        if( auto ptrIS = inStream(); ptrIS )
+        {
+            if(!readHeader(ptrIS()))return false;
+        }
+        else
+        {
+            warningInFunction<<
+            "could not open file " << path() <<endl;
+            return false;
+        }
+    }
+
+    if(ioPattern().thisCallRead())
+    {
+        if( auto ptrIS = inStream(); ptrIS )
+        {
+            if(!readObject(ptrIS(), rdHdr))return false;              
+        }
+        else
+        {
+            warningInFunction<<
+            "could not open file " << path() <<endl;
+            return false;
+        }    
+    }
+		
 	return true;
 }
 
 
-bool pFlow::IOobject::write() const
+bool pFlow::IOobject::writeObject() const
 {
-	if(implyWrite())
+    
+	if(implyWrite()&& ioPattern().thisCallWrite())
 	{
-		if(auto ptrOS = outStream(); ptrOS )
-		{
-			return write(ptrOS());
-		}
-		else
-		{
-			warningInFunction<< 
-			"error in opening file "<< path() <<endl;
-			return false;
-		}
+		
+        if(auto ptrOS = outStream(); ptrOS )
+        {
+            return writeObject(ptrOS());
+        }
+        else
+        {
+            warningInFunction<< 
+            "error in opening file "<< path() <<endl;
+            return false;
+        }
+        
 	}
 
 	return true;
 }
 
 
-bool pFlow::IOobject::read(iIstream& is, bool rdHdr)
+bool pFlow::IOobject::readObject(iIstream& is, bool rdHdr)
 {
-	if(rdHdr)
-	{
-		if(!readHeader(is))return false;
-	}
-	return object_->read_object_t(is);
+	if(rdHdr && 
+        ioPattern().thisCallRead() && 
+        !readHeader(is)) return false;
+	
+    if(ioPattern().thisCallRead())
+    {
+        return read(is, ioPattern());
+    }
+    else
+    {
+        return true;
+    }
+	
 }
 
 
-bool pFlow::IOobject::write(iOstream& os) const
+bool pFlow::IOobject::writeObject(iOstream& os) const
 {
-	if(this->readWriteHeader())
+	if(this->writeHeader() && ioPattern().thisProcWriteHeader())
 		writeHeader(os, typeName());
-	
-	return (object_->write_object_t(os) && writeSeparator(os));
+    
+    if(ioPattern().thisCallWrite())
+	 {   
+        return write(os, ioPattern() );
+     }
+    else
+        return true;
 }
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/IOobject.hpp b/src/phasicFlow/repository/IOobject/IOobject.hpp
index 7b2ab200..36508be1 100644
--- a/src/phasicFlow/repository/IOobject/IOobject.hpp
+++ b/src/phasicFlow/repository/IOobject/IOobject.hpp
@@ -25,7 +25,7 @@ Licence:
 
 
 #include "IOfileHeader.hpp"
-
+#include "IOPattern.hpp"
 
 namespace pFlow
 {
@@ -36,144 +36,80 @@ class IOobject
 :
 	public	IOfileHeader
 {
-
 private:
 
-	class iObject
-	{
-	public:
-
-		virtual ~iObject()=default;
-
-		// - clone 
-		virtual uniquePtr<iObject> clone() const = 0;
-
-		virtual word typeName()const = 0;
-
-		virtual bool read_object_t(iIstream& is) = 0;
-
-		virtual bool write_object_t(iOstream& os)const = 0;
-
-	};
-
-	template<typename dataType>
-	class object_t
-	:
-		public iObject
-	{
-	public:
-		dataType 	data_;
-
-	public:
-
-		template<typename... Args,
-          		typename = std::enable_if_t<!std::is_constructible<object_t, Args&&...>::value>>
-		object_t(Args&&... args)
-		:
-			data_(std::forward<Args>(args)...)
-		{}
-
-		// cunstruct by copying data
-		object_t(const dataType& data): data_(data){}
-
-		// construct by moving data
-		//object_t(dataType&& data): data_(std::move(data)){}
-
-		
-		virtual uniquePtr<iObject> clone() const
-		{
-			return makeUnique<object_t>(*this);
-		}
-
-		virtual word typeName()const
-		{
-			return data_.typeName();
-		}
-
-		virtual bool read_object_t(iIstream& is)
-		{
-			return data_.read(is);
-		}
-
-		virtual bool write_object_t(iOstream& os)const
-		{
-			return data_.write(os);
-		}
-
-	};
-
-protected:
-
-	//// - data members
-
-		// underlaying data object 
-		uniquePtr<iObject> object_;
+    IOPattern       ioPattern_;
 
+    mutable repository* owner_;	
 
 public:
 
 	// - typeinfo
-	word typeName()const
-	{
-		return object_->typeName();
-	}
+	virtual 
+    word typeName() const = 0;
 
 	//// - Constructors
 
 		// - construct from components, transfer the ownership of iObject (object_t) to the 
 		//   onwner and read the object from file 
-		IOobject(const objectFile& objf, const repository* owner, uniquePtr<iObject>&& obj );
+		IOobject(
+            const objectFile&   objf, 
+            const IOPattern&    iop, 
+            repository*   owner);
+        
+        ~IOobject() override;
 
-		// - construct from components, transfer the ownership of IOobject to the owner (no read happens)
-		IOobject(const objectFile& objf, const repository* owner, uniquePtr<IOobject>&& obj);
-		
 		// - copy construct 
 		IOobject(const IOobject& src)=delete;	
 
 		// - move construct
-		IOobject(IOobject&& src) = default;
-
-		
-		// - make object from components, considering no owner for this object, and 
-		//   read from file 
-		//   Args are the arguments of object constructor 
-		template<typename T, typename... Args>
-		static auto make(const objectFile& objf, Args&&... args);
-		
-		// - construct object_t with the Args as the arguments of object constructor 
-		template<typename T, typename... Args>
-		static auto make_object_t(Args&&... args);
+		IOobject(IOobject&& src) = delete;
 		
 
-	//// - Access to data object 
+        inline
+        const IOPattern& ioPattern()const
+        {
+            return ioPattern_;
+        }
 
-		// - is object valid 
-		bool isObjectValid()const;
+        // - pointer to owner repository 
+        const repository* owner()const override
+        {
+            return owner_;
+        }
 
-		// - ref to data object
-		template<typename T>
-		auto& getObject();
+        repository* owner()
+        {
+            return owner_;
+        }
 
-		// - const ref to data object 
-		template<typename T>
-		const auto& getObject()const;
-	
-		
+        repository* releaseOwner(bool fromOwner = false);
+
+        
+        bool isIncluded(const word& objName)const override;
+        
+        bool isExcluded(const word& objName)const override;
+        
 
 	//// - IO operations 
 
 		// - read from file 
-		bool read(bool rdHdr = true);
+		bool readObject(bool rdHdr = true);
 
 		// - write to file 
-		bool write() const;
+		bool writeObject() const;
 
 		// - read from istream 
-		bool read(iIstream& is, bool rdHdr = true);
+		bool readObject(iIstream& is, bool rdHdr = true);
 
 		// - write to istream 
-		bool write(iOstream& os) const;
-		
+		bool writeObject(iOstream& os) const;
+
+        virtual 
+        bool write(iOstream& is, const IOPattern& iop)const = 0;
+
+        virtual 
+        bool read(iIstream& is, const IOPattern& iop) = 0;
 
 };
 
diff --git a/src/phasicFlow/repository/IOobject/IOobjectTemplates.cpp b/src/phasicFlow/repository/IOobject/IOobjectTemplates.cpp
index 4c8f20e1..cdaa3fc6 100644
--- a/src/phasicFlow/repository/IOobject/IOobjectTemplates.cpp
+++ b/src/phasicFlow/repository/IOobject/IOobjectTemplates.cpp
@@ -18,7 +18,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<typename T, typename... Args>
+
+/*template<typename T, typename... Args>
 auto pFlow::IOobject::make
 (
 	const objectFile& objf,
@@ -32,7 +33,7 @@ auto pFlow::IOobject::make
 }
 
 template<typename T, typename... Args>
-auto pFlow::IOobject::make_object_t(Args&&... args)
+pFlow::uniquePtr<pFlow::IOobject::iObject> pFlow::IOobject::make_object_t(Args&&... args)
 {
 	auto ptr = makeUnique<object_t<T>>(std::forward<Args>(args)...);
 	return ptr;
@@ -47,7 +48,7 @@ auto& pFlow::IOobject::getObject()
 		"accessing an invalid objecct "<< name() <<endl;
 		fatalExit;
 	}
-	return  dynamic_cast<object_t<T>&>(*object_).data_;
+	return  static_cast<object_t<T>&>(*object_).data();
 }
 
 
@@ -60,5 +61,5 @@ const auto& pFlow::IOobject::getObject()const
 		"accessing an invalid objecct "<< name() <<endl;
 		fatalExit;
 	}
-	return  dynamic_cast<const object_t<T>&>(*object_).data_;	
-}
\ No newline at end of file
+	return  static_cast<const object_t<T>&>(*object_).data();	
+}*/
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/objectFile.cpp b/src/phasicFlow/repository/IOobject/objectFile.cpp
index 55776975..d761c1ea 100644
--- a/src/phasicFlow/repository/IOobject/objectFile.cpp
+++ b/src/phasicFlow/repository/IOobject/objectFile.cpp
@@ -25,18 +25,15 @@ pFlow::objectFile::objectFile
 	const word& name
 )
 :
-	name_(name),
-	rFlag_(READ_NEVER),
-	wFlag_(WRITE_NEVER),
-	localPath_("")
+	name_(name)
 {}
 
 pFlow::objectFile::objectFile
 (
-	const word& 			name,
-	const fileSystem& 		localPath,
-	const readFlag&   		rf, 
-	const writeFlag&  		wf,
+	const word& 		name,
+	const fileSystem& 	localPath,
+	const readFlag&   	rf, 
+	const writeFlag&  	wf,
 	bool  rwHeader
 )
 :
@@ -44,6 +41,6 @@ pFlow::objectFile::objectFile
 	rFlag_(rf),
 	wFlag_(wf),
 	localPath_(localPath),
-	readWriteHeader_(rwHeader)
+	readWriteHeader_(rwHeader)	
 {
 }
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/objectFile.hpp b/src/phasicFlow/repository/IOobject/objectFile.hpp
index 7ab6f153..ee0cf85a 100644
--- a/src/phasicFlow/repository/IOobject/objectFile.hpp
+++ b/src/phasicFlow/repository/IOobject/objectFile.hpp
@@ -24,12 +24,9 @@ Licence:
 #include "types.hpp"
 #include "fileSystem.hpp"
 
-
 namespace pFlow
 {
 
-
-
 class objectFile
 {
 public:
@@ -47,28 +44,33 @@ public:
 		WRITE_NEVER
 	};
 
-protected:
 
-	// name of the entity
+private:
+
+	/// Name of the entity
 	word 	name_;
 
-	// read flag
-	readFlag  rFlag_;
+	/// Read flag
+	readFlag  rFlag_ = readFlag::READ_NEVER;
 
-	// write flag
-	writeFlag wFlag_;
+	/// Write flag
+	writeFlag wFlag_ = writeFlag::WRITE_NEVER;
 
-	// local path of entity
-	fileSystem localPath_;
+	/// Local path of entity
+	fileSystem localPath_ = "";
 
-	bool readWriteHeader_ = true;
+	/// Number of bytes used for writing/reading real variable (used for binray)
+	int 		numBytesForReal_ = numBytesForReal__;
+	
+	/// Does the objectFile read & write the header?
+	bool        readWriteHeader_ = true;
 
 public:
 
 
 	
 	// constructors
-	objectFile
+	explicit objectFile
 	(
 		const word& name
 	);
@@ -77,9 +79,9 @@ public:
 	objectFile
 	(
 		const word& name,
-		const fileSystem& localPath,
-		const readFlag&   rf = READ_NEVER,
-		const writeFlag&  wf = WRITE_NEVER,
+		const fileSystem& 	localPath,
+		const readFlag&   	rf = readFlag::READ_NEVER,
+		const writeFlag&  	wf = writeFlag::WRITE_NEVER,
 		bool  rwHeader = true
 	);
 
@@ -92,53 +94,64 @@ public:
 
 	objectFile& operator = (objectFile && rhs) = default;
 
+
 	virtual ~objectFile()=default;
 
-	virtual word name() const
+	virtual 
+	const word& name() const
 	{
 		return name_;
 	}
 
-	virtual fileSystem localPath()const
+	virtual 
+	const fileSystem& localPath()const
 	{
 		return localPath_;
 	}
 
+	inline
 	readFlag rFlag()const
 	{
 		return rFlag_;
 	}
 
+	inline
 	writeFlag wFlag()const
 	{
 		return wFlag_;
 	}
 
+	inline
 	bool isReadAlways()const
 	{
-		return rFlag_ == READ_ALWAYS;
+		return rFlag_ == readFlag::READ_ALWAYS;
 	}
 
+	inline
 	bool isReadNever()const
 	{
-		return rFlag_ == READ_NEVER;
+		return rFlag_ == readFlag::READ_NEVER;
 	}
 
+	inline
 	bool isReadIfPresent()const
 	{
-		return rFlag_ == READ_IF_PRESENT;
+		return rFlag_ == readFlag::READ_IF_PRESENT;
 	}
 
+	inline
 	bool isWriteAlways()const
 	{
-		return wFlag_ == WRITE_ALWAYS;
+		return wFlag_ == writeFlag::WRITE_ALWAYS;
 	}
 
+	inline
 	bool isWriteNever()const
 	{
-		return wFlag_ == WRITE_NEVER;
+		return wFlag_ == writeFlag::WRITE_NEVER;
 	}
 
+	inline 
 	bool readWriteHeader()const
 	{
 		return readWriteHeader_;
diff --git a/src/phasicFlow/repository/Time/Time.cpp b/src/phasicFlow/repository/Time/Time.cpp
index e99679ba..234dcfd0 100644
--- a/src/phasicFlow/repository/Time/Time.cpp
+++ b/src/phasicFlow/repository/Time/Time.cpp
@@ -55,12 +55,6 @@ pFlow::Time::Time
 		geometryRepository_,
 		geometryFolder__,
 		this
-	),
-	integration_
-	(
-		integrationRepository__,
-		integrationFolder__,
-		this
 	)
 {
 	
@@ -90,12 +84,6 @@ pFlow::Time::Time(
 		geometryRepository_,
 		geometryFolder__,
 		this
-	),
-	integration_
-	(
-		integrationRepository__,
-		integrationFolder__,
-		this
 	)
 {
 	if(!readDictionary(setiingsDict))
@@ -104,6 +92,16 @@ pFlow::Time::Time(
 	}
 }
 
+pFlow::fileSystem pFlow::Time::localPath()const
+{
+    return fileSystem(timeName());
+}
+
+pFlow::fileSystem pFlow::Time::integrationFolder() const
+{
+	return integrationFolder__;
+}
+
 bool pFlow::Time::write
 (
 	bool verbose
@@ -111,7 +109,7 @@ bool pFlow::Time::write
 {
 	if(outputToFile())
 	{
-		REPORT(0)<<"\nWriting to file at time: "<< cyanText(timeName())<<endREPORT;
+		REPORT(0)<<"\nWriting to file at time: "<< Cyan_Text(timeName())<<END_REPORT;
 		return repository::write(verbose);
 	}
 	return true;
diff --git a/src/phasicFlow/repository/Time/Time.hpp b/src/phasicFlow/repository/Time/Time.hpp
index 915c9478..6cafa87b 100644
--- a/src/phasicFlow/repository/Time/Time.hpp
+++ b/src/phasicFlow/repository/Time/Time.hpp
@@ -28,7 +28,7 @@ Licence:
 
 #include "timeControl.hpp"
 #include "repository.hpp"
-
+#include "fileSystem.hpp"
 
 
 namespace pFlow
@@ -49,10 +49,6 @@ protected:
 	// - geometry folder/repository 
 	repository 		geometry_;
 
-	// - integration folder/repository 
-	repository 		integration_;
-
-
 	bool readDictionary(const dictionary& dict);
 
 public:
@@ -70,10 +66,8 @@ public:
 
 
 	//// -  Methods
-		virtual fileSystem localPath()const
-		{
-			return timeName();
-		}
+		fileSystem localPath()const override;
+		
 	
 		// - geometry repository 
 		const repository& geometry()const
@@ -86,15 +80,7 @@ public:
 			return geometry_;
 		}
 
-		const repository& integration()const
-		{
-			return integration_;
-		}
-
-		repository& integration()
-		{
-			return integration_;
-		}
+		fileSystem integrationFolder()const;
 		
 		/// Write to the file with binary format?
 		bool outFileBinary()const override
diff --git a/src/phasicFlow/repository/Time/baseTimeControl.cpp b/src/phasicFlow/repository/Time/baseTimeControl.cpp
new file mode 100644
index 00000000..413736c0
--- /dev/null
+++ b/src/phasicFlow/repository/Time/baseTimeControl.cpp
@@ -0,0 +1,77 @@
+/*------------------------------- 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 "baseTimeControl.hpp"
+
+
+pFlow::baseTimeControl::baseTimeControl
+(
+    const dictionary &dict,
+    const word& intervalPrefix,
+	real defStartTime
+)
+{
+	auto tControl = dict.getVal<word>("timeControl");
+	if(tControl == "timeStep")
+		isTimeStep_ = true;
+	else if( tControl == "runTime" || 
+			 tControl == "simulationTime")
+		isTimeStep_ = false;
+	else
+	{
+		fatalErrorInFunction<<
+		"bad input for intervalControl in dictionary "<< dict.globalName()<<endl<<
+		"valid inputs are "<< 
+		wordList({"timeStep", "runTime", "simulationTime"})<<endl;
+		fatalExit;
+	}
+
+	word intervalWord = intervalPrefix.size()==0? word("interval"): intervalPrefix+"Interval";
+
+	if(!isTimeStep_)
+	{
+		auto startTime = (dict.getValOrSet<real>("startTime", defStartTime));
+    	auto endTime = (dict.getValOrSet<real>("endTime", largeValue));
+		auto interval = dict.getVal<real>(intervalWord);
+		rRange_ = realStridedRange(startTime, endTime, interval);
+
+	}
+	else
+	{
+		auto startTime = (dict.getValOrSet<int32>("startTime", 0));
+    	auto endTime = (dict.getValOrSet<int32>("endTime", largestPosInt32));
+		auto interval = dict.getVal<int32>(intervalWord);
+		iRange_ = int32StridedRagne(startTime, endTime, interval);
+	}
+    
+}
+
+bool pFlow::baseTimeControl::timeEvent(uint32 iter, real t, real dt) const
+{
+	if(isTimeStep_)
+	{	
+		return iRange_.isMember(iter);
+	}
+	else
+	{
+		return rRange_.isMember(t, 0.55*dt);
+	}
+    return false;
+}
diff --git a/src/phasicFlow/repository/Time/baseTimeControl.hpp b/src/phasicFlow/repository/Time/baseTimeControl.hpp
new file mode 100644
index 00000000..647cd84e
--- /dev/null
+++ b/src/phasicFlow/repository/Time/baseTimeControl.hpp
@@ -0,0 +1,55 @@
+/*------------------------------- 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 __baseTimeControl_hpp__
+#define __baseTimeControl_hpp__
+
+#include "dictionary.hpp"
+#include "ranges.hpp"
+
+
+namespace pFlow
+{
+
+class baseTimeControl
+{
+private:
+	 
+	bool 	isTimeStep_;
+
+	int32StridedRagne iRange_;
+
+	realStridedRange  rRange_;
+	
+
+public:
+
+	baseTimeControl(
+		const dictionary& dict, 
+		const word& intervalPrefix = "",
+		real defStartTime = 0.0);
+
+
+	bool timeEvent(uint32 iter, real t, real dt)const;
+
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/repository/Time/timeControl.cpp b/src/phasicFlow/repository/Time/timeControl.cpp
index cb6a162a..701130e8 100644
--- a/src/phasicFlow/repository/Time/timeControl.cpp
+++ b/src/phasicFlow/repository/Time/timeControl.cpp
@@ -174,7 +174,7 @@ void pFlow::timeControl::checkForOutputToFile()
 bool pFlow::timeControl::timersReportTime()const
 {
 	if(currentIter_<=1)return false;
-	return timersReportInterval_.isMember(currentTime_, dt_);
+	return timersReportInterval_.isMember(currentTime_, 0.55*dt_);
 }
 
 bool pFlow::timeControl::sortTime()const
@@ -203,7 +203,7 @@ bool pFlow::timeControl::operator ++(int)
 	currentTime_ += dt_;
 	if(screenReport() && !managedExternaly_)
 	{
-		REPORT(0)<<"Time (s): "<<cyanText( currentTimeWord() )<<endREPORT;
+		REPORT(0)<<"Time (s): "<<Cyan_Text( currentTimeWord() )<<END_REPORT;
 	}
 	// switch outputToFile_ on/off
 	checkForOutputToFile();
diff --git a/src/phasicFlow/repository/repository/repository.cpp b/src/phasicFlow/repository/repository/repository.cpp
index 520afa38..32f37802 100644
--- a/src/phasicFlow/repository/repository/repository.cpp
+++ b/src/phasicFlow/repository/repository/repository.cpp
@@ -18,7 +18,6 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
 #include "repository.hpp"
 
 
@@ -33,7 +32,7 @@ pFlow::repository::repository
 	localPath_(localPath),
 	owner_(owner)
 {
-
+    
 	if(owner)
 	{
 		owner->addToRepository(this);
@@ -42,10 +41,20 @@ pFlow::repository::repository
 
 pFlow::repository::~repository()
 {
-	if(owner_)
+	for(auto& objcs: objects_)
+    {
+        objcs.second->releaseOwner(true);
+    }
+    for(auto& reps: repositories_)
+    {
+        reps.second->releaseOwner(true);
+    }
+
+    if(owner_)
 	{
-		owner_->removeRepository(this);
+		owner_->removeFromRepository(this);
 	}
+    
 }
 
 pFlow::word pFlow::repository::name()const
@@ -106,26 +115,57 @@ bool pFlow::repository::addToRepository(repository* rep)
 	return true;
 }	
 
-bool pFlow::repository::removeRepository(repository* rep)
+bool pFlow::repository::removeFromRepository(repository* rep)
 {
 	auto name = rep->name();
 	return repositories_.erase(name) == 1; 
 }
 
+bool pFlow::repository::removeFromRepository(IOobject *io)
+{
+    auto name = io->name();
+	return objects_.erase(name) == 1; 
+    
+}
 
+pFlow::repository *pFlow::repository::releaseOwner(bool fromOwner)
+{
+    auto* old = owner_;
+    if(old && !fromOwner)
+    {
+        old->removeFromRepository(this);
+    }
+    owner_ = nullptr;
+    return old;
+}
+
+bool pFlow::repository::addToRepository(IOobject* io)
+{
+    if( !objects_.insertIf(io->name(), io ) )
+	{
+		warningInFunction<<
+    	"Failed to add object " << io->name() <<
+    	" to repository " << this->name() << 
+    	". It is already in this repository. \n";
+    	return false;
+	}
+
+	return true;
+}
 
 bool pFlow::repository::lookupObjectName(const word& nm)const
 {
 	return objects_.search(nm);
 }
 
-pFlow::word pFlow::repository::lookupObjectTypeName(
+pFlow::word pFlow::repository::lookupObjectTypeName
+(
 	const word& nm
-	)const
+)const
 {
 	if(auto [iter, found] = objects_.findIf(nm); found)
 	{
-		return iter->second.typeName();
+		return iter->second->typeName();
 	}
 	else
 	{
@@ -143,13 +183,11 @@ bool pFlow::repository::globalLookupObjectName
 )const
 {	
 
-	
-	
 	if(!downward)
 	{	
 		// the object to start search and its owner 
-		auto object = this;
-		auto owner = object->owner();
+		auto* object = this;
+		auto* owner = object->owner();
 
 		// get to the top-most repository 
 		while(!owner)
@@ -241,14 +279,15 @@ bool pFlow::repository::write
 ) const
 {
 	
-	for(auto& obj:objects_)
-	{
+	for(const auto& obj:objects_)
+	{		
 		if(verbose)
 		{
-			REPORT(1)<< "Writing to " << obj.second.path()<<endREPORT;
+			if(obj.second->implyWrite())
+				REPORT(1)<< "Writing to " << obj.second->path()<<END_REPORT;
 		}
 		
-		if(!obj.second.write())
+		if(!obj.second->writeObject())
 		{
 			return false;
 		}
diff --git a/src/phasicFlow/repository/repository/repository.hpp b/src/phasicFlow/repository/repository/repository.hpp
index b257e692..93698ab7 100644
--- a/src/phasicFlow/repository/repository/repository.hpp
+++ b/src/phasicFlow/repository/repository/repository.hpp
@@ -45,7 +45,7 @@ protected:
 	repository* 	 owner_;
 
 	// - sorted names of objects with object index in vector of objects
-	wordMap<IOobject>  	objects_;
+	wordMap<IOobject*>  	objects_;
 
 	// - list of repositories that this repository owns
 	// - it is not a managed list of pointers!
@@ -100,60 +100,36 @@ public:
 		// - ref to this repository 
 		repository& thisRepository();
 		
-		// - add rep to this repository 
-		//   return false if the name already exists 
+		/// @brief add repository to this repository 
+		///   return false if the name already exists 
 		bool addToRepository(repository* rep);
 		
-		// - remove rep from the list of repositories 
-		bool removeRepository(repository* rep);
-	
+		/// @brief remove rep from the list of repositories 
+		bool removeFromRepository(repository* rep);
 
-	//// - Add/remove objects 
+        /// @brief add IOobject to this repository
+        bool addToRepository(IOobject* io);
 
-		// - insert the object into repository if it does not exist
-		//   return a refernce to underlying data object, this reference never invalidated 
-		//   until it is deleted from repository.
-		//   issue a fatal error if it is already exists
-		//   ** one time construction and no move/copy of object ** 
-		template<typename T, typename... Args>
-		T& emplaceObject(const objectFile& objf, Args&&... args);
-		
-		// - insert the object into repository if it does not exist
-		//   return a refernce to underlying data object, this reference never invalidated 
-		//   until it is deleted from repository.
-		// - if the object already exist, after type check(if consistent), return the 
-		//   reference of the existing object and create no new object. 
-		//   ** one time construction and no move/copy of object ** 
-		template<typename T, typename... Args>
-		T& emplaceObjectOrGet(const objectFile& objf, Args&&... args);
+    /// @brief remove rep from the list of repositories 
+		bool removeFromRepository(IOobject* io);
 
-		// - insert the object into repository and replace if it already exists (old object is destroyed) 
-		//   return a refernce to underlying data object, this reference never invalidated 
-		//   until it is deleted from repository.
-		//   ** one time construction and no move/copy of object ** 
-		template<typename T, typename... Args>
-		T& emplaceReplaceObject(const objectFile& objf, Args&&... args);
-		
+        repository* releaseOwner(bool fromOwner = false);
 
-		// - Insert_or_replace the IOobejct into repository and change its ownership  
-		//   to this repository, take effect only if the object does not belong to 
-		//   any other repository
-		template<typename T>
-		T& insertReplaceObject(uniquePtr<IOobject>&& ptr );
-		
-
-		// - Insert_or_replace the IOobejct into repository with new objectFile and   
-		//   change the ownership to this repository, take effect only if the object
-		//   does not belong to any other repository
-		template<typename T>
-		T& insertReplaceObject(const objectFile& objf, uniquePtr<IOobject>&& ptr );
-		
-		// - rease an object from this repository
-		bool eraseObject(const word& name)
-		{
-			return objects_.erase(name) == 1;
-		}
+		virtual
+		bool isIncluded(const word& objName)const
+        {
+            if(owner_)
+                return owner_->isIncluded(objName);
+            return false;
+        }
 
+        virtual
+        bool isExcluded(const word& objName)const 
+        {
+            if(owner_)
+                return owner_->isExcluded(objName);
+            return false;
+        }
 
 	//// - lookups and queries
 	
diff --git a/src/phasicFlow/repository/repository/repositoryTemplates.cpp b/src/phasicFlow/repository/repository/repositoryTemplates.cpp
index b7e514d7..a4c9ee1e 100644
--- a/src/phasicFlow/repository/repository/repositoryTemplates.cpp
+++ b/src/phasicFlow/repository/repository/repositoryTemplates.cpp
@@ -18,12 +18,14 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
+
 template <typename Type1>
-pFlow::word pFlow::repository::reportTypeError (IOobject& object)
+pFlow::word pFlow::repository::reportTypeError(IOobject& object)
 {
 	word err;
-	err = "The requested object " + object.name() + " with type " + Type1::TYPENAME() + ", while the type " +
-	  	object.typeName() + "is found in repository " + this->name();
+	err = "Object " + object.name() + " with type " + Type1::TYPENAME() + 
+    "is requested, while the type " +
+	  	object.typeName() + "is found in repository " + this->name()+".";
 
 	return err;
 }
@@ -34,114 +36,6 @@ bool pFlow::repository::checkForObjectType(IOobject& object)
 	return Type::TYPENAME() == object.typeName();
 }
 
-template<typename T, typename... Args>
-T& pFlow::repository::emplaceObject(const objectFile& objf, Args&&... args)
-{
-	
-	if( auto [iter2, success2] = objects_.findIf(objf.name()); !success2 )
-	{
-		auto ptr = IOobject::make_object_t<T>(std::forward<Args>(args)...);
-		auto [iter, success] = objects_.emplace(std::piecewise_construct,
-					 std::forward_as_tuple(objf.name()),
-					 std::forward_as_tuple(objf, this, std::move(ptr) )
-					 );
-	
-		return iter->second.template getObject<T>();
-	}
-	else
-	{
-		fatalErrorInFunction<<
-		"IOobject " << objf.name() << " already exists in repository " << name() <<endl;
-		fatalExit;
-		return	iter2->second.template getObject<T>();
-		
-	}
-}
-
-template<typename T, typename... Args>
-T& pFlow::repository::emplaceObjectOrGet(const objectFile& objf, Args&&... args)
-{
-
-	if(auto [iter, success] = objects_.findIf(objf.name()); !success )
-	{
-		return emplaceObject<T>(objf, std::forward<Args>(args)... );
-	}
-	else
-	{
-		// type check 
-		if( checkForObjectType<T>( iter->second ) )
-		{
-			return iter->second.template getObject<T>();
-		}
-		else
-		{
-			fatalErrorInFunction<<
-			"  IOobject "<< objf.name() <<" already exist in the repository "<< name() <<
-			". Trying to return the existing object but there is a type mismatch. \n"<<
-			reportTypeError<T>( iter->second );
-			fatalExit;
-			return iter->second.template getObject<T>(); // this is never executed 
-		}
-	}
-}
-
-template<typename T, typename... Args>
-T& pFlow::repository::emplaceReplaceObject(const objectFile& objf, Args&&... args)
-{
-	
-	eraseObject(objf.name());
-
-	auto ptr = IOobject::make_object_t<T>(std::forward<Args>(args)...);
-	auto [iter, success] = objects_.emplace(std::piecewise_construct,
-					 std::forward_as_tuple(objf.name()),
-					 std::forward_as_tuple(objf, this, std::move(ptr) )
-					 );
-	
-	return iter->second.template getObject<T>();
-}
-
-template<typename T>
-T& pFlow::repository::insertReplaceObject(uniquePtr<IOobject>&& ptr )
-{
-	if( !ptr->owner() )
-	{
-		eraseObject(ptr->name());
-		objectFile objf( ptr() );
-		
-		auto [iter, success] = objects_.emplace
-					(
-						std::piecewise_construct,
-					 	std::forward_as_tuple(ptr->name()),
-					 	std::forward_as_tuple(objf, this, std::move(ptr))
-					 );
-		return iter->second.template getObject<T>();
-	}else
-	{
-		return ptr().getObject<T>();
-	}
-}
-
-template<typename T>
-T& pFlow::repository::insertReplaceObject(const objectFile& objf, uniquePtr<IOobject>&& ptr )
-{
-	if( !ptr->owner() )
-	{
-		eraseObject(objf.name());
-		
-		auto [iter, success] = objects_.emplace
-					(
-						std::piecewise_construct,
-					 	std::forward_as_tuple(objf.name()),
-					 	std::forward_as_tuple(objf, this, std::move(ptr))
-					 );
-		return iter->second.template getObject<T>();
-	}else
-	{
-		return ptr().getObject<T>();
-	}
-}
-
-
 template<typename T>
 T& pFlow::repository::lookupObject(const word& name)
 {
@@ -150,14 +44,15 @@ T& pFlow::repository::lookupObject(const word& name)
 
     	if( checkType<T>(iter->second) )
     	{
-    		return iter->second.template getObject<T>();
+    		return static_cast<T&>(*iter->second);
+            
 
     	}else
     	{
     		fatalErrorInFunction << 
-    		reportTypeError<T>(iter->second)<<endl;
+    		reportTypeError<T>(*iter->second)<<endl;
     		fatalExit;
-    		return iter->second.template getObject<T>();
+    		return static_cast<T&>(*iter->second);
     	}
         
     }
@@ -167,6 +62,6 @@ T& pFlow::repository::lookupObject(const word& name)
 		"Object with name " << name << " is not found in repository " << this->name()<<endl <<
 		"list of avaiable objest is \n" << objectNames();
         fatalExit;
-        return iter->second.template getObject<T>();
+        return static_cast<T&>(*iter->second);
     }
 }
\ No newline at end of file
diff --git a/src/phasicFlow/repository/systemControl/dynamicLinkLibs.cpp b/src/phasicFlow/repository/systemControl/dynamicLinkLibs.cpp
index 6004dd77..f74b4303 100644
--- a/src/phasicFlow/repository/systemControl/dynamicLinkLibs.cpp
+++ b/src/phasicFlow/repository/systemControl/dynamicLinkLibs.cpp
@@ -37,7 +37,7 @@ pFlow::dynamicLinkLibs::dynamicLinkLibs(
 	}
 	
 
-	REPORT(1)<< "libs are "<< greenText(libNames)<<endREPORT;
+	REPORT(1)<< "libs are "<< Green_Text(libNames)<<END_REPORT;
 
 	for(auto libName:libNames)
 	{
@@ -68,7 +68,7 @@ pFlow::dynamicLinkLibs::~dynamicLinkLibs()
 
 void* pFlow::dynamicLinkLibs::open(word libName)
 {
-	REPORT(2)<<"Loading "<< greenText(libName)<<endREPORT;
+	REPORT(2)<<"Loading "<< Green_Text(libName)<<END_REPORT;
 
 	void* handle = dlopen(libName.c_str(), RTLD_LAZY|RTLD_GLOBAL);
 	
diff --git a/src/phasicFlow/repository/systemControl/systemControl.cpp b/src/phasicFlow/repository/systemControl/systemControl.cpp
index 4cd60260..ba96adab 100644
--- a/src/phasicFlow/repository/systemControl/systemControl.cpp
+++ b/src/phasicFlow/repository/systemControl/systemControl.cpp
@@ -24,7 +24,32 @@ Licence:
 #include "error.hpp"
 #include "systemControl.hpp"
 #include "vocabs.hpp"
+#include "Lists.hpp"
 
+bool pFlow::systemControl::readIncludeExclue
+(
+	const dictionary& dict
+)
+{
+	if(dict.containsDataEntry("includeObjects"))
+	{
+		wordList incld = dict.getVal<wordList>("includeObjects");
+		for(auto& nm:incld)
+		{
+			includeList_.insert(nm);
+		}
+	}
+
+	if(dict.containsDataEntry("excludeObjects"))
+	{
+		wordList excld = dict.getVal<wordList>("excludeObjects");
+		for(auto& nm:excld)
+		{
+			excludeList_.insert(nm);
+		}
+	}
+	return true;
+}
 
 pFlow::word pFlow::systemControl::getRunName
 (
@@ -108,55 +133,58 @@ pFlow::systemControl::systemControl
 	(	
 		getTopFolder(path)
 	),
-	settings_
+    settingsDict_
 	(
-		settingsRepository__,
-		settingsFolder__,
-		this
-	),
-	caseSetup_
-	(
-		caseSetupRepository__,
-		caseSetupFolder__,
-		this
-	),
-	settingsDict_
-	(
-		settings().emplaceObject<dictionary>
-		(
-			objectFile
-			(
-				settingsFile__,
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_NEVER
-			),
-			settingsFile__,
-			true
-		)
-	),
-	libs_(settingsDict_),
-	outFilePrecision_(
-		settingsDict_.getValOrSet("outFilePrecision", static_cast<size_t>(6))
-		),
-	Time_
+        makeUnique<fileDictionary>
+        (
+            objectFile
+            (
+                settingsFile__,
+                settingsFolder__,
+                objectFile::READ_ALWAYS,
+                objectFile::WRITE_NEVER
+            ),
+            this   
+        )
+    ),
+    Time_
 	(
 		this,
-		settingsDict_
+		settingsDict_()
 	),
-	g_(
-		settingsDict_.getVal<realx3>("g")
+	settings_
+    (
+        makeUnique<repository>
+        (
+            settingsRepository__,
+            settingsFolder__,
+            this
+        )
+    ),
+	caseSetup_
+	(
+        makeUnique<repository>
+        (
+            caseSetupRepository__,
+            caseSetupFolder__,
+            this
+        )
 	),
-	domain_(
-		settingsDict_.subDict("domain")
+	
+	libs_(settingsDict_()),
+	outFilePrecision_
+    (
+		settingsDict_().getValOrSet("outFilePrecision", static_cast<uint64>(6))
 	),
 	timers_(runName_),
 	timersReport_
 	(
-		settingsDict_.getValOrSet("timersReport", Logical("Yes"))
+		settingsDict_().getValOrSet("timersReport", Logical("Yes"))
 	),
 	writeToFileTimer_("Write to file", &timers_)	
-{}
+{
+    readIncludeExclue(settingsDict_());
+}
 
 pFlow::systemControl::systemControl(
 		const real startTime, 
@@ -179,57 +207,58 @@ pFlow::systemControl::systemControl(
 	(	
 		getTopFolder(path)
 	),
-	settings_
+    settingsDict_
 	(
-		settingsRepository__,
-		settingsFolder__,
-		this
-	),
-	caseSetup_
-	(
-		caseSetupRepository__,
-		caseSetupFolder__,
-		this
-	),
-	settingsDict_
-	(
-		settings().emplaceObject<dictionary>
-		(
-			objectFile
-			(
-				settingsFile__,
-				"",
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_NEVER
-			),
-			settingsFile__,
-			true
-		)
-	),
-	libs_(settingsDict_),
-	Time_
+        makeUnique<fileDictionary>
+        (
+            objectFile
+            (
+                settingsFile__,
+                settingsFolder__,
+                objectFile::READ_ALWAYS,
+                objectFile::WRITE_NEVER
+            ),
+            this   
+        )
+    ),
+    Time_
 	(
 		this,
-		settingsDict_,
+		settingsDict_(),
 		startTime, 
 		endTime, 
 		saveInterval, 
 		startTimeName
 	),
+	settings_
+    (
+        makeUnique<repository>
+        (
+            settingsRepository__,
+            settingsFolder__,
+            this
+        )
+    ),
+	caseSetup_
+	(
+        makeUnique<repository>
+        (
+            caseSetupRepository__,
+            caseSetupFolder__,
+            this
+        )
+	),
+	libs_(settingsDict_()),
 	externalTimeControl_(true),
-	g_(
-		settingsDict_.getVal<realx3>("g")
-	),
-	domain_(
-		settingsDict_.subDict("domain")
-	),
 	timers_(runName_),
 	timersReport_
 	(
-		settingsDict_.getValOrSet("timersReport", Logical("Yes"))
+		settingsDict_->getValOrSet("timersReport", Logical("Yes"))
 	),
 	writeToFileTimer_("Write to file", &timers_)	
-{}
+{
+    readIncludeExclue(settingsDict_());
+}
 
 
 bool pFlow::systemControl::operator ++(int)
diff --git a/src/phasicFlow/repository/systemControl/systemControl.hpp b/src/phasicFlow/repository/systemControl/systemControl.hpp
index 4556ff40..28d5542b 100644
--- a/src/phasicFlow/repository/systemControl/systemControl.hpp
+++ b/src/phasicFlow/repository/systemControl/systemControl.hpp
@@ -30,10 +30,11 @@ Licence:
 
 #include "types.hpp"
 #include "Time.hpp"
-#include "dictionary.hpp"
+#include "fileDictionary.hpp"
 #include "box.hpp"
 #include "Timers.hpp"
 #include "dynamicLinkLibs.hpp"
+#include "Set.hpp"
 
 namespace pFlow
 {
@@ -50,35 +51,27 @@ protected:
 	// - path to top-level folder 
 	const fileSystem 	topLevelFolder_;
 
+    /// settingsDict fileDictionary
+	uniquePtr<fileDictionary> 	settingsDict_;
 
+    /// time repository
+    Time 			            Time_;
 
-	// - settings folder repository
-	repository 			settings_;
+	/// settings folder repository
+	uniquePtr<repository> 		settings_;
 
-	// - caseSetup folder repository
-	repository 			caseSetup_;
+	/// caseSetup folder repository
+	uniquePtr<repository>       caseSetup_;
 
-	// - settingsDict fileDictionary
-	dictionary& 		settingsDict_;
-
-	// - extra libs to be loaded
-	dynamicLinkLibs 	libs_;
+	/// extra libs to be loaded
+	dynamicLinkLibs 	        libs_;
 	
-	// - precision for writing to file 
+	/// precision for writing to file 
 	size_t 			outFilePrecision_ = 6;
 
-	// - time repository
-	Time 			Time_;
 
-	// - if time control is managed externaly
-
-	bool 				externalTimeControl_ = false;
-
-	// - acceleration 
-	realx3 			g_;
-
-	// - domain for dem world
-	box  			domain_;
+	/// if time control is managed externaly
+	bool 			externalTimeControl_ = false;
 
 	// all timers
 	Timers 			timers_;
@@ -87,6 +80,13 @@ protected:
 
 	Timer 			writeToFileTimer_;
 
+	wordSet 		includeList_;
+
+	wordSet 		excludeList_;
+    
+	
+	bool readIncludeExclue(const dictionary& dict);
+
 	static word getRunName( const fileSystem& path);
 	
 	static word getTopFolder(const fileSystem& path);
@@ -104,25 +104,25 @@ public:
 		const fileSystem path = CWD() );
 
 	const repository& settings() const{
-		return settings_;
+		return settings_();
 	}
 
 	repository& settings(){
-		return settings_;
+		return settings_();
 	}
 
 	const repository& caseSetup()const{
-		return caseSetup_;
+		return caseSetup_();
 	}
 
 	repository& caseSetup(){
-		return caseSetup_;
+		return caseSetup_();
 	}
 
 	
 	const Time& time() const
 	{
-		return const_cast<Time&>(Time_);
+		return Time_;
 	}
 
 	Time& time()
@@ -155,28 +155,31 @@ public:
 		return timersReport_();
 	}
 
-	const dictionary& settingsDict()const{
-		return settingsDict_;
+	const fileDictionary& settingsDict()const{
+		return settingsDict_();
 	}
 
-	dictionary& settingsDict(){
-		return settingsDict_;
+	fileDictionary& settingsDict(){
+		return settingsDict_();
 	}
 
+	//fileDictionary& domainDict();
+	
+
 	virtual word runName() const
 	{
 		return runName_;
 	}
 
-	inline const realx3& g()const
+	inline const realx3 g()const
 	{
-		return g_;
+		return settingsDict_().getVal<realx3>("g");
 	}
 
-	inline const box& domain()const
+	/*inline box domain()
 	{
-		return domain_;
-	}
+		return box(domainDict().subDict("globalBox"));
+	}*/
 
 	bool operator ++(int);
 
@@ -192,6 +195,36 @@ public:
 		return outFilePrecision_;
 	}
 
+	
+	bool isIncluded(const word& objName)const final
+	{
+		return includeList_.count(objName) == static_cast<size_t>(1);
+	}
+
+	
+	bool isExcluded(const word& objName)const final
+	{
+		return excludeList_.count(objName) == static_cast<size_t>(1);
+	}
+
+	void clearIncludeExclude()
+	{
+		includeList_.clear();
+		excludeList_.clear();
+	}
+
+	bool addInclude(const word& objName)
+	{
+		auto [iter, success] = includeList_.insert(objName);
+		return success;
+	}
+
+	bool addExclude(const word& objName)
+	{
+		auto [ite, success] = excludeList_.insert(objName);
+		return success;
+	}
+
 };
 
 
diff --git a/src/phasicFlow/setFieldList/setFieldEntry.cpp b/src/phasicFlow/setFieldList/setFieldEntry.cpp
index 8cb0c24f..7da664fa 100644
--- a/src/phasicFlow/setFieldList/setFieldEntry.cpp
+++ b/src/phasicFlow/setFieldList/setFieldEntry.cpp
@@ -39,13 +39,15 @@ bool pFlow::setFieldEntry::checkForTypeAndValueAll()const
 	if( 
 		!(
 			checkForTypeAndValue<int8>() ||
-			checkForTypeAndValue<int16>() ||
+			checkForTypeAndValue<uint8>() ||
 			checkForTypeAndValue<int32>() ||
 			checkForTypeAndValue<int64>() ||
 			checkForTypeAndValue<uint32>() ||
-			checkForTypeAndValue<label>() ||
+			checkForTypeAndValue<uint64>() ||
 			checkForTypeAndValue<real>()  ||
-			checkForTypeAndValue<realx3>()
+			checkForTypeAndValue<realx3>() ||
+			checkForTypeAndValue<realx4>() ||
+			checkForTypeAndValue<word>()
 		 )
 	   )
 	{
@@ -57,40 +59,58 @@ bool pFlow::setFieldEntry::checkForTypeAndValueAll()const
 	return true;
 }
 
-void* pFlow::setFieldEntry::setPointFieldDefaultValueNewAll
+pFlow::uniquePtr<pFlow::IOobject> 
+	pFlow::setFieldEntry::setPointFieldDefaultValueNewAll
 (
-	repository& owner,
 	pointStructure& pStruct,
 	bool verbose
 )
 {
-	if( void* res =  setPointFieldDefaultValueNew<int8> (owner, pStruct, verbose) ; res)
+	uniquePtr<IOobject> Ptr = nullptr;
+
+	if(  Ptr =  setPointFieldDefaultValueNew<int8>(pStruct, verbose) ; Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueNew<int16>(owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<uint8>(pStruct, verbose); Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueNew<int32> (owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<int32> (pStruct, verbose); Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueNew<int64> (owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<int64> (pStruct, verbose); Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueNew<uint32> (owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<uint32> (pStruct, verbose); Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueNew<label>(owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<int64>(pStruct, verbose); Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueNew<real>(owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<uint64>(pStruct, verbose); Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueNew<realx3>(owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<real>(pStruct, verbose); Ptr)
 	{
-		return res;
-	}else if(void* res = setPointFieldDefaultValueStdNew<word>(owner, pStruct, verbose); res)
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<realx3>(pStruct, verbose); Ptr)
 	{
-		return res;
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<realx4>(pStruct, verbose); Ptr)
+	{
+		return Ptr;
+	}
+	else if(Ptr = setPointFieldDefaultValueNew<word>(pStruct, verbose); Ptr)
+	{
+		return Ptr;
 	}else
 	{
 		fatalErrorInFunction<< 
@@ -100,46 +120,59 @@ void* pFlow::setFieldEntry::setPointFieldDefaultValueNewAll
 
 }
 
-void* pFlow::setFieldEntry::setPointFieldSelectedAll
+bool pFlow::setFieldEntry::setPointFieldSelectedAll
 (
 	repository& owner,
-	int32IndexContainer& selected,
+	uint32IndexContainer& selected,
 	bool verbose
 )
 {
 
-	if( void* res =  setPointFieldSelected<int8> (owner, selected, verbose) ; res)
+	if( setPointFieldSelected<int8> (owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelected<int16>(owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<uint8>(owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelected<int32> (owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<int32>(owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelected<int64> (owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<uint32>(owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelected<uint32> (owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<int64>(owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelected<label>(owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<uint64>(owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelected<real>(owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<real>(owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelected<realx3>(owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<realx3>(owner, selected, verbose))
 	{
-		return res;
-	}else if(void* res = setPointFieldSelectedStd<word>(owner, selected, verbose); res)
+		return true;
+	}
+	else if( setPointFieldSelected<realx4>(owner, selected, verbose))
 	{
-		return res;
-	}else
+		return true;
+	}
+	else if( setPointFieldSelected<word>(owner, selected, verbose))
+	{
+		return true;
+	}
+	else
 	{
 		fatalErrorInFunction<< 
 		"  un-supported data type "<<entry_.firstPart() << " in setField for field " << fieldName() <<endl;
-		return nullptr;
+		return false;
 	}
 
 }
diff --git a/src/phasicFlow/setFieldList/setFieldEntry.hpp b/src/phasicFlow/setFieldList/setFieldEntry.hpp
index 214d9d57..f23bdaae 100644
--- a/src/phasicFlow/setFieldList/setFieldEntry.hpp
+++ b/src/phasicFlow/setFieldList/setFieldEntry.hpp
@@ -65,48 +65,34 @@ public:
 		bool checkForTypeAndValueAll()const;
 		
 		template <typename Type>
-		void* setPointFieldDefaultValueNew
+		uniquePtr<pointField_H<Type>> 
+			setPointFieldDefaultValueNew
 		(
-			repository& owner,
 			pointStructure& pStruct,
 			bool verbose = false
 		);
 
-		template<typename Type>
-		void* setPointFieldDefaultValueStdNew
+		uniquePtr<IOobject>
+			 setPointFieldDefaultValueNewAll
 		(
-			repository& owner,
-			pointStructure& pStruct,
-			bool verbose = false
-		);
-
-		void* setPointFieldDefaultValueNewAll
-		(
-			repository& owner,
 			pointStructure& pStruct,
 			bool verbose = false
 		);
 
 		template <typename Type>
-		void* setPointFieldSelected
+		bool setPointFieldSelected
 		(
 			repository& owner,
-			int32IndexContainer& selected,
+			uint32IndexContainer& selected,
 			bool verbose = false
 		);
 
-		template <typename Type>
-		void* setPointFieldSelectedStd
-		(
-			repository& owner,
-			int32IndexContainer& selected,
-			bool verbose = false
-		);
+		
 
-		void* setPointFieldSelectedAll
+		bool setPointFieldSelectedAll
 		(
 			repository& owner,
-			int32IndexContainer& selected,
+			uint32IndexContainer& selected,
 			bool verbose = false
 		);
 
diff --git a/src/phasicFlow/setFieldList/setFieldEntryTemplates.cpp b/src/phasicFlow/setFieldList/setFieldEntryTemplates.cpp
index db9e4f28..ac30c06c 100644
--- a/src/phasicFlow/setFieldList/setFieldEntryTemplates.cpp
+++ b/src/phasicFlow/setFieldList/setFieldEntryTemplates.cpp
@@ -37,9 +37,9 @@ bool pFlow::setFieldEntry::checkForTypeAndValue()const
 }
 
 template <typename Type>
-void* pFlow::setFieldEntry::setPointFieldDefaultValueNew
+pFlow::uniquePtr<pFlow::pointField_H<Type>>
+	 pFlow::setFieldEntry::setPointFieldDefaultValueNew
 (
-	repository& owner,
 	pointStructure& pStruct,
 	bool verbose
 )
@@ -50,13 +50,10 @@ void* pFlow::setFieldEntry::setPointFieldDefaultValueNew
 	Type defValue = entry_.secondPartVal<Type>();
 	
 	if(verbose)
-		REPORT(2)<<"Creating pointField " << greenText(fieldName())<< " with default value " << cyanText(defValue)<<
-	             " in repository "<< owner.name() <<endREPORT;
-
+		REPORT(2)<<"Creating pointField " << Green_Text(fieldName())<< " with default value " << Cyan_Text(defValue)<<
+	             " in repository "<< pStruct.owner()->name() <<END_REPORT;
 	
-	auto& field = 
-	owner.emplaceObject<pointField<VectorSingle,Type>>
-	(
+	auto Ptr = makeUnique<pointField_H<Type>>(
 		objectFile
 		(
 			fieldName(),
@@ -65,13 +62,14 @@ void* pFlow::setFieldEntry::setPointFieldDefaultValueNew
 			objectFile::WRITE_ALWAYS
 		),
 		pStruct,
-		defValue
+		defValue,
+		defValue	
 	);
-
-	return &field;
+	
+	return Ptr;
 }
 
-template <typename Type>
+/*template <typename Type>
 void* pFlow::setFieldEntry::setPointFieldDefaultValueStdNew
 (
 	repository& owner,
@@ -85,8 +83,8 @@ void* pFlow::setFieldEntry::setPointFieldDefaultValueStdNew
 	Type defValue = entry_.secondPartVal<Type>();
 	
 	if(verbose)
-		REPORT(2)<<"Creating pointField " << greenText(fieldName())<< " with default value " << cyanText(defValue)<<
-	             " in repository "<< owner.name() <<endREPORT;
+		REPORT(2)<<"Creating pointField " << Green_Text(fieldName())<< " with default value " << cyanText(defValue)<<
+	             " in repository "<< owner.name() <<END_REPORT;
 
 	// by default we perform operations on host
 	auto& field = 
@@ -104,17 +102,17 @@ void* pFlow::setFieldEntry::setPointFieldDefaultValueStdNew
 	);
 
 	return &field;
-}
+}*/
 
 template <typename Type>
-void* pFlow::setFieldEntry::setPointFieldSelected
+bool pFlow::setFieldEntry::setPointFieldSelected
 (
 	repository& owner,
-	int32IndexContainer& selected,
+	uint32IndexContainer& selected,
 	bool verbose
 )
 {
-	if( !checkForType<Type>() ) return nullptr;
+	if( !checkForType<Type>() ) return false;
 
 	
 	auto fName = fieldName();
@@ -123,56 +121,34 @@ void* pFlow::setFieldEntry::setPointFieldSelected
 	{
 		fatalErrorInFunction<<
 		"Cannot find "<< fName << " in repository " << owner.name() << ". \n";
-		return nullptr;
+		return false;
 	}
 
 	Type value = entry_.secondPartVal<Type>();
 
 	if(verbose)
-		REPORT(2)<< "Setting selected points of " << greenText(fName)
-		 		 << " to value " << cyanText(value) <<endREPORT;
+		REPORT(2)<< "Setting selected points of " << Green_Text(fName)
+		 		 << " to value " << Cyan_Text(value) <<END_REPORT;
 	
 	
 	auto fieldTypeName = owner.lookupObjectTypeName(fName);
 
-	if( pointField<VectorSingle,Type>::TYPENAME() == fieldTypeName )
+	if( getTypeName<pointField_H<Type>>() == fieldTypeName )
 	{
 		
-		auto& field = owner.lookupObject<pointField<VectorSingle,Type>>(fName);
+		auto& field = owner.lookupObject<pointField_H<Type>>(fName);
 		if(field.insertSetElement(selected, value))
-			return &field;
+			return true;
 		else
-			return nullptr;
-	}
-
-	if( pointField<VectorSingle,Type, HostSpace>::TYPENAME() == fieldTypeName )
-	{
-		
-		auto& field = owner.lookupObject<pointField<VectorSingle,Type,HostSpace>>(fName);
-		if(field.insertSetElement(selected, value))
-			return &field;
-		else
-			return nullptr;
-	}
-
-	if( pointField<VectorDual,Type>::TYPENAME() == fieldTypeName )
-	{
-		
-		
-		auto& field = owner.lookupObject<pointField<VectorDual,Type>>(fName);
-		if(field.insertSetElement(selected, value))
-			return &field;
-		else
-			return nullptr;
+			return false;
 	}
 
 	fatalErrorInFunction<<
 	fieldTypeName<< " is not a supported field type for setFieldEntry.\n";
-	return nullptr;
-	
+	return false;
 }
 
-template <typename Type>
+/*template <typename Type>
 void* pFlow::setFieldEntry::setPointFieldSelectedStd
 (
 	repository& owner,
@@ -197,8 +173,8 @@ void* pFlow::setFieldEntry::setPointFieldSelectedStd
 	Type value = entry_.secondPartVal<Type>();
 
 	if(verbose)
-		REPORT(2)<< "Setting selected points of " << greenText(fName)
-		 		 << " to value " << cyanText(value) <<endREPORT;
+		REPORT(2)<< "Setting selected points of " << Green_Text(fName)
+		 		 << " to value " << cyanText(value) <<END_REPORT;
 	
 	
 	auto fieldTypeName = owner.lookupObjectTypeName(fName);
@@ -213,4 +189,4 @@ void* pFlow::setFieldEntry::setPointFieldSelectedStd
 	}
 
 	return nullptr;
-}
\ No newline at end of file
+}*/
\ No newline at end of file
diff --git a/src/phasicFlow/smartPointers/uniquePtr.hpp b/src/phasicFlow/smartPointers/uniquePtr.hpp
index 9375d15c..c1363cde 100644
--- a/src/phasicFlow/smartPointers/uniquePtr.hpp
+++ b/src/phasicFlow/smartPointers/uniquePtr.hpp
@@ -18,7 +18,6 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
 #ifndef __uniquePtr_hpp__
 #define __uniquePtr_hpp__
 
@@ -47,31 +46,27 @@ class uniquePtr
 {
 public:
 
-	typedef std::unique_ptr<T,Deleter>  uniquePtrType;
+	using uniquePtrType = std::unique_ptr<T, Deleter>;
 
 	// using base constructors 
 	using uniquePtrType::unique_ptr;
 
 
 	template<typename... Args>
-    inline static uniquePtr<T> makeUnique(Args&&... args)
-    {
-    	return uniquePtr<T>(new T(std::forward<Args>(args)...));
-    }
+	inline static uniquePtr<T> makeUnique(Args&&... args)
+	{
+		return uniquePtr<T>(new T(std::forward<Args>(args)...));
+	}
 
-    void clear()
-    {
-    	if( ! (*this) )
-    	{
-    		auto p = this->release();
-    		delete p;
-    	}
-    }
+	void clear()
+	{
+		this->reset(nullptr);
+	}
 
-    // ref to the object of type T
+	// ref to the object of type T
 	T& operator ()()
 	{
-		if(!this->get())
+		if(!*this)
 		{
 			fatalErrorInFunction <<
 			"uniquePtr is empty, and you are trying to get its reference. \n" <<
@@ -84,14 +79,19 @@ public:
 	// const ref to the object of type T
 	const T& operator() () const
 	{
-		if(!this->get())
+		if(!*this)
 		{
 			fatalErrorInFunction <<
 			"uniquePtr is empty, and you are trying to get its reference. \n" <<
 			"Type name is "<< typeid(T).name()<<"\n";
 			fatalExit;
 		}
-		return const_cast<T&>(*this->get());
+		return static_cast<const T&>(*this->get());
+	}
+
+	explicit operator bool() const
+	{
+		return this->get()!= nullptr;
 	}
 
 };
@@ -104,7 +104,4 @@ inline uniquePtr<T> makeUnique(Args&&... args)
 
 }
 
-
-
-
 #endif
diff --git a/src/phasicFlow/streams/Fstream/fileStream.cpp b/src/phasicFlow/streams/Fstream/fileStream.cpp
index 8edf2d3a..a577d83c 100755
--- a/src/phasicFlow/streams/Fstream/fileStream.cpp
+++ b/src/phasicFlow/streams/Fstream/fileStream.cpp
@@ -17,9 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
 
 #include "fileStream.hpp"
 #include "error.hpp"
@@ -133,6 +130,3 @@ std::ofstream& pFlow::fileStream::outStream()
 {
 	return outStream_();
 }
-
-
-
diff --git a/src/phasicFlow/streams/Fstream/fileStream.hpp b/src/phasicFlow/streams/Fstream/fileStream.hpp
index 8804200c..0cf6f34b 100755
--- a/src/phasicFlow/streams/Fstream/fileStream.hpp
+++ b/src/phasicFlow/streams/Fstream/fileStream.hpp
@@ -33,49 +33,61 @@ Licence:
 namespace pFlow
 {
 
+/**
+ * Creates and manages an input/output file stream 
+ * with specified format. 
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs.
+ */
 class fileStream
 {
 protected:
 
-	// - in file stream 
+	/// in file stream 
 	uniquePtr<std::ifstream> inStream_;
 	
-	// - out file stream
+	/// out file stream
 	uniquePtr<std::ofstream> outStream_;
 
 	bool binary_ = false;
 	
-	// - open input file
+	/// open input file
 	void openInFile(const fileSystem& path);
 	
-	// - open output file
+	/// open output file
 	void openOutFile(const fileSystem& path);
 	
-	// - close streams 
+	/// close streams 
 	void close();
 
 public:
 
-	// - Constructors
+	//// - Constructors
 
-	fileStream( const fileSystem& path, bool outStream = false, bool binary = false);
-	
-	fileStream(const fileStream&)= delete;
+		/// From file path and input type and format. 
+		fileStream( const fileSystem& path, bool outStream = false, bool binary = false);
+		
+		/// No copy
+		fileStream(const fileStream&)= delete;
 
-	fileStream& operator=(const fileStream&)=delete;
+		/// No assignment
+		fileStream& operator=(const fileStream&)=delete;
 
-	virtual ~fileStream() 
-	{
-		close();
-	}
+		/// Destructor
+		virtual ~fileStream() 
+		{
+			close();
+		}
 	
 	
-	// - access 
-
-	std::ifstream& inStream();
+	//// - Access 
 	
-	std::ofstream& outStream();
-
+		/// Access input file stream 
+		std::ifstream& inStream();
+		
+		/// Access output file stream 
+		std::ofstream& outStream();
 };
 
 }
diff --git a/src/phasicFlow/streams/Fstream/iFstream.cpp b/src/phasicFlow/streams/Fstream/iFstream.cpp
index 2eb0a4fe..01043a95 100755
--- a/src/phasicFlow/streams/Fstream/iFstream.cpp
+++ b/src/phasicFlow/streams/Fstream/iFstream.cpp
@@ -17,9 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
 
 #include "iFstream.hpp"
 
diff --git a/src/phasicFlow/streams/Fstream/iFstream.hpp b/src/phasicFlow/streams/Fstream/iFstream.hpp
index a37baf81..dc90a8c2 100755
--- a/src/phasicFlow/streams/Fstream/iFstream.hpp
+++ b/src/phasicFlow/streams/Fstream/iFstream.hpp
@@ -17,9 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
 #ifndef __iFstream_hpp__
 #define __iFstream_hpp__
 
@@ -31,7 +28,12 @@ Licence:
 namespace pFlow
 {
 
-
+/**
+ * Input file stream for reading binary or ascii data from a file. 
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs.
+ */
 class iFstream
 :
 	public fileStream,
@@ -39,17 +41,19 @@ class iFstream
 {
 public:
 
-	// - Constructor 
-	iFstream (const fileSystem& path, bool binary = false);
+	//// - Constructors
 
-	// no copy constructor
-	iFstream( const iFstream& src) = delete;
+		/// From file path and format 
+		iFstream (const fileSystem& path, bool binary = false);
 
-	// no assignment
-	iFstream& operator = (const iFstream& rhs) = delete;
+		/// No copy constructor
+		iFstream( const iFstream& src) = delete;
 
-	// - Destructor
-	virtual ~iFstream() = default;
+		/// No assignment
+		iFstream& operator = (const iFstream& rhs) = delete;
+
+		/// Destructor
+		virtual ~iFstream() = default;
 
 };
 
diff --git a/src/phasicFlow/streams/Fstream/oFstream.cpp b/src/phasicFlow/streams/Fstream/oFstream.cpp
index 5e975843..54e1606a 100755
--- a/src/phasicFlow/streams/Fstream/oFstream.cpp
+++ b/src/phasicFlow/streams/Fstream/oFstream.cpp
@@ -17,8 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
 
 
 #include "oFstream.hpp"
diff --git a/src/phasicFlow/streams/Fstream/oFstream.hpp b/src/phasicFlow/streams/Fstream/oFstream.hpp
index 0fa6d86d..3092b2ca 100755
--- a/src/phasicFlow/streams/Fstream/oFstream.hpp
+++ b/src/phasicFlow/streams/Fstream/oFstream.hpp
@@ -17,10 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
-
 #ifndef __oFstream_hpp__
 #define __oFstream_hpp__
 
@@ -32,7 +28,13 @@ Licence:
 namespace pFlow
 {
 
-
+/**
+ * Output file stream to send binary or ascii data to a file.  
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs
+ *
+ */
 class oFstream
 :
 	public fileStream,
@@ -40,16 +42,18 @@ class oFstream
 {
 public:
 
-	// Constructor
+	//// - Constructors
+	
+	/// From file path and format 
 	oFstream (const fileSystem& path, bool binary = false);
 
-	// no copy constructor
+	/// No copy constructor
 	oFstream( const oFstream& src) = delete;
 
-	// no assignment
+	/// No assignment
 	oFstream& operator = (const oFstream& rhs) = delete;
 
-	// Destructor
+	/// Destructor
 	virtual ~oFstream() = default;
 
 };
diff --git a/src/phasicFlow/streams/Stream/Istream.cpp b/src/phasicFlow/streams/Stream/Istream.cpp
index 06e3a4ed..3786448a 100755
--- a/src/phasicFlow/streams/Stream/Istream.cpp
+++ b/src/phasicFlow/streams/Stream/Istream.cpp
@@ -17,10 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
-
 #include "Istream.hpp"
 #include "token.hpp"
 #include "error.hpp"
@@ -797,12 +793,6 @@ pFlow::iIstream& pFlow::Istream::read(int32& val)
     return *this;
 }
 
-pFlow::iIstream& pFlow::Istream::read(int16& val)
-{
-    is_ >> val;
-    setState(is_.rdstate());
-    return *this;
-}
 
 pFlow::iIstream& pFlow::Istream::read(int8& val)
 {
@@ -811,7 +801,7 @@ pFlow::iIstream& pFlow::Istream::read(int8& val)
     return *this;
 }
 
-pFlow::iIstream& pFlow::Istream::read(label& val)
+pFlow::iIstream& pFlow::Istream::read(uint64& val)
 {
     is_ >> val;
     setState(is_.rdstate());
@@ -825,7 +815,7 @@ pFlow::iIstream& pFlow::Istream::read(uint32& val)
     return *this;
 }
 
-pFlow::iIstream& pFlow::Istream::read(uint16& val)
+pFlow::iIstream& pFlow::Istream::read(uint8& val)
 {
     is_ >> val;
     setState(is_.rdstate());
@@ -868,6 +858,36 @@ pFlow::iIstream& pFlow::Istream::read
     return *this;
 }
 
+size_t pFlow::Istream::findBinaryBlockStart()
+{
+    size_t pos = 0;
+    char getChar = 'a';
+    unsigned char bFlag = 255;
+    int numFound = 0;
+
+    while( is_.good() && !is_.eof() )
+    {
+        getChar = is_.get();
+        pos++;
+
+        if( numFound <3 &&
+         static_cast<unsigned char>(getChar) == bFlag ) 
+        {
+            numFound++;
+        }
+        else if(numFound == 3 && static_cast<unsigned char>(getChar) == 0 )
+        {
+            return pos;
+        }
+        else
+        {
+            numFound = 0;
+        }
+    }
+
+    return static_cast<size_t>(-1);
+}
+
 void pFlow::Istream::rewind()
 {
     lineNumber_ = 1;      // Reset line number
@@ -879,6 +899,28 @@ void pFlow::Istream::rewind()
     stdStream().rdbuf()->pubseekpos(0, std::ios_base::in);
 }
 
+void pFlow::Istream::seek(size_t pos)
+{
+    stdStream().clear();  // Clear the iostate error state flags
+    setGood();            // Sync local copy of iostate
+    resetPutBack();
+    // pubseekpos() rather than seekg() so that it works with gzstream
+    stdStream().rdbuf()->pubseekpos(pos, std::ios_base::in);
+}
+
+size_t pFlow::Istream::tell() 
+{
+
+    auto pos = static_cast<size_t>(stdStream().tellg());
+    if(stdStream().fail())
+    {
+        fatalErrorInFunction<<
+        "Error in getting current position from stream "<<
+        this->name()<<endl;
+        fatalExit;
+    }
+    return pos;
+}
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/phasicFlow/streams/Stream/Istream.hpp b/src/phasicFlow/streams/Stream/Istream.hpp
index ae2bcab8..4e8dd969 100755
--- a/src/phasicFlow/streams/Stream/Istream.hpp
+++ b/src/phasicFlow/streams/Stream/Istream.hpp
@@ -17,10 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
-
 #ifndef __Istream_hpp__
 #define __Istream_hpp__
 
@@ -34,140 +30,152 @@ Licence:
 namespace pFlow
 {
 
-
+/**
+ * Standard input stream for binary and ascii data 
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs.
+ */
 class Istream
 :
     public iIstream
 {
-    // Private Data
+    //- Private Data
 
-    word    name_;
+        /// Stream name 
+        word    name_;
 
-    std::istream& is_;
+        /// Input stream 
+        std::istream& is_;
 
 
-    //- Get the next valid character
+    /// Get the next valid character
     char nextValid();
 
-    //- Read a word token
+    /// Read a word token
     void readWordToken(token& t);
 
     
-    //- Read a variable name starting with '$'.
+    /// Read a variable name starting with '$'.
     //  Handles "$var" and "${var}" forms, permits '/' scoping character.
     Istream& readVariable(word& str);
 
-    //- No copy assignment
+    /// No copy assignment
     void operator=(const Istream&) = delete;
 
 
 public:
 
+    //// - Constructors 
 
-    //- Construct wrapper around std::istream, set stream status
-    Istream( std::istream& is, const word& streamName, writeFormat wf = ASCII);
+        /// Construct wrapper around std::istream, set stream status
+        Istream( std::istream& is, const word& streamName, writeFormat wf = ASCII);
 
-    //- Destructor
-    virtual ~Istream() = default;
+        /// Destructor
+        virtual ~Istream() = default;
 
 
     //// - Methods
 
-    //- Return the name of the stream
-    virtual const word& name() const
-    {
-        return name_;
-    }
+        /// Return the name of the stream
+        virtual const word& name() const
+        {
+            return name_;
+        }
 
-    //- Return non-const access to the name of the stream
-    virtual word& name()
-    {
-        return name_;
-    }
+        /// Return non-const access to the name of the stream
+        virtual word& name()
+        {
+            return name_;
+        }
 
-    //- Return flags of output stream
-    virtual ios_base::fmtflags flags() const;
+        /// Return flags of output stream
+        virtual ios_base::fmtflags flags() const;
 
 
-    //// Read Functions
+    //// - Read Functions
 
-    //- Raw, low-level get character function.
-    Istream& get(char& c);
+        /// Raw, low-level get character function.
+        Istream& get(char& c);
 
-    //- Raw, low-level peek function.
-    //  Does not remove the character from the stream.
-    //  Returns the next character in the stream or EOF if the
-    //  end of file is read.
-    int peek();
+        /// Raw, low-level peek function.
+        ///  Does not remove the character from the stream.
+        ///  Returns the next character in the stream or EOF if the
+        ///  end of file is read.
+        int peek();
 
-    //- Raw, low-level getline (until delimiter) into a string.
-    Istream& getLine(word& str, char delim = '\n');
+        /// Raw, low-level getline (until delimiter) into a string.
+        Istream& getLine(word& str, char delim = '\n');
 
-    //- Low-level discard until delimiter
-    //  return the number of characters extracted
-    std::streamsize getLine(std::nullptr_t, char delim = '\n');
+        /// Low-level discard until delimiter
+        ///  return the number of characters extracted
+        std::streamsize getLine(std::nullptr_t, char delim = '\n');
 
-    //- Raw, low-level putback character function.
-    Istream& putback(const char c);
+        /// Raw, low-level putback character function.
+        Istream& putback(const char c);
 
-    //- Return next token from stream
-    virtual iIstream& read(token& t) override;
+        /// Return next token from stream
+        virtual iIstream& read(token& t) override;
 
-    //- Read a character
-    virtual iIstream& read(char& c) override;
+        /// Read a character
+        virtual iIstream& read(char& c) override;
 
-    //- Read a word
-    virtual iIstream& read(word& str) override;
+        /// Read a word
+        virtual iIstream& read(word& str) override;
 
-    //- Read a string
-    virtual iIstream& readString(word& str) override;
+        /// Read a string
+        virtual iIstream& readString(word& str) override;
 
-    //- Read a int64
-    virtual iIstream& read(int64&) override;
+        /// Read a int64
+        virtual iIstream& read(int64&) override;
 
-    //- Read a int32
-    virtual iIstream& read(int32&) override;
+        /// Read a int32
+        virtual iIstream& read(int32&) override;
 
-    //- Read a int16
-    virtual iIstream& read(int16&) override;
+        /// Read a int8
+        virtual iIstream& read(int8&) override;
 
-    //- Read a int8
-    virtual iIstream& read(int8&) override;
+        /// Read a uint64
+        virtual iIstream& read(uint64&) override;
 
-    //- Read a label
-    virtual iIstream& read(label&) override;
+        /// Read a uint32
+        virtual iIstream& read(uint32&) override;
 
-    //- Read a uint32
-    virtual iIstream& read(uint32&) override;
+        /// Read a uint8
+        virtual iIstream& read(uint8&) override;
 
-    //- Read a uint16
-    virtual iIstream& read(uint16&) override;
+        /// Read a float
+        virtual iIstream& read(float& val) override;
 
-    //- Read a float
-    virtual iIstream& read(float& val) override;
+        /// Read a double
+        virtual iIstream& read(double& val) override;
 
-    //- Read a double
-    virtual iIstream& read(double& val) override;
-
-    iIstream& read(char* buffer, std::streamsize count) override;
+        iIstream& read(char* buffer, std::streamsize count) override;
 
     
-    //- Rewind the stream so that it may be read again
-    virtual void rewind();
+    size_t findBinaryBlockStart()override;
+
+    /// Rewind the stream so that it may be read again
+    void rewind() override;
+
+    void seek(size_t pos) override;
+
+    /// Return current position indicator 
+    size_t tell() override;
 
 
-    //- Set stream flags
+    /// Set stream flags
     virtual ios_base::fmtflags flags(const ios_base::fmtflags flags);
 
 
 
-    //- Access to underlying std::istream
+    /// Access to underlying std::istream
     virtual std::istream& stdStream()
     {
         return is_;
     }
 
-    //- Const access to underlying std::istream
+    /// Const access to underlying std::istream
     virtual const std::istream& stdStream() const
     {
         return is_;
diff --git a/src/phasicFlow/streams/Stream/Ostream.cpp b/src/phasicFlow/streams/Stream/Ostream.cpp
index 51f2f28d..e4cf6cbc 100755
--- a/src/phasicFlow/streams/Stream/Ostream.cpp
+++ b/src/phasicFlow/streams/Stream/Ostream.cpp
@@ -17,8 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
 
 #include "error.hpp"
 #include "token.hpp"
@@ -181,21 +179,14 @@ pFlow::iOstream& pFlow::Ostream::write(const int32 val)
     return *this;
 }
 
-/*pFlow::iOstream& pFlow::Ostream::write(const int16 val)
+pFlow::iOstream& pFlow::Ostream::write(const int8 val)
 {
     os_ << val;
     setState(os_.rdstate());
     return *this;
 }
 
-pFlow::iOstream& pFlow::Ostream::write(const int8 val)
-{
-    os_ << val;
-    setState(os_.rdstate());
-    return *this;
-}*/
-
-pFlow::iOstream& pFlow::Ostream::write(const label val)
+pFlow::iOstream& pFlow::Ostream::write(const uint64 val)
 {
     os_ << val;
     setState(os_.rdstate());
@@ -209,7 +200,7 @@ pFlow::iOstream& pFlow::Ostream::write(const uint32 val)
     return *this;
 }
 
-pFlow::iOstream& pFlow::Ostream::write(const uint16 val)
+pFlow::iOstream& pFlow::Ostream::write(const uint8 val)
 {
     os_ << val;
     setState(os_.rdstate());
@@ -231,6 +222,13 @@ pFlow::iOstream& pFlow::Ostream::write(const double val)
     return *this;
 }
 
+pFlow::iOstream& pFlow::Ostream::write(const size_t val)
+{
+    os_ << val;
+    setState(os_.rdstate());
+    return *this;
+}
+
 pFlow::iOstream& pFlow::Ostream::write
 (
     const char* binaryData, 
@@ -248,13 +246,22 @@ pFlow::iOstream& pFlow::Ostream::write
     os_.write(binaryData, count);
     os_ << token::END_LIST;
 
-    setState(os_.rdstate());
-
     return *this;
 }
 
+pFlow::iOstream& pFlow::Ostream::writeBinaryBlockFlag()
+{
+    write( static_cast<char>(255));
+    write( static_cast<char>(255));
+    write( static_cast<char>(255));
+    write( static_cast<char>(0));
+    return *this;
+}
 
-
+void pFlow::Ostream::seek(size_t pos)
+{
+    os_.seekp(pos, std::ios_base::cur);
+}
 
 void pFlow::Ostream::indent()
 {
@@ -264,20 +271,30 @@ void pFlow::Ostream::indent()
     }
 }
 
+void pFlow::Ostream::startOfBinaryStreaming()
+{
+    this->endl();
+    this->flush();
+}
+
+void pFlow::Ostream::endOfBinaryStreaming()
+{
+    os_.seekp(0, std::ios_base::end);
+    this->endl();
+    this->flush();
+}
 
 void pFlow::Ostream::flush()
 {
     os_.flush();
 }
 
-
 void pFlow::Ostream::endl()
 {
     write('\n');
     os_.flush();
 }
 
-
 std::ios_base::fmtflags pFlow::Ostream::flags() const
 {
     return os_.flags();
diff --git a/src/phasicFlow/streams/Stream/Ostream.hpp b/src/phasicFlow/streams/Stream/Ostream.hpp
index 727b65e4..256270b5 100755
--- a/src/phasicFlow/streams/Stream/Ostream.hpp
+++ b/src/phasicFlow/streams/Stream/Ostream.hpp
@@ -30,130 +30,156 @@ Licence:
 namespace pFlow
 {
 
-
-
+/**
+ * Standard output stream for BINARY and ASCII formats
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs
+ */
 class Ostream
 :
     public iOstream
 {
+private:
 
+    // - private data members 
+
+    /// Stream name 
     word name_;
 
+    /// Output stream 
     std::ostream& os_;
 
 
 public:
 
-    // Constructors
+    ///- Constructors
     
-    Ostream ( std::ostream& os, const word& streamName, writeFormat wf = ASCII);
+        /// Construct from components 
+        Ostream ( std::ostream& os, const word& streamName, writeFormat wf = ASCII);
 
-    //- no copy construct 
-    Ostream(const Ostream&) = delete;
+        /// No copy construct 
+        Ostream(const Ostream&) = delete;
 
-    //- No copy assignment
-    void operator=(const Ostream&) = delete;
+        /// No copy assignment
+        void operator=(const Ostream&) = delete;
 
 
     //// - Methods
 
-    //- Return the name of the stream
+        /// Return the name of the stream
         virtual const word& name() const
         {
             return name_;
         }
 
-        //- Return non-const access to the name of the stream
+        /// Return non-const access to the name of the stream
         virtual word& name()
         {
             return name_;
         }
 
-        //- Return flags of output stream
+        /// Return flags of output stream
         virtual ios_base::fmtflags flags() const;
 
 
-        //- Write token to stream or otherwise handle it.
-        //  return false if the token type was not handled by this method
+        /// Write token to stream or otherwise handle it.
+        ///  return false if the token type was not handled by this method
         bool write(const token& tok)override;
 
-        //- Write character
+        /// Write character
         iOstream& write(const char c)override;
 
-        //- Write character string
+        /// Write character string
         iOstream& write(const char* str)override;
 
-        //- Write word
+        /// Write word
         iOstream& write(const word& str)override;
     
-        //- Write std::string surrounded by quotes.
-        //  Optional write without quotes.
+        /// Write std::string surrounded by quotes.
+        ///  Optional write without quotes.
         iOstream& writeQuoted ( const word& str, const bool quoted=true ) override;
 
-        //- Write int64
+        /// Write int64
         iOstream& write(const int64 val) override;
 
-        //- Write int32
+        /// Write int32
         iOstream& write(const int32 val) override;
 
-        //- Write label
-        iOstream& write(const label val) override;
+        /// Write int32
+        iOstream& write(const int8 val) override;
 
-        //- Write uint32
+        /// Write uint64
+        iOstream& write(const uint64 val) override;
+
+        /// Write uint32
         iOstream& write(const uint32 val) override;
 
-        //- Write uint16
-        iOstream& write(const uint16 val) override;
+        /// Write uint8
+        iOstream& write(const uint8 val) override;
 
-        //- Write float
+        /// Write float
         iOstream& write(const float val) override;
 
-        //- Write double
+        /// Write double
         iOstream& write(const double val) override;
 
+        /// Write size_t
+        iOstream& write(const size_t val) override;
+
         /// Write a block of binray data 
         iOstream& write(const char* binaryData, std::streamsize count) override;
 
-        //- Add indentation characters
+        iOstream& writeBinaryBlockFlag() override;
+
+        void seek(size_t pos) override;
+
+        /// Add indentation characters
         void indent() override;
 
-        //- Set stream flags
+        /// Set stream flags
         ios_base::fmtflags flags(const ios_base::fmtflags f) override;
 
-        //- Flush stream
+        /// Add a new line and flush stream 
+        void startOfBinaryStreaming() override;
+
+        /// Reach end of file add a new line and flush stream 
+        void endOfBinaryStreaming() override ;
+
+        /// Flush stream
         void flush() override;
 
-        //- Add newline and flush stream
+        /// Add newline and flush stream
         void endl() override;
 
-        //- Get the current padding character
+        /// Get the current padding character
         char fill() const override;
 
-        //- Set padding character for formatted field up to field width
-        //  \return previous padding character
+        /// Set padding character for formatted field up to field width
+        ///  \return previous padding character
         char fill(const char fillch) override;
 
-        //- Get width of output field
+        /// Get width of output field
         int width() const override;
 
-        //- Set width of output field
-        //  \return previous width
+        /// Set width of output field
+        ///  \return previous width
         int width(const int w) override;
 
-        //- Get precision of output field
+        /// Get precision of output field
         int precision() const override;
 
-        //- Set precision of output field
-        //  return old precision
+        /// Set precision of output field
+        ///  return old precision
         int precision(const int p) override;
 
-        //- Access to underlying std::ostream
+        /// Access to underlying std::ostream
         virtual std::ostream& stdStream() 
         {
             return os_;
         }
 
-        //- Const access to underlying std::ostream
+        /// Const access to underlying std::ostream
         virtual const std::ostream& stdStream() const
         {
             return os_;
@@ -162,10 +188,9 @@ public:
 };
 
 
-
 } // pFlow
 
 
-#endif
+#endif //__Ostream_hpp__
 
 
diff --git a/src/phasicFlow/streams/TStream/helperTstream.hpp b/src/phasicFlow/streams/TStream/helperTstream.hpp
index 6a43874c..9fae802c 100755
--- a/src/phasicFlow/streams/TStream/helperTstream.hpp
+++ b/src/phasicFlow/streams/TStream/helperTstream.hpp
@@ -1,8 +1,26 @@
+/*------------------------------- 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 __helperTstream_hpp__
 #define __helperTstream_hpp__
 
 
-
 inline bool validTokenForStream(const token tok)
 {
 	if( tok.good() && !tok.isPunctuation() )return true;
diff --git a/src/phasicFlow/streams/TStream/iTstream.cpp b/src/phasicFlow/streams/TStream/iTstream.cpp
index d5f6ab2a..49b80cee 100755
--- a/src/phasicFlow/streams/TStream/iTstream.cpp
+++ b/src/phasicFlow/streams/TStream/iTstream.cpp
@@ -222,16 +222,6 @@ pFlow::iIstream& pFlow::iTstream::read
     return *this;
 }
 
-pFlow::iIstream& pFlow::iTstream::read
-(
-    int16& val
-)
-{
-    notImplementedFunction;
-    fatalExit;
-    CONSUME_PARAM(val);
-    return *this;
-}
  
 pFlow::iIstream& pFlow::iTstream::read
 (
@@ -246,7 +236,7 @@ pFlow::iIstream& pFlow::iTstream::read
 
 pFlow::iIstream& pFlow::iTstream::read
 (
-    label& val
+    uint64& val
 )
 {
     notImplementedFunction;
@@ -268,7 +258,7 @@ pFlow::iIstream& pFlow::iTstream::read
 
 pFlow::iIstream& pFlow::iTstream::read
 (
-    uint16& val
+    uint8& val
 )
 {
     notImplementedFunction;
@@ -319,6 +309,10 @@ void pFlow::iTstream::rewind()
     setGood();
 }
 
+void pFlow::iTstream::seek(size_t pos) 
+{
+    notImplementedFunction;
+}
 
 void pFlow::iTstream::reset()
 {
@@ -328,6 +322,12 @@ void pFlow::iTstream::reset()
     setGood();
 }
 
+size_t pFlow::iTstream::tell() 
+{
+    notImplementedFunction;
+    return -1;
+}
+
 const pFlow::tokenList& pFlow::iTstream::tokens()const
 {
     return tokenList_;
diff --git a/src/phasicFlow/streams/TStream/iTstream.hpp b/src/phasicFlow/streams/TStream/iTstream.hpp
index eb77f94e..2f7e0786 100755
--- a/src/phasicFlow/streams/TStream/iTstream.hpp
+++ b/src/phasicFlow/streams/TStream/iTstream.hpp
@@ -10,7 +10,7 @@
 namespace pFlow
 {
 
-// helper functions declearation
+//- helper functions declearation
 inline bool validTokenForStream(const token tok);
 
 inline bool isBeginToken(const token& tok);
@@ -18,142 +18,150 @@ inline bool isBeginToken(const token& tok);
 inline bool isEndToken(const token& tok);
 
 
+/**
+ * Input token stream. 
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs.
+ */
 class iTstream
 :
     public iIstream
 {
 protected:
     
-    // - name of the stream
+    /// name of the stream
     word    name_;
 
-    // - list of tokens in this stream
+    /// list of tokens in this stream
     tokenList  tokenList_;
 
-    // - current token
+    /// current token
     tokenList::iterator currentToken_;
 
-    // - check if end of list is reached 
+    /// check if end of list is reached 
     bool isLastToken();
 
-    // - rewind the stream 
+    /// rewind the stream 
     void setFirstToken();
 
-    // - check for valid tokens in the tokenList 
+    /// check for valid tokens in the tokenList 
     void validate();
 
 public:
 
     //// - Constructors 
 
-        //- construct with a name
+        /// construct with a name
         iTstream(const word& streamName);
 
-        // - construct with name and copy
+        /// construct with name and copy
         iTstream(const word& streamName, const tokenList& tList);
 
-        // - construct with name and move 
+        /// construct with name and move 
         iTstream(const word& streamName, tokenList && tList);
 
-        // - copy construct
+        /// copy construct
         iTstream(const iTstream&) = default;
-        // - move construct 
+        
+        /// move construct 
         iTstream(iTstream&&) = default;
 
-        // - copy assignment
+        /// copy assignment
         iTstream& operator=(const iTstream&) = default;
 
-        // - move assignment 
+        /// move assignment 
         iTstream& operator=(iTstream&&) = default;
 
-        // copy assignment from tokenList
+        /// copy assignment from tokenList
         void operator=(const tokenList& tList);
         
-        // move assignment from tokenList
+        /// move assignment from tokenList
         void operator=(tokenList&& tList);
 
-        //- Destructor
+        /// Destructor
         virtual ~iTstream() = default;
 
 
-    //// Member Functions   
+    //// - Member Functions   
 
-        //- Return the name of the stream
+        /// Return the name of the stream
         virtual const word& name() const;
 
-        //- Return non-const access to the name of the stream
+        /// Return non-const access to the name of the stream
         virtual word& name();
 
-        //- Return next token from stream
+        /// Return next token from stream
         virtual iIstream& read(token& t)override;
 
-        //- Read a character
+        /// Read a character
         virtual iIstream& read(char& c)override;
 
-        //- Read a word
+        /// Read a word
         virtual iIstream& read(word& str)override;
 
-        //- Read a string
+        /// Read a string
         virtual iIstream& readString(word& str)override;
 
-       //- Read a int64
+        /// Read a int64
         virtual iIstream& read(int64&) override;
 
-        //- Read a int32
+        /// Read a int32
         virtual iIstream& read(int32&) override;
-
-        //- Read a int16
-        virtual iIstream& read(int16&) override;
-
-        //- Read a int8
+        
+        /// Read a int8
         virtual iIstream& read(int8&) override;
 
-        //- Read a label
-        virtual iIstream& read(label&) override;
+        /// Read a uint64
+        virtual iIstream& read(uint64&) override;
 
-        //- Read a uint32
+        /// Read a uint32
         virtual iIstream& read(uint32&) override;
 
-        //- Read a uint16
-        virtual iIstream& read(uint16&) override;
+        /// Read a uint8
+        virtual iIstream& read(uint8&) override;
 
-        //- Read a floatScalar
+        /// Read a floatScalar
         virtual iIstream& read(float&) override;
 
-        //- Read a doubleScalar
+        /// Read a doubleScalar
         virtual iIstream& read(double&) override;
 
         iIstream& read(char* buffer, std::streamsize count) override;
 
-        // - Rewind the stream so that it may be read again
-        virtual void rewind();
+        /// Rewind the stream so that it may be read again
+        virtual void rewind()override;
 
-        // - reset the iTstream and make the stream empty
+        void seek(size_t pos) override;
+
+        size_t tell() override;
+
+        /// reset the iTstream and make the stream empty
         virtual void reset();
 
-        // - const access to token list
+        /// const access to token list
         const tokenList& tokens()const;
 
-        // - size
+        /// size
         size_t size()const; 
 
-        // - size
+        /// size
         size_t numTokens()const;
         
-        // - append a list of tokens to the end of tokens
+        /// append a list of tokens to the end of tokens
         //   and rewind the stream
         void appendTokens(const tokenList & tList);
 
-        // - append token to the end of token and rewind the stream 
+        /// append token to the end of token and rewind the stream 
         void appendToken(const token& t);
    
-        //- Return flags of output stream
+        /// Return flags of output stream
         ios_base::fmtflags flags() const
         {
             return ios_base::fmtflags(0);
         }
 
-        //- Set flags of stream
+        /// Set flags of stream
         ios_base::fmtflags flags(const ios_base::fmtflags)
         {
             return ios_base::fmtflags(0);        
diff --git a/src/phasicFlow/streams/TStream/oTstream.cpp b/src/phasicFlow/streams/TStream/oTstream.cpp
index 5f158545..35c9d0c8 100755
--- a/src/phasicFlow/streams/TStream/oTstream.cpp
+++ b/src/phasicFlow/streams/TStream/oTstream.cpp
@@ -108,10 +108,17 @@ pFlow::iOstream& pFlow::oTstream::write(const int32 val)
     return *this;
 }
 
+pFlow::iOstream& pFlow::oTstream::write(const int8 val)
+{
+    append(token(val)); // tokenType::INT64
+
+    return *this;
+}
 
 
 
-pFlow::iOstream& pFlow::oTstream::write(const label val)
+
+pFlow::iOstream& pFlow::oTstream::write(const uint64 val)
 {
     append(token(static_cast<int64>(val))); // tokenType::INT64
 
@@ -125,7 +132,7 @@ pFlow::iOstream& pFlow::oTstream::write(const uint32 val)
     return *this;
 }
 
-pFlow::iOstream& pFlow::oTstream::write(const uint16 val)
+pFlow::iOstream& pFlow::oTstream::write(const uint8 val)
 {
     append(token(static_cast<int64>(val))); // tokenType::INT64
 
@@ -148,6 +155,14 @@ pFlow::iOstream& pFlow::oTstream::write(const double val)
     return *this;
 }
 
+pFlow::iOstream& pFlow::oTstream::write(const size_t val)
+{
+    append(token(static_cast<int64>(val))); // tokenType::INT64
+
+    return *this;
+}
+
+
 pFlow::iOstream& pFlow::oTstream::write
 (
     const char* binaryData, 
@@ -158,6 +173,10 @@ pFlow::iOstream& pFlow::oTstream::write
     return *this;
 }
 
+void pFlow::oTstream::seek(size_t pos) 
+{
+    notImplementedFunction;
+}
 
 void pFlow::oTstream::append(const token& tok)
 {
diff --git a/src/phasicFlow/streams/TStream/oTstream.hpp b/src/phasicFlow/streams/TStream/oTstream.hpp
index 92b37f60..110e9410 100755
--- a/src/phasicFlow/streams/TStream/oTstream.hpp
+++ b/src/phasicFlow/streams/TStream/oTstream.hpp
@@ -1,4 +1,22 @@
+/*------------------------------- 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 __oTstream_hpp__
 #define __oTstream_hpp__
 
@@ -6,20 +24,27 @@
 #include "iOstream.hpp"
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 namespace pFlow
 {
 
 
-// helper functions declearation
+//- Helper functions declearation
+
+/// Is tok a valid token for this stream?
 inline bool validTokenForStream(const token tok);
 
+/// Is tok a begin token?
 inline bool isBeginToken(const token& tok);
 
+/// Is tok an end token?
 inline bool isEndToken(const token& tok);
 
-
+/**
+ * Output token stream
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs.
+ */
 class oTstream
 :
     public iOstream
@@ -27,160 +52,175 @@ class oTstream
 
 protected:
 
-    // - name of stream
+    /// name of stream
     word    name_;
 
-    // - tokenList
+    /// tokenList
     tokenList  tokenList_;
 
 public:
     
     //// - Constructors
 
-        // - emtpy stream with a name
+        /// emtpy stream with a name
         oTstream(const word& nm);
         
-        // - copy construcotr 
+        /// copy construcotr 
         oTstream(const oTstream& src);
 
-        // - move construct 
+        /// move construct 
         oTstream(oTstream&&) = default;
 
-        // - destructor 
+        /// destructor 
         virtual ~oTstream() = default;
 
     
     //// -  Methods
     
-        // give const access 
+        // Give const access 
         const tokenList& tokens()const;
 
-        // give access 
+        // Give access 
         tokenList& tokens();
     
 
     //// - Write
 
-        //- Write token to stream or otherwise handle it.
-        //  return false if the token type was not handled by this method
+        /// Write token to stream or otherwise handle it.
+        ///  return false if the token type was not handled by this method
         virtual bool write(const token& tok);
 
-        //- Write single character. Whitespace is suppressed.
+        /// Write single character. Whitespace is suppressed.
         virtual iOstream& write(const char c);
 
-        //- Write the word-characters of a character string.
-        //  Sends as a single char, or as word.
+        /// Write the word-characters of a character string.
+        ///  Sends as a single char, or as word.
         virtual iOstream& write(const char* str);
 
-        //- Write word
+        /// Write word
         virtual iOstream& write(const word& str);
 
         
-        //- Write std::string surrounded by quotes.
-        //  Optional write without quotes.
+        /// Write std::string surrounded by quotes.
+        ///  Optional write without quotes.
         virtual iOstream& writeQuoted(const std::string& str, const bool quoted=true );
 
-        //- Write int64
+        /// Write int64
         virtual iOstream& write(const int64 val) override;
 
-        //- Write int32
+        /// Write int32
         virtual iOstream& write(const int32 val) override;
 
-        
-        //- Write label
-        virtual iOstream& write(const label val) override;
+        /// Write int8
+        virtual iOstream& write(const int8 val) override;
 
-        //- Write uint32
+        /// Write uint64
+        virtual iOstream& write(const uint64 val) override;
+
+        /// Write uint32
         virtual iOstream& write(const uint32 val) override;
 
-        //- Write uint16
-        virtual iOstream& write(const uint16 val) override;
+        /// Write uint8
+        virtual iOstream& write(const uint8 val) override;
 
-        //- Write float
+        /// Write float
         virtual iOstream& write(const float val) override;
 
-        //- Write double
+        /// Write double
         virtual iOstream& write(const double val) override;
 
+        /// Write double
+        virtual iOstream& write(const size_t val) override;
+
+        void seek(size_t pos) override;
+
         /// Write a block of binray data
         iOstream& write(
             const char* binaryData, 
             std::streamsize count) override;
 
-        // - append token to the stream
+        /// append token to the stream
         virtual void append(const token& tok);
         
-        // - append a list of tokens to the stream
+        /// append a list of tokens to the stream
         virtual void append(const tokenList& tLisk);
         
     
 
     //// - Stream state functions
 
-        //- Reset the output buffer and rewind the stream
+        /// Reset the output buffer and rewind the stream
         void reset();
 
-        //- Rewind the output stream
+        /// Rewind the output stream
         virtual void rewind();
 
-        //- Add indentation characters
+        /// Add indentation characters
         virtual void indent()
         {}
 
-        //- Flush stream
+        /// Add a new line and flush stream 
+        virtual void startOfBinaryStreaming()
+        {}
+
+        /// Reach end of file add a new line and flush stream 
+        virtual void endOfBinaryStreaming()
+        {}
+
+        /// Flush stream
         virtual void flush()
         {}
 
-        //- Add newline and flush stream
+        /// Add newline and flush stream
         virtual void endl()
         {}
 
-        //- Get the current padding character
-        //  \return previous padding character
+        /// Get the current padding character
+        ///  \return previous padding character
         virtual char fill() const
         {
             return 0;
         }
 
-        //- Set padding character for formatted field up to field width
+        /// Set padding character for formatted field up to field width
         virtual char fill(const char)
         {
             return 0;
         }
 
-        //- Get width of output field
+        /// Get width of output field
         virtual int width() const
         {
             return 0;
         }
 
-        //- Set width of output field
-        //  \return previous width
+        /// Set width of output field
+        ///  \return previous width
         virtual int width(const int)
         {
              return 0;
         }
 
-        //- Get precision of output field
+        /// Get precision of output field
         virtual int precision() const
         {
              return 0;
         }
 
-        //- Set precision of output field
-        //  \return old precision
+        /// Set precision of output field
+        ///  \return old precision
         virtual int precision(const int)
         {
              return 0;
         }
 
-        //- Return flags of output stream
+        /// Return flags of output stream
         virtual ios_base::fmtflags flags() const
         {
             return ios_base::fmtflags(0);
         }
 
-        //- Set flags of stream
+        /// Set flags of stream
         ios_base::fmtflags flags(const ios_base::fmtflags)
         {
             return ios_base::fmtflags(0);
@@ -190,12 +230,9 @@ public:
 
 #include "helperTstream.hpp"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace pFlow
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #endif
 
-// ************************************************************************* //
diff --git a/src/phasicFlow/streams/dataIO/createDataIO.hpp b/src/phasicFlow/streams/dataIO/createDataIO.hpp
new file mode 100644
index 00000000..539ec35a
--- /dev/null
+++ b/src/phasicFlow/streams/dataIO/createDataIO.hpp
@@ -0,0 +1,55 @@
+/*------------------------------- 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 __createDataIO_hpp__
+#define __createDataIO_hpp__
+
+#include "uniquePtr.hpp"
+#include "dataIO.hpp"
+#include "dataIORegular.hpp"
+#include "dataIOMPI.hpp"
+
+namespace pFlow
+{
+
+template<typename T>
+uniquePtr<dataIO<T>> createDataIO(
+    const word& runType, const IOPattern& iop)
+{
+    if(runType == "regular")
+    {
+        return makeUnique<dataIORegular<T>>(iop);
+    }
+    else if(runType == "MPI")
+    {
+        return makeUnique<dataIOMPI<T>>(iop);
+    }
+    else
+    {
+        fatalErrorInFunction<< "not dataIO pattern is specified for this "<<
+        runType<<endl;
+        fatalExit;
+    }
+    return nullptr;
+}
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/streams/dataIO/dataIO.hpp b/src/phasicFlow/streams/dataIO/dataIO.hpp
new file mode 100644
index 00000000..5f378953
--- /dev/null
+++ b/src/phasicFlow/streams/dataIO/dataIO.hpp
@@ -0,0 +1,128 @@
+
+/*------------------------------- 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 __dataIO_hpp__
+#define __dataIO_hpp__
+
+#include <vector>
+
+#include "span.hpp"
+#include "IOPattern.hpp"
+#include "iOstream.hpp"
+#include "iIstream.hpp"
+
+
+
+namespace pFlow
+{
+
+// - Forward 
+template<typename T>
+bool writeDataAsciiBinary
+(
+	iOstream& os, 
+	span<T> data
+);
+
+template<typename T>
+bool writeDataASCII
+(
+	iOstream& os, 
+	span<T> data
+);
+
+template<typename T>
+bool readDataAscii
+(
+	iIstream& is,
+	std::vector<T>& vec
+);
+
+template<typename T>
+bool readDataAsciiBinary
+(
+	iIstream& is, 
+	std::vector<T>& data
+);
+
+template<typename T>
+class dataIO
+{
+protected:
+
+	IOPattern 	    ioPattern_;
+
+	std::vector<T> 	buffer_;
+
+    span<T>         bufferSpan_; 
+
+
+    /// gather data from all processors and put the results in buffer_
+	virtual bool gatherData(span<T> data) = 0;  
+
+public:
+
+	/// Type info
+	TypeInfo("dataIO");
+
+	dataIO(const IOPattern& iop)
+	:
+	    ioPattern_(iop)
+	{}
+
+	dataIO(const dataIO&) = default;
+
+	dataIO(dataIO &&) = default;
+
+	dataIO& operator = (const dataIO&) = default;
+
+	dataIO& operator = (dataIO&&) = default;
+
+	virtual ~dataIO() = default;
+
+	/// Write data to the end of file from all processors.
+	/// This method should be called from all processors. 
+	bool writeData(iOstream& os, span<T> data);
+
+	bool readData(
+        iIstream& is, 
+        std::vector<T>& data);
+
+};
+
+template<typename T>
+inline 
+iOstream& operator<<(iOstream& os, const span<T>& s)
+{
+	if(!writeDataAsciiBinary(os, s))
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+    return os;
+}
+
+
+}
+
+#include "dataIOTemplate.cpp"
+
+#endif
diff --git a/src/phasicFlow/streams/dataIO/dataIOMPI.hpp b/src/phasicFlow/streams/dataIO/dataIOMPI.hpp
new file mode 100644
index 00000000..850cf69b
--- /dev/null
+++ b/src/phasicFlow/streams/dataIO/dataIOMPI.hpp
@@ -0,0 +1,97 @@
+#ifndef __datIOMPI_hpp__
+#define __datIOMPI_hpp__
+
+#include "dataIO.hpp"
+#include "pFlowProcessors.hpp"
+
+#ifdef pFlow_Build_MPI
+    #include "gatherMaster.hpp"
+#endif
+
+namespace pFlow
+{
+
+template<typename T>
+class dataIOMPI
+:
+	public dataIO<T>
+{
+protected:
+    
+    bool gatherData(span<T> data ) override
+    {
+        
+        if(this->ioPattern_.isAllProcessorsDifferent())
+        {
+            this->bufferSpan_ = data;
+            return true;
+        }
+        
+        if( this->ioPattern_.isMasterProcessorDistribute())
+        {
+
+#ifdef pFlow_Build_MPI
+            
+            auto gatherT = pFlow::MPI::gatherMaster<T>(pFlowProcessors());
+            
+            if(!gatherT.gatherData(data))
+            {
+                fatalErrorInFunction<<"Error in gathering data to master"<<endl;
+                return false;
+            }
+
+            this->buffer_ = gatherT.moveData();
+
+            this->bufferSpan_ = makeSpan(this->buffer_);
+
+            return true;
+#else
+            notImplementedFunction;
+            fatalExit;
+            return false;
+#endif //pFlow_Build_MPI
+        
+        }
+
+        if( this->ioPattern_.isMasterProcessorOnly() || this->ioPattern_.isAllProcessorSimilar() )
+        {
+            if( this->ioPattern_.isMaster() )
+            {
+                this->bufferSpan_ = data;
+            }
+            else
+            {
+                this->bufferSpan_ = span<T>(nullptr, 0);
+                return true;
+            }
+        }
+
+        return false;
+    }
+public:
+
+	TypeInfo("dataIO<MPI>");
+
+	dataIOMPI(const IOPattern& iop)
+    :
+        dataIO<T>(iop)
+    {}
+
+	dataIOMPI(const dataIOMPI&) = default;
+
+	dataIOMPI(dataIOMPI&&) = default;
+
+
+	dataIOMPI& operator=(const dataIOMPI&) = default;
+
+	dataIOMPI& operator=(dataIOMPI&&) = default;
+
+	~dataIOMPI() = default;
+
+};
+
+
+}
+
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/streams/dataIO/dataIORegular.hpp b/src/phasicFlow/streams/dataIO/dataIORegular.hpp
new file mode 100644
index 00000000..faebc715
--- /dev/null
+++ b/src/phasicFlow/streams/dataIO/dataIORegular.hpp
@@ -0,0 +1,67 @@
+/*------------------------------- 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 __datIONoMPI_hpp__
+#define __datIONoMPI_hpp__
+
+#include "dataIO.hpp"
+
+namespace pFlow
+{
+template<typename T>
+class dataIORegular
+:
+	public dataIO<T>
+{
+protected:
+
+    bool gatherData(span<T> data ) override
+    {
+        /// in serial mode, no gathering is required. 
+        this->bufferSpan_ = data;
+        return true;
+    }
+
+public:
+
+	TypeInfo("dataIO<regular>");
+
+	dataIORegular(const IOPattern& iop)
+    :
+	    dataIO<T>(iop)
+    {}
+
+	dataIORegular(const dataIORegular&) = default;
+
+	dataIORegular(dataIORegular&&) = default;
+
+	dataIORegular& operator=(const dataIORegular&) = default;
+
+	dataIORegular& operator=(dataIORegular&&) = default;
+
+	~dataIORegular() = default;
+	
+};
+
+
+}
+
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/streams/dataIO/dataIOTemplate.cpp b/src/phasicFlow/streams/dataIO/dataIOTemplate.cpp
new file mode 100644
index 00000000..74efd812
--- /dev/null
+++ b/src/phasicFlow/streams/dataIO/dataIOTemplate.cpp
@@ -0,0 +1,260 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+template<typename T>
+bool pFlow::writeDataAsciiBinary(iOstream& os, span<T> data)
+{
+
+	if( os.isBinary() )
+	{
+		// first write the number of data
+		uint64 numData = data.size();
+		os<< numData << endl;
+
+		// write the bindary data
+		auto chBuffer = charSpan(data);
+
+		if(!os.write(chBuffer.data(), chBuffer.size()))
+		{
+			fatalErrorInFunction<<
+			"error in writing binary data to "<<os.name()<<endl;
+			return false;
+		}
+
+	}
+	else
+	{
+		if( !writeDataASCII(os, data) )
+		{
+			fatalErrorInFunction<<
+			"error in writing ASCII data to "<<os.name()<<endl;
+			return false;
+		}
+	}
+
+	return os.check(FUNCTION_NAME);
+	
+}
+
+template<typename T>
+bool pFlow::writeDataASCII(iOstream& os, span<T> data)
+{
+	os<< data.size()<<endl;
+	os << token::BEGIN_LIST;
+	if(data.size()>0)
+	{
+		for(uint32 i=0; i<data.size()-1; i++)
+		{
+			os << data[i]<<token::NL;
+		}
+		os << data[data.size()-1] << token::END_LIST;
+	}
+	else
+	{
+		os<< token::END_LIST;
+	}
+	
+	os.check(FUNCTION_NAME);
+	return true;
+}
+
+template<typename T>
+bool pFlow::readDataAsciiBinary
+(
+	iIstream& is, 
+	std::vector<T>& data
+)
+{
+	
+	if(is.isBinary())
+	{
+		data.clear();
+		// read length of data 			
+		token firstToken(is);
+		
+		size_t len = 0;
+		if( firstToken.isInt64())
+		{
+			len = firstToken.int64Token();
+			data.resize(len);	
+		}
+		else
+		{
+			fatalErrorInFunction<<
+			"expected length of vector in the stream "<<is.name()<<
+			"but found this "<< firstToken<<endl;
+			return false;
+		}
+
+		is.read(reinterpret_cast<char*>(data.data()), len*sizeof(T));	
+		
+		return is.check(FUNCTION_NAME);
+	}
+	else
+	{
+		
+		return readDataAscii(is, data);
+	}
+	
+}
+
+template<typename T>
+bool pFlow::readDataAscii
+(
+	iIstream& is,
+	std::vector<T>& vec
+)
+{
+	
+	is.fatalCheck(FUNCTION_NAME);
+
+	vec.clear();
+	
+	token firstToken(is);
+
+	size_t len = 0;
+	bool lenFound = false;
+	if( firstToken.isInt64())
+	{
+		len = firstToken.int64Token();
+		lenFound = true;
+		vec.reserve(len);
+		firstToken  = token(is);
+	}
+	
+
+	T val{};
+	if( firstToken.isPunctuation() ) // start of vector 
+	{
+		if(firstToken != token::BEGIN_LIST)
+		{
+			warningInFunction
+			<< "expected token "<< token::BEGIN_LIST 
+			<< " but found "<< firstToken ;
+			return false;
+
+		}
+
+		token lastToken(is);
+		
+		is.fatalCheck(FUNCTION_NAME);
+		
+		while(!(lastToken.isPunctuation()
+             	&& lastToken == token::END_LIST ))
+		{
+
+			is.putBack(lastToken);
+			
+			is >> val;
+			vec.push_back(val);
+			
+			is >> lastToken;
+			is.fatalCheck(FUNCTION_NAME);
+
+		}
+
+	} else
+	{
+		warningInFunction
+		<< "expected token "<< token::BEGIN_LIST 
+		<< " but found "<< firstToken<<endl; ;
+		return false;
+	}
+	
+	if(lenFound && len>0 && len != vec.size())
+	{
+		warningInFunction<<"vector length specified "<< len << 
+		" is different from number of elements "<< vec.size()<<endl;
+		return false;
+	}
+
+	return true;
+}
+
+
+template<typename T>
+bool pFlow::dataIO<T>::writeData(iOstream& os, span<T> data)
+{
+	/// first gather data from all processors (if any)
+	if(!gatherData( data ) )
+	{
+		fatalErrorInFunction<<
+		"Error in gathering data for out stream "<< os.name()<<endl;
+		return false;
+	}
+
+	if( ioPattern_.thisProcWriteData())
+	{
+		return writeDataAsciiBinary(os, data);
+	}
+	else
+	{
+		return true;
+	}
+}
+
+template<>
+inline
+bool pFlow::dataIO<pFlow::word>::writeData(iOstream& os, span<word> data)
+{
+    
+	if( ioPattern_.isParallel()	)
+	{
+		notImplementedFunction<<
+		"data transfer for type word is not supported in parallel mode!"<<endl;
+		fatalExit;
+	}
+
+    /// first gather data from all processors (if any)
+	if(!gatherData( data ) )
+	{
+		fatalErrorInFunction<<
+		"Error in gathering data for out stream "<< os.name()<<endl;
+		return false;
+	}
+	
+	if( ioPattern_.thisProcWriteData())
+	{
+		return writeDataASCII(os, data);
+	}
+	else
+	{
+		return true;
+	}
+}
+
+template<typename T>
+bool pFlow::dataIO<T>::readData
+(
+	iIstream& is, 
+	std::vector<T>& data
+)
+{
+	data.clear();
+	if(ioPattern_.thisProcReadData())
+	{
+		return readDataAsciiBinary(is, data);
+	}
+	else
+	{
+		return true;
+	}
+}
+
diff --git a/src/phasicFlow/streams/iStream/IOstream.hpp b/src/phasicFlow/streams/iStream/IOstream.hpp
index 046aa1f0..3a6982cf 100644
--- a/src/phasicFlow/streams/iStream/IOstream.hpp
+++ b/src/phasicFlow/streams/iStream/IOstream.hpp
@@ -17,13 +17,9 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
-
 #ifndef __IOstream_hpp__
 #define __IOstream_hpp__
 
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
 
 #include <iostream>
 
@@ -42,6 +38,12 @@ using std::cerr;
 namespace pFlow
 {
 
+/**
+ * A base calss for input/output streams
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs
+ */
 class IOstream
 {
 
@@ -115,7 +117,7 @@ protected:
 
 public:
 
-    //- Constructors
+    ////- Constructors
 
         /// Default
         explicit IOstream():
@@ -144,7 +146,7 @@ public:
         virtual ~IOstream() = default;
           
         
-    //- Member Functions
+    ////- Member Functions
 
         /// Return the name of the stream
         virtual const word& name() const;
@@ -178,7 +180,7 @@ public:
         bool isBinary()const
         {
             return writeFormat_ == BINARY;
-        }
+        }    
 
         /// Return true if next operation might succeed
         bool good() const
@@ -299,13 +301,13 @@ public:
             flags(flags() & ~f);
         }
 
-
 }; // end of IOstream
 
 
 /// An IOstream manipulator
 typedef IOstream& (*IOstreamManip)(IOstream&);
 
+
 inline IOstream& dec(IOstream& io)
 {
     io.setf(ios_base::dec, ios_base::dec|ios_base::hex|ios_base::oct);
@@ -337,7 +339,6 @@ inline IOstream& scientific(IOstream& io)
 }
 
 
-
 } // pFlow
 
 #endif  //  __IOstream__hpp__
diff --git a/src/phasicFlow/streams/iStream/iIstream.cpp b/src/phasicFlow/streams/iStream/iIstream.cpp
index 96849244..a74d9620 100755
--- a/src/phasicFlow/streams/iStream/iIstream.cpp
+++ b/src/phasicFlow/streams/iStream/iIstream.cpp
@@ -1,4 +1,22 @@
+/*------------------------------- 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 "iIstream.hpp"
 
 
@@ -57,6 +75,12 @@ bool pFlow::iIstream::peekBack(token& tok)
     return putBack_;
 }
 
+size_t pFlow::iIstream::findBinaryBlockStart()
+{
+    notImplementedFunction;
+    return 0;
+}
+
 bool pFlow::iIstream::findToken( const word & w )
 {
     rewind();
@@ -78,10 +102,13 @@ bool pFlow::iIstream::findTokenResume(const word& w)
             " at line number "<< lineNumber()<<endl;
             return false;
         }
-
+        
         if( next.isWord() && isFirstToken)
         {   
-            if(next.wordToken() == w ) return true;   
+            if(next.wordToken() == w ) 
+            {
+                return true;   
+            }
         }
 
         if(next.isEndStatement()|| next.isEndBlock())
diff --git a/src/phasicFlow/streams/iStream/iIstream.hpp b/src/phasicFlow/streams/iStream/iIstream.hpp
index cf32961b..2dbf0fa9 100755
--- a/src/phasicFlow/streams/iStream/iIstream.hpp
+++ b/src/phasicFlow/streams/iStream/iIstream.hpp
@@ -17,7 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
 #ifndef __iIstream_hpp__
 #define __iIstream_hpp__
 
@@ -29,25 +28,30 @@ Licence:
 namespace pFlow
 {
 
-
-class iIstream // interface class for input streams
+/**
+ * Interface class for any input stream  
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs
+ */
+class iIstream
 :
 	public IOstream
 {
 
-	// Private Data
+	//- Private Data
 
-    //- Has a token been put back on the stream?
-    bool putBack_;
+	    /// Has a token been put back on the stream?
+	    bool putBack_;
 
-    //- The last token put back on the stream
-    token putBackToken_;
+	    /// The last token put back on the stream
+	    token putBackToken_;
 
 public:
 
-    //// - Constructors    
+    ////- Constructors    
 
-    	// - default
+    	/// default
 	    iIstream():
 			IOstream(),
 	        putBack_(false)	
@@ -58,85 +62,91 @@ public:
 	    	putBack_(false)
 	    {}
 
-	    // - Copy construct
+	    /// Copy construct
 	    iIstream(const iIstream&) = default;
 
-	    // - Destructor
+	    /// Destructor
 	    virtual ~iIstream() = default;
 
 
 
-    //// member methods
+    ////- member methods
 
-	    //- Put back token
-	    //  Only a single put back is permitted
+	    /// Put back token
+	    ///  Only a single put back is permitted
 	    void putBack(const token& tok);
 
-	    //- Get the put back token if there is one and return true.
-	    //  Return false if no put back token is available.
+	    /// Get the put back token if there is one and return true.
+	    ///  Return false if no put back token is available.
 	    bool getBack(token& tok);
 
-	    //- Peek at the put back token without removing it.
-	    //  Returns false if no put back token is available and set the
-	    //  token to undefined.
+	    /// Peek at the put back token without removing it.
+	    ///  Returns false if no put back token is available and set the
+	    ///  token to undefined.
 	    bool peekBack(token& tok);
 
-	    //- reset the put back token;
+	    /// reset the put back token;
 	    void resetPutBack()
 	    {
 	    	putBackToken_.reset();
 	    	putBack_ = false;
 	    }
 
-	    //- Return next token from stream
+	    /// Return next token from stream
 	    virtual iIstream& read(token&) = 0;
 
-	    //- Read a character
+	    /// Read a character
 	    virtual iIstream& read(char&) = 0;
 
-	    //- Read a string (including enclosing double-quotes)
+	    /// Read a string (including enclosing double-quotes)
 	    virtual iIstream& read(word&) = 0;
 
-	    //- Read a string 
+	    /// Read a string 
 	    virtual iIstream& readString(word&) = 0;    
 
-	    //- Read a int64
+	    /// Read a int64
 	    virtual iIstream& read(int64&) = 0;
 
-	    //- Read a int32
+	    /// Read a int32
 	    virtual iIstream& read(int32&) = 0;
 
-	    //- Read a int16
-	    virtual iIstream& read(int16&) = 0;
-
-	    //- Read a int8
+	    /// Read a int8
 	    virtual iIstream& read(int8&) = 0;
 
-	    //- Read a label
-	    virtual iIstream& read(label&) = 0;
+	    /// Read a uint64
+	    virtual iIstream& read(uint64&) = 0;
 
-	    //- Read a uin32
+	    /// Read a uin32
 	    virtual iIstream& read(uint32&) = 0;
 
-	    //- Read a uin16
-	    virtual iIstream& read(uint16&) = 0;
+	    /// Read a uint8
+	    virtual iIstream& read(uint8&) = 0;
 
-	    //- Read a floatScalar
+	    /// Read a floatScalar
 	    virtual iIstream& read(float&) = 0;
 
-	    //- Read a doubleScalar
+	    /// Read a doubleScalar
 	    virtual iIstream& read(double&) = 0;
 
+	    /// Write a block of binray data 
 	    virtual iIstream& read(char* buffer, std::streamsize count) =0;
-
 	    
-	    //- Rewind the stream so that it may be read again
+	    /// Rewind the stream so that it may be read again
 	    virtual void rewind() = 0;
 
+	    virtual void seek(size_t pos) = 0;
 
-    //// - find and lookups
+	    /// Return current position indicator 
+	    virtual size_t tell() = 0;
 
-        // - search for all tokesn and find the first word token tbat matchs w
+    ////- find and lookups
+
+	    /// It seek for a character sequence that indicates the start of 
+	    /// a binary block
+	    /// char sequence is 255 255 255 0 
+	    virtual size_t findBinaryBlockStart();
+
+        /// search for all tokesn and find the first word token tbat matchs w
         virtual bool findToken( const word & w );
 
         /// search for all tokesn after the current file position 
@@ -144,69 +154,69 @@ public:
         virtual bool findTokenResume(const word& w);
 
 
-        // - search for all tokesn and find the first word token that matchs 
+        /// search for all tokesn and find the first word token that matchs 
         virtual bool findTokenSilent( const word & w, int32 limitLine = 100 );
 
         /// search for all tokesn after the current file position 
         /// and find the first word token tbat matchs w
         virtual bool findTokenResumeSilent( const word & w, int32 limitLine = 100 );
 
-        // - search for all tokens and find the first word token and also next word token
-        //   chekck if it is eneded with end statement ;
+        /// search for all tokens and find the first word token and also next word token
+        /// chekck if it is eneded with end statement ;
         virtual bool findTokenAndNext( const word& w, word& nextW, bool checkEndStatement = true);
 
 
         virtual bool findTokenAndNextSilent( const word& w, word& nextW, int32 limitLine = 100);
 
-        // - find a pair of keyword and data terminated by ;
-        //   keyword data;
-        //   return false if keyword does not exist or reading fails. 
+        /// find a pair of keyword and data terminated by ;
+        ///  keyword data;
+        ///  return false if keyword does not exist or reading fails. 
         template<typename T>
         bool findKeywordAndVal(const word& keyword, T& val, bool checkEndStatement = true);
 
-        // - lookup for keyword and data;
-        //   fatalExit if fails
+        /// lookup for keyword and data;
+        ///  fatalExit if fails
         template<typename T>
         T lookupData(const word& keyword);
 
-        // - lookup for keyword and data;
-        //   set to setVal if lookup fails. 
+        /// lookup for keyword and data;
+        ///  set to setVal if lookup fails. 
         template<typename T>
         T lookupDataOrSet(const word& keyword, const T& setVal);
         
-        // - read the data next to keword 
-        //   keyword    data; 
-        //   check the keyword is correct or not 
+        /// read the data next to keword 
+        /// keyword    data; 
+        /// check the keyword is correct or not 
         template<typename T>
         bool nextData(const word& keyword, T& data);
 
 	//// Read List punctuation tokens
 
-	    //- Begin read of data chunk, starts with '('.
-	    //  return true or FatalIOError
+	    /// Begin read of data chunk, starts with '('.
+	    /// return true or FatalIOError
 	    bool readBegin(const char* funcName);
 
-	    //- End read of data chunk, ends with ')'
-	    //  return true or FatalIOError
+	    /// End read of data chunk, ends with ')'
+	    /// return true or FatalIOError
 	    bool readEnd(const char* funcName);
 
-	    //- Begin read of data chunk, starts with '('.
-	    //  return true or FatalIOError
+	    /// Begin read of data chunk, starts with '('.
+	    /// return true or FatalIOError
 	    bool readBeginSquare(const char* funcName);
 
-	    //- Begin read of data chunk, starts with '('.
-	    //  return true or FatalIOError
+	    /// Begin read of data chunk, starts with '('.
+	    /// return true or FatalIOError
 	    bool readEndSquare(const char* funcName);
 
-	    //- Begin read of list data, starts with '(' or '{'
-	    //  return starting delimiter or FatalIOError
+	    /// Begin read of list data, starts with '(' or '{'
+	    /// return starting delimiter or FatalIOError
 	    char readBeginList(const char* funcName);
 
-	    //- End read of list data, ends with ')' or '}'
-	    //  return closing delimiter or FatalIOError
+	    /// End read of list data, ends with ')' or '}'
+	    /// return closing delimiter or FatalIOError
 	    char readEndList(const char* funcName);
 
-	    // End statement character ;
+	    /// End statement character ;
 	    char readEndStatement(const char* funcName);
 
     	
@@ -217,13 +227,13 @@ public:
 
 typedef iIstream& (*iIstreamManip)(iIstream&);
 
-//- operator>> handling for manipulators without arguments
+/// operator>> handling for manipulators without arguments
 inline iIstream& operator>>(iIstream& is, iIstreamManip f)
 {
     return f(is);
 }
 
-//- operator>> handling for manipulators without arguments
+/// operator>> handling for manipulators without arguments
 inline iIstream& operator>>(iIstream& is, IOstreamManip f)
 {
     f(is);
@@ -231,24 +241,20 @@ inline iIstream& operator>>(iIstream& is, IOstreamManip f)
 }
 
 
-// read operation for basic types it gets from the 
-// token stream
-
+// read operation for basic types it gets from the token stream
 inline iIstream& operator>>( iIstream& is, word & w);
 
 inline iIstream& operator>>( iIstream& is, int64& val);
 
 inline iIstream& operator>>( iIstream& is, int32& val);
 
-inline iIstream& operator>>( iIstream& is, int16& val);
-
 inline iIstream& operator>>( iIstream& is, int8& val);
 
+inline iIstream& operator>>( iIstream& is, uint64& val);
+
 inline iIstream& operator>>( iIstream& is, uint32& val);
 
-inline iIstream& operator>>( iIstream& is, uint16& val);
-
-inline iIstream& operator>>( iIstream& is, label& val);
+inline iIstream& operator>>( iIstream& is, uint8& val);
 
 inline iIstream& operator>>( iIstream& is, float& val);
 
@@ -262,4 +268,4 @@ inline iIstream& operator>>( iIstream& is, double& val);
 #include "iIstreamI.hpp"
 
 
-#endif
+#endif //__iIstream_hpp__
diff --git a/src/phasicFlow/streams/iStream/iIstreamI.hpp b/src/phasicFlow/streams/iStream/iIstreamI.hpp
index f8cea3d3..9ddb739a 100755
--- a/src/phasicFlow/streams/iStream/iIstreamI.hpp
+++ b/src/phasicFlow/streams/iStream/iIstreamI.hpp
@@ -200,13 +200,6 @@ inline pFlow::iIstream& pFlow::operator>>( iIstream& is, int32& val)
     return is;
 }
 
-inline pFlow::iIstream& pFlow::operator>>( iIstream& is, int16& val)
-{
-    int64 lval(0);
-    is>>lval;
-    val = static_cast<int16>(lval);
-    return is;
-}
 
 inline pFlow::iIstream& pFlow::operator>>( iIstream& is, int8& val)
 {
@@ -216,11 +209,11 @@ inline pFlow::iIstream& pFlow::operator>>( iIstream& is, int8& val)
     return is;
 }
 
-inline pFlow::iIstream& pFlow::operator>>( iIstream& is, label& val)
+inline pFlow::iIstream& pFlow::operator>>( iIstream& is, uint64& val)
 {
     int64 lval(0);
     is>>lval;
-    val = static_cast<label>(lval);
+    val = static_cast<uint64>(lval);
     return is;
 }
 
@@ -232,11 +225,11 @@ inline pFlow::iIstream& pFlow::operator>>( iIstream& is, uint32& val)
     return is;
 }
 
-inline pFlow::iIstream& pFlow::operator>>( iIstream& is, uint16& val)
+inline pFlow::iIstream& pFlow::operator>>( iIstream& is, uint8& val)
 {
     int64 lval(0);
     is>>lval;
-    val = static_cast<uint16>(lval);
+    val = static_cast<uint8>(lval);
     return is;
 }
 
diff --git a/src/phasicFlow/streams/iStream/iOstream.cpp b/src/phasicFlow/streams/iStream/iOstream.cpp
index 622ff494..dfe82685 100644
--- a/src/phasicFlow/streams/iStream/iOstream.cpp
+++ b/src/phasicFlow/streams/iStream/iOstream.cpp
@@ -21,9 +21,16 @@ Licence:
 
 #include "iOstream.hpp"
 #include "token.hpp"
+#include "error.hpp"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+pFlow::iOstream& pFlow::iOstream::writeBinaryBlockFlag()
+{
+    notImplementedFunction;
+    return *this;
+}
+
 void pFlow::iOstream::decrIndent()
 {
     if (!indentLevel_)
diff --git a/src/phasicFlow/streams/iStream/iOstream.hpp b/src/phasicFlow/streams/iStream/iOstream.hpp
index 6c083a9b..11b73674 100644
--- a/src/phasicFlow/streams/iStream/iOstream.hpp
+++ b/src/phasicFlow/streams/iStream/iOstream.hpp
@@ -17,17 +17,13 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
-
 #ifndef __iOstream_hpp__
 #define __iOstream_hpp__
 
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
 
 #include "IOstream.hpp"
 
+/// char constants to alter output format and color 
 const inline char* defaultColor = "\033[0m";
 const inline char* blackColor   = "\033[30m";
 const inline char* redColor     = "\033[31m";
@@ -40,7 +36,13 @@ const inline char* whiteColor   = "\033[37m";
 
 const inline char* boldChar     = "\033[1m";
 
-
+#define Red_Text(text)      redColor<<text<<defaultColor
+#define Yellow_Text(text)   yellowColor<<text<<defaultColor
+#define Blue_Text(text)     blueColor<<text<<defaultColor
+#define Green_Text(text)    greenColor<<text<<defaultColor
+#define Magenta_Text(text)  magentaColor<<text<<defaultColor
+#define Cyan_Text(text)         cyanColor<<text<<defaultColor
+#define Bold_Text(text)         boldChar<<text<<defaultColor
 
 namespace pFlow
 {
@@ -48,15 +50,19 @@ namespace pFlow
 // Forward Declarations
 class token;
 
-
-
+/**
+ * Interface class for any output stream. 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs
+ * 
+ */
 class iOstream
 :
     public IOstream
 {
 protected:
 
-    // Protected Data
+    //- Protected Data
 
         /// Indentation of the entry from the start of the keyword
         static constexpr const unsigned short entryIndentation_ = 16;
@@ -71,7 +77,7 @@ protected:
 public:
     
 
-    // Constructors
+    ////- Constructors
 
         /// Default
         explicit iOstream()
@@ -89,7 +95,7 @@ public:
         virtual ~iOstream() = default;
 
 
-    /// Write Functions
+    ////- Write Functions
 
         /// Write token to stream or otherwise handle it.
         /// return false if the token type was not handled by this method
@@ -118,14 +124,17 @@ public:
         /// Write int32
         virtual iOstream& write(const int32 val) = 0;
 
-        /// Write label
-        virtual iOstream& write(const label val) = 0;
+        /// Write int8
+        virtual iOstream& write(const int8 val) = 0;
+
+        /// Write uint64
+        virtual iOstream& write(const uint64 val) = 0;
 
         /// Write uint32
         virtual iOstream& write(const uint32 val) = 0;
 
-        /// Write uint16
-        virtual iOstream& write(const uint16 val) = 0;
+        /// Write uint8
+        virtual iOstream& write(const uint8 val) = 0;
 
         /// Write float
         virtual iOstream& write(const float val) = 0;
@@ -133,11 +142,17 @@ public:
         /// Write double
         virtual iOstream& write(const double val) = 0;
        
+        /// Write size_t
+        virtual iOstream& write(const size_t val) = 0;
+         
         /// Write a block of binray data 
         virtual iOstream& write(const char* binaryData, std::streamsize count) = 0;
+
+        /// Write the flag to indicate the start of a binary block
+        virtual iOstream& writeBinaryBlockFlag();
         
-    
-    // - Indent 
+        virtual void seek(size_t pos) = 0;
+    //// - Indent 
 
         /// Add indentation characters
         virtual void indent() = 0;
@@ -175,7 +190,7 @@ public:
         /// Decrement the indent level
         void decrIndent();
 
-    //- Punctuations
+    ////- Punctuations
     
         /// Write begin block group with a name
         ///  Increments indentation, adds newline.
@@ -228,7 +243,13 @@ public:
         }
 
 
-    //- Stream state functions
+    ////- Stream state functions
+
+        /// Add a new line and flush stream 
+        virtual void startOfBinaryStreaming() =0;
+
+        /// Reach end of file add a new line and flush stream 
+        virtual void endOfBinaryStreaming() = 0 ;
 
         /// Flush stream
         virtual void flush() = 0;
@@ -255,7 +276,7 @@ public:
         virtual int precision(const int p) = 0;
 
 
-    //- Member Operators
+    ////- Member Operators
 
         /// Return a non-const reference to const iOstream
         /// Needed for write functions where the stream argument is temporary:
@@ -377,17 +398,13 @@ inline iOstream& operator<<( iOstream& os, const int32& val)
     return os.write(val);
 }
 
-inline iOstream& operator<<( iOstream& os, const int16& val)
-{
-    return os.write(val);
-}
 
 inline iOstream& operator<<( iOstream& os, const int8& val)
 {
     return os.write(val);
 }
 
-inline iOstream& operator<<( iOstream& os, const label& val)
+inline iOstream& operator<<( iOstream& os, const uint64& val)
 {
     return os.write(val);
 }
@@ -397,7 +414,7 @@ inline iOstream& operator<<( iOstream& os, const uint32& val)
     return os.write(val);
 }
 
-inline iOstream& operator<<( iOstream& os, const uint16& val)
+inline iOstream& operator<<( iOstream& os, const uint8& val)
 {
     return os.write(val);
 }
@@ -412,16 +429,19 @@ inline iOstream& operator<<( iOstream& os, const double& val)
 {
     return os.write(val);
 }
+
+inline iOstream& operator<<( iOstream& os, const size_t& val)
+{
+    return os.write(val);
+}
+
 // Useful aliases for tab and newline characters
 constexpr char tab = '\t';
 constexpr char nl = '\n';
 
 
-
-
 } //  pFlow
 
 
 #endif
 
-// ************************************************************************* //
diff --git a/src/phasicFlow/streams/masterOstream/masterOstream.cpp b/src/phasicFlow/streams/masterOstream/masterOstream.cpp
new file mode 100755
index 00000000..24d0931a
--- /dev/null
+++ b/src/phasicFlow/streams/masterOstream/masterOstream.cpp
@@ -0,0 +1,187 @@
+/*------------------------------- 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 "masterOstream.hpp"
+#include "token.hpp"
+
+
+pFlow::masterOstream::masterOstream
+(
+    std::ostream& os,
+    const word& streamName
+)
+:
+    Ostream(os, streamName, writeFormat::ASCII)
+{}
+
+
+pFlow::iOstream& pFlow::masterOstream::write(const char c)
+{
+    if(showOutput())
+    {
+        Ostream::write(c);
+    }
+    return *this;
+}
+
+
+pFlow::iOstream& pFlow::masterOstream::write(const char* str)
+{
+    if(showOutput())
+    {
+        Ostream::write(str);
+    }
+    return *this;
+}
+
+
+pFlow::iOstream& pFlow::masterOstream::write(const word& str)
+{
+    if(showOutput())
+    {
+        Ostream::write(str);
+    }
+    return *this;
+}
+
+
+pFlow::iOstream& pFlow::masterOstream::writeQuoted
+(
+    const word& str,
+    const bool quoted
+)
+{
+    if(showOutput())
+    {
+        Ostream::writeQuoted(str, quoted);
+    }
+    return *this;
+}
+
+
+
+pFlow::iOstream& pFlow::masterOstream::write(const int64 val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this;   
+}
+
+
+pFlow::iOstream& pFlow::masterOstream::write(const int32 val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+
+pFlow::iOstream& pFlow::masterOstream::write(const int8 val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+pFlow::iOstream& pFlow::masterOstream::write(const uint64 val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+pFlow::iOstream& pFlow::masterOstream::write(const uint32 val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+pFlow::iOstream& pFlow::masterOstream::write(const uint8 val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+pFlow::iOstream& pFlow::masterOstream::write(const float val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+
+pFlow::iOstream& pFlow::masterOstream::write(const double val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+pFlow::iOstream& pFlow::masterOstream::write(const size_t val)
+{
+    if(showOutput())
+    {
+        Ostream::write(val);
+    }
+    return *this; 
+}
+
+
+pFlow::iOstream& pFlow::masterOstream::write
+(
+    const char* binaryData, 
+    std::streamsize count
+)
+{
+    if(showOutput())
+    {
+        Ostream::write(binaryData, count);
+    }
+    return *this; 
+}
+
+
+void pFlow::masterOstream::indent()
+{
+    
+    if(showOutput())
+    {
+        Ostream::indent();
+    }    
+}
\ No newline at end of file
diff --git a/src/phasicFlow/streams/masterOstream/masterOstream.hpp b/src/phasicFlow/streams/masterOstream/masterOstream.hpp
new file mode 100755
index 00000000..60931ea4
--- /dev/null
+++ b/src/phasicFlow/streams/masterOstream/masterOstream.hpp
@@ -0,0 +1,135 @@
+/*------------------------------- 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 __masterOstream_hpp__
+#define __masterOstream_hpp__
+
+#include "Ostream.hpp"
+
+namespace pFlow
+{
+
+/**
+ * Output stream for MPI parallel run, when we need to 
+ * know which the processor number in the output line. 
+ * The processor number is shown as a prefix for the output line. 
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs.
+ */
+class masterOstream
+:
+    public Ostream
+{
+protected:
+
+    /// Print prefix?
+    bool isThisMaster_	= true;
+
+    
+    inline bool showOutput() const
+    {
+        return isThisMaster_;
+    }
+
+public:
+
+    //// - Constructors
+        
+        /// From components 
+        masterOstream(std::ostream& os, const word& streamName);
+
+        /// No copy construct 
+        masterOstream(const masterOstream&) = delete;
+
+        /// No copy assignment
+        void operator=(const masterOstream&) = delete;
+
+
+
+    //// - Methods
+        /// Set if this processor is slave or master 
+        void setMasterSlave(bool master)
+        {
+            isThisMaster_ = master;
+        }
+
+        /// Write token to stream or otherwise handle it.
+        /// return false if the token type was not handled by this method
+        bool write(const token& tok)
+        // to prevent compiler warning, this method is overriden agian 
+        {
+            return Ostream::write(tok);
+        }
+
+        /// Write character
+        iOstream& write(const char c)override;
+
+        /// Write character string
+        iOstream& write(const char* str)override;
+
+        /// Write word
+        iOstream& write(const word& str)override;
+    
+        /// Write std::string surrounded by quotes.
+        //  Optional write without quotes.
+        iOstream& writeQuoted ( const word& str, const bool quoted=true ) override;
+
+        /// Write int64
+        iOstream& write(const int64 val) override;
+
+        /// Write int32
+        iOstream& write(const int32 val) override;
+
+        /// Write int32
+        iOstream& write(const int8 val) override;
+
+        /// Write uint64
+        iOstream& write(const uint64 val) override;
+
+        /// Write uint32
+        iOstream& write(const uint32 val) override;
+
+        /// Write uint8
+        iOstream& write(const uint8 val) override;
+
+        /// Write float
+        iOstream& write(const float val) override;
+
+        /// Write double
+        iOstream& write(const double val) override;
+
+        /// Write double
+        iOstream& write(const size_t val) override;
+        
+        /// Write a block of binray data 
+        iOstream& write(const char* binaryData, std::streamsize count) override;
+
+        /// Add indentation characters
+        void indent() override;
+
+
+}; // masterOstream
+
+
+
+} // pFlow
+
+
+#endif // __masterOstream_hpp__
diff --git a/src/phasicFlow/streams/processorOstream/processorOstream.cpp b/src/phasicFlow/streams/processorOstream/processorOstream.cpp
new file mode 100755
index 00000000..b91950cd
--- /dev/null
+++ b/src/phasicFlow/streams/processorOstream/processorOstream.cpp
@@ -0,0 +1,158 @@
+/*------------------------------- 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 <cstring>
+
+#include "processorOstream.hpp"
+#include "token.hpp"
+
+
+pFlow::processorOstream::processorOstream
+(
+    std::ostream& os,
+    const word& streamName
+)
+:
+    Ostream(os, streamName, writeFormat::ASCII)
+{}
+
+
+pFlow::iOstream& pFlow::processorOstream::write(const char c)
+{
+    checkForPrefix();
+    Ostream::write(c);
+
+    if (c == token::NL)
+    {
+        printPrefix_ = true;
+    }
+
+    return *this;
+
+}
+
+
+pFlow::iOstream& pFlow::processorOstream::write(const char* str)
+{
+    checkForPrefix();
+    Ostream::write(str);
+
+    size_t len = std::strlen(str);
+    if (len && str[len-1] == token::NL)
+    {
+        printPrefix_ = true;
+    }
+
+    return *this;
+}
+
+
+pFlow::iOstream& pFlow::processorOstream::write(const word& str)
+{
+    checkForPrefix();
+    return Ostream::write(str);
+}
+
+
+pFlow::iOstream& pFlow::processorOstream::writeQuoted
+(
+    const word& str,
+    const bool quoted
+)
+{
+    checkForPrefix();
+    return Ostream::writeQuoted(str, quoted);
+}
+
+
+
+pFlow::iOstream& pFlow::processorOstream::write(const int64 val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+
+pFlow::iOstream& pFlow::processorOstream::write(const int32 val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+
+pFlow::iOstream& pFlow::processorOstream::write(const int8 val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+pFlow::iOstream& pFlow::processorOstream::write(const uint64 val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+pFlow::iOstream& pFlow::processorOstream::write(const uint32 val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+pFlow::iOstream& pFlow::processorOstream::write(const uint8 val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+pFlow::iOstream& pFlow::processorOstream::write(const float val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+
+pFlow::iOstream& pFlow::processorOstream::write(const double val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+pFlow::iOstream& pFlow::processorOstream::write(const size_t val)
+{
+    checkForPrefix();
+    return Ostream::write(val);
+}
+
+pFlow::iOstream& pFlow::processorOstream::write
+(
+    const char* binaryData, 
+    std::streamsize count
+)
+{
+    checkForPrefix();
+    return Ostream::write(binaryData, count);
+}
+
+
+void pFlow::processorOstream::indent()
+{
+    checkForPrefix();
+    Ostream::indent();
+}
diff --git a/src/phasicFlow/streams/processorOstream/processorOstream.hpp b/src/phasicFlow/streams/processorOstream/processorOstream.hpp
new file mode 100755
index 00000000..d448f082
--- /dev/null
+++ b/src/phasicFlow/streams/processorOstream/processorOstream.hpp
@@ -0,0 +1,150 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+#ifndef __processorOstream_hpp__
+#define __processorOstream_hpp__
+
+#include "Ostream.hpp"
+
+namespace pFlow
+{
+
+/**
+ * Output stream for MPI parallel run, when we need to 
+ * know which the processor number in the output line. 
+ * The processor number is shown as a prefix for the output line. 
+ * 
+ * It is based on OpenFOAM stream, with some modifications/simplifications
+ * to be tailored to our needs.
+ */
+class processorOstream
+:
+    public Ostream
+{
+protected:
+
+    /// Print prefix?
+    bool printPrefix_	= false;
+
+    /// Prefix word  
+    word prefix_ 		= "";
+
+    /// Output the prefix if required. 
+    inline
+    void checkForPrefix()
+    {
+    	if(printPrefix_ && prefix_.size())
+    	{
+    		Ostream::write(prefix_.c_str());
+    		printPrefix_ = false;
+    	}
+    }
+
+public:
+
+    //// - Constructors
+        
+        /// From components 
+        processorOstream(std::ostream& os, const word& streamName);
+
+        /// No copy construct 
+        processorOstream(const processorOstream&) = delete;
+
+        /// No copy assignment
+        void operator=(const processorOstream&) = delete;
+
+
+    //// - Methods
+
+        /// Set processor number to be used in the prefix. 
+        word setPrefixNum(int procNum)
+        {
+            prefix_ = word("[")+int322Word(procNum)+word("] ");
+            return prefix_;
+        }
+
+        /// Activate prefix for this stream.
+        void activatePrefix()
+        {
+            printPrefix_ = true;
+        }
+        
+        /// Write token to stream or otherwise handle it.
+        /// return false if the token type was not handled by this method
+        bool write(const token& tok)
+        // to prevent compiler warning, this method is overriden agian 
+        {
+            return Ostream::write(tok);
+        }
+
+        /// Write character
+        iOstream& write(const char c)override;
+
+        /// Write character string
+        iOstream& write(const char* str)override;
+
+        /// Write word
+        iOstream& write(const word& str)override;
+    
+        /// Write std::string surrounded by quotes.
+        //  Optional write without quotes.
+        iOstream& writeQuoted ( const word& str, const bool quoted=true ) override;
+
+        /// Write int64
+        iOstream& write(const int64 val) override;
+
+        /// Write int32
+        iOstream& write(const int32 val) override;
+
+        /// Write int32
+        iOstream& write(const int8 val) override;
+
+        /// Write uint64
+        iOstream& write(const uint64 val) override;
+
+        /// Write uint32
+        iOstream& write(const uint32 val) override;
+
+        /// Write uint8
+        iOstream& write(const uint8 val) override;
+
+        /// Write float
+        iOstream& write(const float val) override;
+
+        /// Write double
+        iOstream& write(const double val) override;
+
+        /// Write double
+        iOstream& write(const size_t val) override;
+        
+        /// Write a block of binray data 
+        iOstream& write(const char* binaryData, std::streamsize count) override;
+
+        /// Add indentation characters
+        void indent() override;
+
+
+}; // processorOstream
+
+
+
+} // pFlow
+
+
+#endif // __processorOstream_hpp__
diff --git a/src/phasicFlow/streams/streams.cpp b/src/phasicFlow/streams/streams.cpp
index 337b7e81..12ad3690 100755
--- a/src/phasicFlow/streams/streams.cpp
+++ b/src/phasicFlow/streams/streams.cpp
@@ -3,6 +3,11 @@
 
 pFlow::Ostream pFlow::output(std::cout, "pFlow Ostream");
 
+pFlow::masterOstream pFlow::mOutput(cout, "pFlow masterOstream");
+
+pFlow::processorOstream pFlow::pOutput(cout, "pFlow processorOstream");
+
 pFlow::Istream pFlow::input( std::cin, "sFlow Istream"); 
 
-pFlow::Ostream pFlow::errReport( std::cerr, "pFlow error report stream");
+pFlow::masterOstream pFlow::errReport( std::cerr, "pFlow error report stream");
+
diff --git a/src/phasicFlow/streams/streams.hpp b/src/phasicFlow/streams/streams.hpp
index de60dc6f..683bba58 100755
--- a/src/phasicFlow/streams/streams.hpp
+++ b/src/phasicFlow/streams/streams.hpp
@@ -13,38 +13,37 @@
 
 #include "iTstream.hpp"
 
+#include "processorOstream.hpp"
+
+#include "masterOstream.hpp"
+
 namespace pFlow
 {
 
-
 	extern Ostream output;
 
+	extern masterOstream mOutput;
+
+	extern processorOstream pOutput;
+
 	extern Istream input; 
 
-	extern Ostream errReport;
-
+	extern masterOstream errReport;
 
 }
 
-#define redText(text)     	redColor<<text<<defaultColor
-#define yellowText(text)  	yellowColor<<text<<defaultColor
-#define blueText(text)    	blueColor<<text<<defaultColor
-#define greenText(text)   	greenColor<<text<<defaultColor
-#define magentaText(text) 	magentaColor<<text<<defaultColor
-#define cyanText(text) 		cyanColor<<text<<defaultColor
-#define boldText(text) 		boldChar<<text<<defaultColor
 
-#define INFORMATION pFlow::output<<boldChar<<magentaColor<<"> INFO: "<<defaultColor<<magentaColor
-#define endINFO defaultColor<<pFlow::nl
+#define INFORMATION pFlow::mOutput<<boldChar<<magentaColor<<"> INFO: "<<defaultColor<<magentaColor
+#define END_INFO defaultColor<<pFlow::endl
 
-#define REPORT(n) pFlow::output.space(2*n)
-#define endREPORT pFlow::nl
+#define REPORT(n) pFlow::mOutput.space(2*n)
+#define END_REPORT pFlow::endl
 
 
-#define yWARNING pFlow::output<<boldChar<<yellowColor<<"> WARNING\n"<<defaultColor<<yellowColor<<"  " 
-#define endyWARNING defaultColor<<pFlow::nl
+#define WARNING pFlow::errReport<<boldChar<<yellowColor<<"> WARNING\n"<<defaultColor<<yellowColor<<"  " 
+#define END_WARNING defaultColor<<pFlow::endl
 
-#define ERR pFlow::output<<boldChar<<redColor<<"> ERROR\n"<<defaultColor<<redColor<<"  " 
-#define endERR defaultColor<<pFlow::nl
+#define ERR pFlow::errReport<<boldChar<<redColor<<"> ERROR\n"<<defaultColor<<redColor<<"  " 
+#define END_ERR defaultColor<<pFlow::endl
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/streams/token/token.hpp b/src/phasicFlow/streams/token/token.hpp
index 5dd3ebaa..c0ba324f 100755
--- a/src/phasicFlow/streams/token/token.hpp
+++ b/src/phasicFlow/streams/token/token.hpp
@@ -17,95 +17,97 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-// based on OpenFOAM stream, with some modifications/simplifications
-// to be tailored to our needs
-
-
 #ifndef __token_hpp__
 #define __token_hpp__
 
 
 #include "bTypes.hpp"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 
 namespace pFlow
 {
 
-// Forward Declarations
+/// Forward Declarations
 class token;
 class iIstream;
 class iOstream;
+
 iOstream& operator<<(iOstream& os, const token& tok);
 
 
+/**
+ *  Token class 
+ *  based on OpenFOAM stream, with some modifications/simplifications
+ *  to be tailored to our needs 
+ */
 class token
 {
 public:
 
-    //- Enumeration defining the types of token.
-    //  Since these values are also used to tag content in Pstream,
-    //  the maximum number of types is limited to 30.
+    /// Enumeration defining the types of token.
+    /// Since these values are also used to tag content in Pstream,
+    /// the maximum number of types is limited to 30.
     enum tokenType
     {
         UNDEFINED = 0,    //!< An undefined token-type
 
         // Fundamental types
-        FLAG,             //!< stream flag (1-byte bitmask)
-        PUNCTUATION,      //!< single character punctuation
-        BOOL,             //!< boolean type
-        INT64,             //!< int64 (integer) type
-        FLOAT,            //!< float (single-precision) type
-        DOUBLE,           //!< double (double-precision) type
+        FLAG,             /// stream flag (1-byte bitmask)
+        PUNCTUATION,      /// single character punctuation
+        BOOL,             /// boolean type
+        INT64,            /// int64 (integer) type
+        FLOAT,            /// float (single-precision) type
+        DOUBLE,           /// double (double-precision) type
 
         // Pointer types
-        WORD,             //!< A pFlow::word
-        STRING, 		  //!< A string whth double quuote
-        DIRECTIVE,        //!< A dictionary \c \#directive (word variant)
-        VARIABLE,         //!< A dictionary \c \$variable (string variant)
+        WORD,             /// A pFlow::word
+        STRING, 		  /// A string whth double quuote
+        DIRECTIVE,        /// A dictionary \c \#directive (word variant)
+        VARIABLE,         /// A dictionary \c \$variable (string variant)
 
-        ERROR,            //!< A token error encountered
+        ERROR,            /// A token error encountered
     };
 
 
-    //**************- Stream or output control flags (1-byte width)
+    /// Stream or output control flags (1-byte width)
     enum flagType
     {
-        NO_FLAG = 0,   //!< No flags
-        ASCII   = 1,   //!< ASCII-mode stream
-        BINARY  = 2    //!< BINARY-mode stream
+        NO_FLAG = 0,   /// No flags
+        ASCII   = 1,   /// ASCII-mode stream
+        BINARY  = 2    /// BINARY-mode stream
     };
 
 
-    //- Standard punctuation tokens (a character)
+    /// Standard punctuation tokens (a character)
     enum punctuationToken : char
     {
-        NULL_TOKEN     = '\0',  //!< Nul character
-        SPACE          = ' ',   //!< Space [isspace]
-        TAB            = '\t',  //!< Tab [isspace]
-        NL             = '\n',  //!< Newline [isspace]
+        NULL_TOKEN     = '\0',  /// Nul character
+        SPACE          = ' ',   /// Space [isspace]
+        TAB            = '\t',  /// Tab [isspace]
+        NL             = '\n',  /// Newline [isspace]
 
-        END_STATEMENT  = ';',   //!< End entry [#isseparator]
-        BEGIN_LIST     = '(',   //!< Begin list [#isseparator]
-        END_LIST       = ')',   //!< End list [#isseparator]
-        BEGIN_SQR      = '[',   //!< Begin dimensions [#isseparator]
-        END_SQR        = ']',   //!< End dimensions [#isseparator]
-        BEGIN_BLOCK    = '{',   //!< Begin block [#isseparator]
-        END_BLOCK      = '}',   //!< End block [#isseparator]
-        COLON          = ':',   //!< Colon [#isseparator]
-        COMMA          = ',',   //!< Comma [#isseparator]
-        DOLLAR         = '$',   //!< Dollar - start variable
-        SQUOTE         = '\'',  //!< Single quote
-        DQUOTE         = '"',   //!< Double quote
+        END_STATEMENT  = ';',   /// End entry [#isseparator]
+        BEGIN_LIST     = '(',   /// Begin list [#isseparator]
+        END_LIST       = ')',   /// End list [#isseparator]
+        BEGIN_SQR      = '[',   /// Begin dimensions [#isseparator]
+        END_SQR        = ']',   /// End dimensions [#isseparator]
+        BEGIN_BLOCK    = '{',   /// Begin block [#isseparator]
+        END_BLOCK      = '}',   /// End block [#isseparator]
+        COLON          = ':',   /// Colon [#isseparator]
+        COMMA          = ',',   /// Comma [#isseparator]
+        DOLLAR         = '$',   /// Dollar - start variable
+        SQUOTE         = '\'',  /// Single quote
+        DQUOTE         = '"',   /// Double quote
 
-        SUBTRACT       = '-',   //!< Subtract or start of negative number
-        DIVIDE         = '/',   //!< Divide [#isseparator]
+        SUBTRACT       = '-',   /// Subtract or start of negative number
+        DIVIDE         = '/',   /// Divide [#isseparator]
 
-        BEGIN_STRING   = DQUOTE, //!< Begin string with double quote
-        END_STRING     = DQUOTE  //!< End string with double quote
+        BEGIN_STRING   = DQUOTE, /// Begin string with double quote
+        END_STRING     = DQUOTE  /// End string with double quote
     };
 
-    //- An undefined token
+    /// An undefined token
     static const inline token undefinedToken();
 
     static token endList()
@@ -155,7 +157,7 @@ public:
 
 private:
 
-    //- A %union of token types
+    /// A %union of token types
     union content
     {
         // Fundamental values. Largest first for any {} initialization.
@@ -172,279 +174,285 @@ private:
     };
 
 
-    // Private Data
+    //// -  Private Data
 
-    //- The data content (as a union).
+    /// The data content (as a union).
     //  For memory alignment this should appear as the first member.
     content data_;
 
-    //- The token type
+    /// The token type
     tokenType type_;
 
-    //- Line number in the file the token was read from
+    /// Line number in the file the token was read from
     int32 lineNumber_;
 
 
     // Private Member Functions
 
-    //- Set as UNDEFINED and zero the union content without any checking
+    /// Set as UNDEFINED and zero the union content without any checking
     inline void setUndefined();
 
-    // Parse error, expected 'expected', found ...
+    /// Parse error, expected 'expected', found ...
     void parseError(const char* expected) const;
 
 
 public:
 
-    // Static Data Members
 
-    // Constructors
+    //// - Constructors
 
-    //- Default construct, initialized to an UNDEFINED token.
-    inline constexpr token() noexcept;
+        /// Default construct, initialized to an UNDEFINED token.
+        inline constexpr token() noexcept;
 
-    //- Copy construct
-    inline token(const token& t);
+        /// Copy construct
+        inline token(const token& t);
 
-    //- Move construct. The original token is left as UNDEFINED.
-    inline token(token&& t);
+        /// Move construct. The original token is left as UNDEFINED.
+        inline token(token&& t);
 
-    //- Construct punctuation character token
-    inline explicit token(punctuationToken p, int32 lineNumber=0);
+        /// Construct punctuation character token
+        inline explicit token(punctuationToken p, int32 lineNumber=0);
 
-    //- Construct label token
-    inline explicit token(const label val, int32 lineNumber=0);
+        /// Construct int64 token
+        inline explicit token(const uint64 val, int32 lineNumber=0);
 
-    //- Construct uint32 token
-    inline explicit token(const uint32 val, int32 lineNumber=0);
+        /// Construct int64 token
+        inline explicit token(const uint32 val, int32 lineNumber=0);
 
-    //- Construct int64 token
-    inline explicit token(const int64 val, int32 lineNumber=0);
+        /// Construct int8 token
+        inline explicit token(const uint8 val, int32 lineNumber=0);
 
-    //- Construct int64 token
-    inline explicit token(const int32 val, int32 lineNumber=0);
+        /// Construct int64 token
+        inline explicit token(const int64 val, int32 lineNumber=0);
 
-    //- Construct float token
-    inline explicit token(const float val, int32 lineNumber=0);
+        /// Construct int64 token
+        inline explicit token(const int32 val, int32 lineNumber=0);
 
-    //- Construct double token
-    inline explicit token(const double val, int32 lineNumber=0);
+        /// Construct int64 token
+        inline explicit token(const int8 val, int32 lineNumber=0);
 
-    //- Copy construct word & string token
-    inline explicit token(const word& w, int32 lineNumber=0, bool isString = false);
+        /// Construct float token
+        inline explicit token(const float val, int32 lineNumber=0);
+
+        /// Construct double token
+        inline explicit token(const double val, int32 lineNumber=0);
+
+        /// Copy construct word & string token
+        inline explicit token(const word& w, int32 lineNumber=0, bool isString = false);
 
 
-    //- Move construct word & string token
-    inline explicit token(word&& w, int32 lineNumber=0, bool isString = false);
+        /// Move construct word & string token
+        inline explicit token(word&& w, int32 lineNumber=0, bool isString = false);
 
-    //- Construct from iIstream
-    explicit token(iIstream& is);
+        /// Construct from iIstream
+        explicit token(iIstream& is);
 
 
-    //- Destructor
-    inline ~token();
+        /// Destructor
+        inline ~token();
 
 
-    // Static Functions
+    //// - Static Functions
 
-        //- Create a bool token.
+        /// Create a bool token.
         inline static token boolean(bool on);
 
-        //- Create a token with stream flags, no sanity check
-        //
-        //  \param bitmask the flags to set
+        /// Create a token with stream flags, no sanity check
+        ///
+        ///  \param bitmask the flags to set
         inline static token flag(int bitmask);
 
-        //- True if the character is a punctuation separator (eg, in ISstream).
-        //  Since it could also start a number, SUBTRACT is not included as
-        //  a separator.
-        //
-        //  \param c the character to test, passed as int for consistency with
-        //      isdigit, isspace etc.
+        /// True if the character is a punctuation separator (eg, in ISstream).
+        ///  Since it could also start a number, SUBTRACT is not included as
+        ///  a separator.
+        ///
+        ///  \param c the character to test, passed as int for consistency with
+        ///      isdigit, isspace etc.
         inline static bool isseparator(int c);
 
 
-    // Member Functions
+    //// - Member Functions
 
-    // Status
+    // - Status
 
-        //- Return the name of the token type
+        /// Return the name of the token type
         word name() const;
 
-        //- Return the token type
+        /// Return the token type
         inline tokenType type() const;
 
-        //- Change the token type, for similar types.
-        //  This can be used to change between string-like variants
-        //  (eg, STRING, VARIABLE, etc)
-        //  To change types entirely (eg, STRING to DOUBLE),
-        //  use the corresponding assignment operator.
-        //
-        //  \return true if the change was successful or no change was required
+        /// Change the token type, for similar types.
+        ///  This can be used to change between string-like variants
+        ///  (eg, STRING, VARIABLE, etc)
+        ///  To change types entirely (eg, STRING to DOUBLE),
+        ///  use the corresponding assignment operator.
+        ///
+        ///  \return true if the change was successful or no change was required
         inline bool setType(const tokenType tokType);
 
-        //- The line number for the token
+        /// The line number for the token
         inline int32 lineNumber() const;
 
-        //- The line number for the token
+        /// The line number for the token
         inline int32& lineNumber();
 
-        //- True if token is not UNDEFINED or ERROR
+        /// True if token is not UNDEFINED or ERROR
         inline bool good() const;
 
-        //- Token is UNDEFINED
+        /// Token is UNDEFINED
         inline bool undefined() const;
 
-        //- Token is ERROR
+        /// Token is ERROR
         inline bool error() const;
 
-        //- Token is BOOL
+        /// Token is BOOL
         inline bool isBool() const;
 
-        //- Token is FLAG
+        /// Token is FLAG
         inline bool isFlag() const;
 
-        //- Token is PUNCTUATION
+        /// Token is PUNCTUATION
         inline bool isPunctuation() const;
 
-        //- Token is PUNCTUATION and isseparator
+        /// Token is PUNCTUATION and isseparator
         inline bool isSeparator() const;
 
-        //- Tolen is end statement 
+        /// Token is end statement 
         inline bool isEndStatement() const;
 
+        /// Token is end endBlock 
         inline bool isEndBlock()const;
 
-        //- Token is INT64
+        /// Token is int64
         inline bool isInt64() const;
 
-        //- Token is INT32
+        /// Token is int32
         inline bool isInt32() const;
 
-        //- Token is FLOAT
+        /// Token is float
         inline bool isFloat() const;
 
-        //- Token is DOUBLE
+        /// Token is double
         inline bool isDouble() const;
 
-        //- Token is FLOAT or DOUBLE
+        /// Token is float or double
         inline bool isReal() const;
 
-        //- Token is INT64, FLOAT or DOUBLE
+        /// Token is int, float or duble
         inline bool isNumber() const;
 
-        //- Token is WORD or DIRECTIVE word
+        /// Token is word or DIRECTIVE word
         inline bool isWord() const;
 
-        //- Token is DIRECTIVE (word variant)
+        /// Token is DIRECTIVE (word variant)
         inline bool isDirective() const;
 
-        //- Token is STRING, VARIABLE or VERBATIM string
+        /// Token is STRING, VARIABLE or VERBATIM string
         inline bool isString() const;
 
-        //- Token is VARIABLE (string variant)
+        /// Token is VARIABLE (string variant)
         inline bool isVariable() const;
 
-        //- Token is WORD, DIRECTIVE, STRING, VARIABLE or VERBATIM
+        /// Token is WORD, DIRECTIVE, STRING, VARIABLE or VERBATIM
         inline bool isStringType() const;
 
 
-    // Access
+    //- Access
 
-        //- Return boolean token value.
-        //  Report FatalIOError and return false if token is not BOOL or INT64
+        /// Return boolean token value.
+        ///  Report FatalIOError and return false if token is not BOOL or INT64
         inline bool boolToken() const;
 
-        //- Return flag bitmask value.
-        //  Report FatalIOError and return NO_FLAG if token is not FLAG
+        /// Return flag bitmask value.
+        ///  Report FatalIOError and return NO_FLAG if token is not FLAG
         inline int flagToken() const;
 
-        //- Return punctuation character.
-        //  Report FatalIOError and return \b \\0 if token is not PUNCTUATION
+        /// Return punctuation character.
+        ///  Report FatalIOError and return \b \\0 if token is not PUNCTUATION
         inline punctuationToken pToken() const;
 
-        //- Return int64 value.
+        /// Return int64 value.
         //  Report FatalIOError and return \b 0 if token is not INT64
         inline int64 int64Token() const;
 
-        //- Return int32 value.
-        //  Report FatalIOError and return \b 0 if token is not INT64
+        /// Return int32 value.
+        ///  Report FatalIOError and return \b 0 if token is not INT64
         inline int32 int32Token() const;
 
-        //- Return float value.
-        //  Report FatalIOError and return \b 0 if token is not FLOAT
+        /// Return float value.
+        ///  Report FatalIOError and return \b 0 if token is not FLOAT
         inline float floatToken() const;
 
-        //- Return double value.
-        //  Report FatalIOError and return \b 0 if token is not DOUBLE
+        /// Return double value.
+        ///  Report FatalIOError and return \b 0 if token is not DOUBLE
         inline double doubleToken() const;
 
-        //- Return float or double value.
-        //  Report FatalIOError and return \b 0 if token is not a
-        //  FLOAT or DOUBLE
+        /// Return float or double value.
+        ///  Report FatalIOError and return \b 0 if token is not a
+        ///  FLOAT or DOUBLE
         inline real realToken() const;
 
-        //- Return int64, float or double value.
-        //  Report FatalIOError and return \b 0 if token is not a
-        //  INT64, FLOAT or DOUBLE
+        /// Return int64, float or double value.
+        ///  Report FatalIOError and return \b 0 if token is not a
+        ///  INT64, FLOAT or DOUBLE
         inline real number() const;
 
-        //- Return const reference to the word contents.
-        //  Report FatalIOError and return \b "" if token is not a
-        //  WORD or DIRECTIVE
+        /// Return const reference to the word contents.
+        ///  Report FatalIOError and return \b "" if token is not a
+        ///  WORD or DIRECTIVE
         inline const word& wordToken() const;
 
-        //- Return const reference to the string contents.
-        //  Report FatalIOError and return \b "" if token is not a
-        //  STRING, VARIABLE, VERBATIM or an upcast WORD or DIRECTIVE
+        /// Return const reference to the string contents.
+        ///  Report FatalIOError and return \b "" if token is not a
+        ///  STRING, VARIABLE, VERBATIM or an upcast WORD or DIRECTIVE
         inline const word& stringToken() const;
 
 
-    // Edit
+    //- Edit
 
-        //- Reset token to UNDEFINED and clear any allocated storage
+        /// Reset token to UNDEFINED and clear any allocated storage
         inline void reset();
 
-        //- Clear token and set to be ERROR.
+        /// Clear token and set to be ERROR.
         inline void setBad();
 
-        //- Swap token contents: type, data, line-number
+        /// Swap token contents: type, data, line-number
         inline void swap(token& tok);
 
 
-    // Assignment
+    //- Assignment
 
-        //- Copy assign
+        /// Copy assign
         inline void operator=(const token& tok);
 
-        //- Move assign
+        /// Move assign
         inline void operator=(token&& tok);
 
-        //- Copy assign from punctuation
+        /// Copy assign from punctuation
         inline void operator=(const punctuationToken p);
 
-        //- Copy assign from int64
+        /// Copy assign from int64
         inline void operator=(const int64 val);
 
-         //- Copy assign from int32
+         /// Copy assign from int32
         inline void operator=(const int32 val);
 
-        //- Copy assign from float
+        /// Copy assign from float
         inline void operator=(const float val);
 
-        //- Copy assign from double
+        /// Copy assign from double
         inline void operator=(const double val);
 
-        //- Copy assign from word
+        /// Copy assign from word
         inline void operator=(const word& w);
 
                 
 
-        //- Move assign from word
+        /// Move assign from word
         inline void operator=(word&& w);
 
         
-    // Equality
+    //- Equality
 
         inline bool operator==(const token& tok) const;
         inline bool operator==(const punctuationToken p) const;
@@ -455,7 +463,7 @@ public:
         inline bool operator==(const word& w) const;
 
 
-    // Inequality
+    //- Inequality
 
         inline bool operator!=(const token& tok) const;
         inline bool operator!=(const punctuationToken p) const;
@@ -468,7 +476,8 @@ public:
         iOstream& printInfo(iOstream& os)const;
 
         std::ostream& printInfo(std::ostream& os)const;
-    // IOstream Operators
+    
+    //- IOstream Operators
 
         friend iOstream& operator<<(iOstream& os, const token& tok);
         friend iOstream& operator<<(iOstream& os, const punctuationToken& pt);
@@ -527,18 +536,10 @@ inline token newLineToken()
 }
 
 
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 } // End namespace pFlow
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "tokenI.hpp"
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
-
-// ************************************************************************* //
diff --git a/src/phasicFlow/streams/token/tokenI.hpp b/src/phasicFlow/streams/token/tokenI.hpp
index 1b261866..459018e7 100755
--- a/src/phasicFlow/streams/token/tokenI.hpp
+++ b/src/phasicFlow/streams/token/tokenI.hpp
@@ -144,7 +144,7 @@ inline pFlow::token::token(punctuationToken p, int32 lineNumber)
     data_.punctuationVal = p;
 }
 
-inline pFlow::token::token(const label val, int32 lineNumber)
+inline pFlow::token::token(const uint64 val, int32 lineNumber)
 :
     data_(),
     type_(tokenType::INT64),
@@ -162,6 +162,15 @@ inline pFlow::token::token(const uint32 val, int32 lineNumber)
     data_.int64Val = static_cast<int64>(val);
 }
 
+inline pFlow::token::token(const uint8 val, int32 lineNumber)
+:
+    data_(),
+    type_(tokenType::INT64),
+    lineNumber_(lineNumber)
+{
+    data_.int64Val = static_cast<int64>(val);
+}
+
 inline pFlow::token::token(const int64 val, int32 lineNumber)
 :
     data_(),
@@ -180,6 +189,15 @@ inline pFlow::token::token(const int32 val, int32 lineNumber)
     data_.int64Val = static_cast<int64>(val);
 }
 
+inline pFlow::token::token(const int8 val, int32 lineNumber)
+:
+    data_(),
+    type_(tokenType::INT64),
+    lineNumber_(lineNumber)
+{
+    data_.int64Val = static_cast<int64>(val);
+}
+
 inline pFlow::token::token(const float val, int32 lineNumber)
 :
     data_(),
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBase.cpp b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBase.cpp
new file mode 100644
index 00000000..4353115d
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBase.cpp
@@ -0,0 +1,250 @@
+/*------------------------------- 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 "boundaryBase.hpp"
+#include "boundaryList.hpp"
+#include "dictionary.hpp"
+#include "internalPoints.hpp"
+#include "anyList.hpp"
+#include "Time.hpp"
+#include "boundaryBaseKernels.hpp"
+
+
+void pFlow::boundaryBase::setNewIndices
+(
+	const uint32Vector_D& newIndices
+)
+{
+	indexList_.assign(newIndices, false);
+}
+
+bool pFlow::boundaryBase::appendNewIndices
+(
+	const uint32Vector_D& newIndices
+)
+{
+	
+	indexList_.append(newIndices);
+	
+	message msg;
+
+	msg.add(message::BNDR_APPEND);
+	anyList varList;
+	varList.emplaceBack( 
+		message::eventName(message::BNDR_APPEND),
+		newIndices);
+
+	if(!notify(
+		internal_.time().currentIter(),
+		internal_.time().currentTime(),
+		internal_.time().dt(),
+		msg,
+		varList))
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+	return true;
+	
+}
+
+bool pFlow::boundaryBase::removeIndices
+(
+	uint32 numRemove,
+	const uint32Vector_D& removeMask
+)
+{
+    if(removeMask.size() != size()+1 )
+	{
+		fatalErrorInFunction<<"size mismatch"<<endl;
+		return false;
+	}
+
+	uint32Vector_D removeIndices("removeIndices");
+	uint32Vector_D keepIndices("keepIndices");
+
+	pFlow::boundaryBaseKernels::createRemoveKeepIndices
+	(
+		indexList_,
+		numRemove,
+		removeMask,
+		removeIndices,
+		keepIndices
+	);
+	
+	if(!internal_.deletePoints(removeIndices))
+	{
+		fatalErrorInFunction<<
+		"error in deleting points from boundary "<< name()<<endl;
+		return false;
+	}
+
+	setNewIndices(keepIndices);
+
+	anyList aList;
+	
+	aList.emplaceBack(
+		message::eventName(message::BNDR_RESET), 
+		std::move(keepIndices));
+	
+	message msgBndry 	= message::BNDR_RESET;
+
+	uint32 iter = internal_.time().currentIter();
+	real t = internal_.time().currentTime();
+	real dt = internal_.time().dt();
+
+	if( !this->notify(iter, t, dt, msgBndry, aList) )
+	{
+		fatalErrorInFunction<<"Error in notify operation in boundary "<< 
+		name_ <<endl;
+		return false;
+	}
+	
+	return true;
+}
+
+bool pFlow::boundaryBase::transferPoints
+(
+	uint32 numTransfer, 
+	const uint32Vector_D& transferMask, 
+	uint32 transferBoundaryIndex, 
+	realx3 transferVector
+)
+{
+	if(transferMask.size() != size()+1 )
+	{
+		fatalErrorInFunction<<"size mismatch"<<endl;
+		return false;
+	}
+
+	uint32Vector_D transferIndices("transferIndices");
+	uint32Vector_D keepIndices("keepIndices");
+
+	pFlow::boundaryBaseKernels::createRemoveKeepIndices
+	(
+		indexList_,
+		numTransfer,
+		transferMask,
+		transferIndices,
+		keepIndices
+	);
+
+	// first, change the flags in the internalPoints
+	if( !internal_.changePointsFlagPosition(
+		transferIndices,
+		transferVector, 
+		thisBoundaryIndex(),
+		transferBoundaryIndex) ) 
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+	// second, remove the indices from this list 
+	setNewIndices(keepIndices);
+
+	// third, add the indices to the mirror boundary 
+	return mirrorBoundary().appendNewIndices(transferIndices);
+	
+}
+
+pFlow::boundaryBase::boundaryBase
+(
+    const dictionary &dict,
+    const plane 	&bplane,
+    internalPoints 	&internal,
+	boundaryList	&bndrs,
+	uint32 			thisIndex
+)
+: 
+	subscriber(dict.name()),
+	boundaryPlane_(bplane),
+	indexList_(groupNames(dict.name(), "indexList")),
+	neighborLength_(dict.getVal<real>("neighborLength")),
+	internal_(internal),
+	boundaries_(bndrs),
+	thisBoundaryIndex_(thisIndex),
+	mirrorProcessoNo_(dict.getVal<uint32>("mirrorProcessorNo")),
+	name_(dict.name()),
+	type_(dict.getVal<word>("type"))
+{
+}
+
+pFlow::boundaryBase &pFlow::boundaryBase::mirrorBoundary()
+{
+    return boundaries_[mirrorBoundaryIndex()];
+}
+
+void pFlow::boundaryBase::setSize(uint32 newSize)
+{
+	indexList_.resize(newSize);
+	
+}	
+
+typename pFlow::boundaryBase::pointFieldAccessType
+pFlow::boundaryBase::thisPoints()
+{
+    
+    return pointFieldAccessType
+    (
+        indexList_.size(),
+        indexList_.deviceViewAll(),
+        internal_.pointPosition().deviceViewAll()
+    );
+   
+}
+
+typename pFlow::boundaryBase::pointFieldAccessType
+    pFlow::boundaryBase::neighborPoints()
+{
+    notImplementedFunction;
+    return pointFieldAccessType();
+}
+
+pFlow::uniquePtr<pFlow::boundaryBase> pFlow::boundaryBase::create
+(
+    const dictionary &dict,
+    const plane 	&bplane,
+    internalPoints 	&internal,
+	boundaryList	&bndrs,
+	uint32 			thisIndex
+)
+{
+	word type = dict.getVal<word>("type");
+	word bType = angleBracketsNames("boundary", type);
+
+	if( dictionaryvCtorSelector_.search(bType) )
+	{
+		return dictionaryvCtorSelector_[bType] (dict, bplane, internal, bndrs, thisIndex);
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< bType << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			dictionaryvCtorSelector_
+		);
+		fatalExit;
+	}
+	return nullptr;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBase.hpp b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBase.hpp
new file mode 100644
index 00000000..c177d428
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBase.hpp
@@ -0,0 +1,236 @@
+/*------------------------------- 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 __boundaryBase_hpp__
+#define __boundaryBase_hpp__
+
+#include "virtualConstructor.hpp"
+#include "subscriber.hpp"
+#include "VectorSingles.hpp"
+#include "plane.hpp"
+#include "scatteredFieldAccess.hpp"
+
+#include "streams.hpp"
+
+namespace pFlow
+{
+
+// forward 
+
+class internalPoints;
+class dictionary;
+class boundaryList;
+
+class boundaryBase
+:
+	public subscriber
+{
+public:
+
+    using pointFieldAccessType = 
+        deviceScatteredFieldAccess<realx3>;
+
+private:
+
+	const plane& 	boundaryPlane_;
+
+	/// list of particles indices on device 
+	uint32Vector_D 	indexList_;
+
+	/// The length defined for creating neighbor list 
+	real  			neighborLength_;	
+
+	/// a reference to 
+	internalPoints& internal_;
+
+	/// a reference to the list of boundaries 
+	/// (never use this in the constructor).
+	boundaryList& 	boundaries_;
+
+	uint32 			thisBoundaryIndex_;
+
+	uint32 			mirrorProcessoNo_;
+
+	word 		name_;
+
+	word 		type_;
+
+protected:
+
+	void setNewIndices(const uint32Vector_D& newIndices);
+
+	bool appendNewIndices(const uint32Vector_D& newIndices);
+	
+	bool removeIndices(
+		uint32 numRemove, 
+		const uint32Vector_D& removeMask);
+	
+	bool transferPoints(
+		uint32 numTransfer, 
+		const uint32Vector_D& transferMask,
+		uint32 transferBoundaryIndex,
+		realx3 transferVector);
+	
+public:
+
+	TypeInfo("boundaryBase");
+
+	
+	boundaryBase(
+		const dictionary &dict,
+		const plane 	&bplane,
+		internalPoints 	&internal,
+		boundaryList	&bndrs,
+		uint32 			thisIndex);
+
+	boundaryBase(const boundaryBase&) = delete;
+
+	boundaryBase& operator=(const boundaryBase&) = delete;
+
+	boundaryBase(boundaryBase&&) = default;
+
+	boundaryBase& operator=(boundaryBase&&) = default;
+
+	~boundaryBase() override = default;
+	
+
+	create_vCtor
+	(
+		boundaryBase,
+		dictionary,
+		(
+			const dictionary &dict,
+    		const plane 	&bplane,
+    		internalPoints 	&internal,
+			boundaryList	&bndrs,
+			uint32 			thisIndex
+		),
+		(dict, bplane, internal, bndrs, thisIndex)
+	);
+
+	virtual 
+	real neighborLength()const
+	{
+		return neighborLength_;
+	}
+
+	virtual 
+	realx3 boundaryExtensionLength()const
+	{
+		return {0,0,0};
+	}
+
+	const word& type()const
+	{
+		return type_;
+	}
+
+	const word& name()const
+	{
+		return name_;
+	}
+
+	bool empty()const
+	{
+		return indexList_.size()==0;
+	}
+
+	auto size()const
+	{
+		return indexList_.size();
+	}
+
+	virtual 
+	const plane& boundaryPlane()const
+	{
+		return boundaryPlane_;
+	}
+
+	auto capacity()const
+	{
+		return indexList_.capacity();
+	}
+
+	const internalPoints& internal()const
+	{
+		return internal_;
+	}
+
+	internalPoints& internal()
+	{
+		return internal_;
+	}
+
+	boundaryBase& mirrorBoundary();
+	
+	inline
+	uint32 thisBoundaryIndex()const
+	{
+		return thisBoundaryIndex_;
+	}
+
+	inline
+	uint32 mirrorBoundaryIndex()const
+	{
+		return thisBoundaryIndex_%2==0? thisBoundaryIndex_+1:thisBoundaryIndex_-1;
+	}
+
+	/// @brief set the size of indexList 
+	/// Always make sure that size+1 <= capacity
+	void setSize(uint32 newSize);
+
+	virtual 
+    bool beforeIteration(uint32 iterNum, real t, real dt) = 0 ;
+
+	virtual 
+    bool iterate(uint32 iterNum, real t, real dt) = 0;
+
+	virtual 
+    bool afterIteration(uint32 iterNum, real t, real dt) = 0;
+
+	
+	const auto& indexList()const
+	{
+		return indexList_;
+	}
+
+    pointFieldAccessType thisPoints();
+
+    virtual
+    pointFieldAccessType neighborPoints();
+    
+
+	static
+	uniquePtr<boundaryBase> create
+	(
+		const dictionary &dict,
+		const plane 	&bplane,
+		internalPoints 	&internal,
+		boundaryList	&bndrs,
+		uint32 			thisIndex
+	);
+
+	
+};
+
+}
+
+
+#endif //__boundaryBase_hpp__
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBaseKernels.cpp b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBaseKernels.cpp
new file mode 100644
index 00000000..0b0fd10c
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBaseKernels.cpp
@@ -0,0 +1,99 @@
+/*------------------------------- 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 "boundaryBaseKernels.hpp"
+
+void pFlow::boundaryBaseKernels::createRemoveKeepLists
+(
+    uint32 numTotal, 
+    uint32 numRemove, 
+    const uint32Vector_D& removeMask, 
+    uint32Vector_D& removeList, 
+    uint32Vector_D& keepList
+)
+{
+    uint32 numKeep = numTotal - numRemove;
+    removeList.reallocate(numRemove,numRemove);
+    keepList.reallocate(numKeep,numKeep);
+    
+    auto maskD = removeMask.deviceViewAll();
+    const auto& removeD = removeList.deviceViewAll();
+    const auto& keepD = keepList.deviceViewAll();
+    
+    exclusiveScan(
+        maskD, 
+        0u, 
+        numTotal+1, 
+        maskD, 
+        0u);
+
+    Kokkos::parallel_for
+    (
+        "pFlow::boundaryBaseKernels::createRemoveKeepLists",
+        deviceRPolicyStatic(0, numTotal),
+        LAMBDA_HD(uint32 i)
+		{
+			if(maskD(i)!= maskD(i+1))
+				removeD(maskD(i)) = i;
+            else
+                keepD(i-maskD(i)) = i;
+		}
+    );
+    Kokkos::fence();
+
+}
+
+
+void pFlow::boundaryBaseKernels::createRemoveKeepIndices
+(
+    const uint32Vector_D& indices,
+    uint32 numRemove,
+    const uint32Vector_D& removeMask, 
+    uint32Vector_D& removeIndices, 
+    uint32Vector_D& keepIndices
+)
+{
+    uint32 numTotal = indices.size();
+    uint32 numKeep = numTotal - numRemove;
+    
+    removeIndices.reallocate(numRemove, numRemove);
+    keepIndices.reallocate(numKeep, numKeep);
+
+    auto maskD = removeMask.deviceViewAll();
+    const auto& removeD = removeIndices.deviceViewAll();
+    const auto& keepD = keepIndices.deviceViewAll();
+    const auto& indicesD = indices.deviceViewAll();
+
+    exclusiveScan(maskD, 0u, numTotal+1, maskD, 0u);
+
+    Kokkos::parallel_for
+    (
+        "pFlow::boundaryBaseKernels::createRemoveKeepLists",
+        deviceRPolicyStatic(0, numTotal),
+        LAMBDA_HD(uint32 i)
+		{
+			if(maskD(i)!= maskD(i+1))
+				removeD(maskD(i)) = indicesD(i);
+            else
+                keepD(i-maskD(i)) = indicesD(i);
+		}
+    );
+    Kokkos::fence();   
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBaseKernels.hpp b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBaseKernels.hpp
new file mode 100644
index 00000000..780360f7
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryBase/boundaryBaseKernels.hpp
@@ -0,0 +1,46 @@
+/*------------------------------- 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 __boundaryBaseKernels_hpp__
+#define __boundaryBaseKernels_hpp__
+
+#include "VectorSingles.hpp"
+
+namespace pFlow::boundaryBaseKernels
+{
+
+void createRemoveKeepLists(
+    uint32 numTotal, 
+    uint32 numRemove, 
+    const uint32Vector_D& removeMask, 
+    uint32Vector_D& removeList, 
+    uint32Vector_D& keepList);
+
+void createRemoveKeepIndices(
+    const uint32Vector_D& indices,
+    uint32 numRemove,
+    const uint32Vector_D& removeMask, 
+    uint32Vector_D& removeIndices, 
+    uint32Vector_D& keepIndices);
+
+
+}
+
+#endif //__boundaryBaseKernels_hpp__
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryBase/scatteredFieldAccess.hpp b/src/phasicFlow/structuredData/boundaries/boundaryBase/scatteredFieldAccess.hpp
new file mode 100644
index 00000000..19c9caa7
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryBase/scatteredFieldAccess.hpp
@@ -0,0 +1,129 @@
+
+#ifndef __scatteredFieldAccess_hpp__
+#define __scatteredFieldAccess_hpp__
+
+
+#include "phasicFlowKokkos.hpp"
+
+namespace pFlow
+{
+
+
+template<typename T, typename MemorySpace=void>
+class scatteredFieldAccess
+{
+public:
+	
+	using viewType 			= ViewType1D<T, MemorySpace>;
+
+    using device_type 		= typename viewType::device_type;
+
+    using memory_space 		= typename viewType::memory_space;
+
+    using execution_space 	= typename viewType::execution_space;
+
+private:
+
+	uint32 								size_ = 0;
+
+	ViewType1D<uint32, memory_space> 	indices_;
+
+	viewType 		fieldVals_;
+
+public:
+
+    scatteredFieldAccess():
+        indices_(),
+        fieldVals_()    
+    {}
+
+	scatteredFieldAccess(
+		uint32 	sz,
+		ViewType1D<uint32, memory_space> ind,
+		ViewType1D<T, memory_space> fVals)
+	:
+		size_(sz),
+		indices_(ind),
+		fieldVals_(fVals)
+	{}
+
+	scatteredFieldAccess(const scatteredFieldAccess&) = default;
+
+	scatteredFieldAccess(scatteredFieldAccess&&) = default;
+
+	scatteredFieldAccess& operator=(const scatteredFieldAccess&) = default;
+
+	scatteredFieldAccess& operator=(scatteredFieldAccess&&) = default;
+
+	~scatteredFieldAccess() = default;
+
+	// - Methods
+
+    INLINE_FUNCTION_HD
+	T& operator()(uint32 i)
+	{
+		return fieldVals_(indices_(i));
+	}
+
+    INLINE_FUNCTION_HD
+	const T& operator()(uint32 i)const
+	{
+		return fieldVals_(indices_(i));
+	}
+
+    INLINE_FUNCTION_HD
+	T& operator[](uint32 i)
+	{
+		return fieldVals_(indices_(i));
+	}
+
+    INLINE_FUNCTION_HD
+	const T& operator[](uint32 i)const
+	{
+		return fieldVals_(indices_(i));
+	}
+
+    INLINE_FUNCTION_HD
+	uint32 	size()const
+	{
+		return size_;
+	}
+
+    INLINE_FUNCTION_HD
+	bool empty()const
+	{
+		return size_ == 0;
+	}
+
+	T getFirstCopy()const
+	{
+		T val;
+		uint32 n = indices_(0);
+		getNth(val, fieldVals_, n);
+		return val;
+	}
+
+	T getLastCopy()const 
+	{
+		T val;
+		if(empty())return val;
+		uint32 n = indices_(size()-1);
+		getNth(val, fieldVals_, n);
+		return val;
+	}
+
+};
+
+template<typename T>
+	using deviceScatteredFieldAccess = 
+		scatteredFieldAccess<T, typename DefaultExecutionSpace::memory_space>;
+
+template<typename T>
+	using hostScatteredFieldAccess = 
+		scatteredFieldAccess<T,HostSpace>;
+
+} // pFlow
+
+
+#endif //__scatteredFieldAccess_hpp__
+
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryExit/boundaryExit.cpp b/src/phasicFlow/structuredData/boundaries/boundaryExit/boundaryExit.cpp
new file mode 100644
index 00000000..3b753877
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryExit/boundaryExit.cpp
@@ -0,0 +1,108 @@
+/*------------------------------- 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 "boundaryExit.hpp"
+#include "internalPoints.hpp"
+#include "dictionary.hpp"
+
+
+pFlow::boundaryExit::boundaryExit
+(
+	const dictionary &dict,
+    const plane 	&bplane,
+    internalPoints 	&internal,
+	boundaryList	&bndrs,
+	uint32 			thisIndex
+)
+:
+	boundaryBase(dict, bplane, internal, bndrs, thisIndex)
+{
+	exitMarginLength_ = max( 
+		dict.getValOrSet("exitMarginLength",(real)0.0), (real)0.0);
+	checkForExitInterval_ = max(
+		dict.getValOrSet("checkForExitInterval", 1), 1);
+}
+
+bool pFlow::boundaryExit::beforeIteration
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
+{
+	// nothing have to be done
+	if(empty())
+	{
+		return true;
+	}
+
+	uint32 s = size();
+	uint32Vector_D deleteFlags("deleteFlags",s+1, s+1, RESERVE());
+	deleteFlags.fill(0u);
+
+	const auto& deleteD = deleteFlags.deviceViewAll();
+	auto points = thisPoints();
+	auto p = boundaryPlane().infPlane();
+
+	uint32 numDeleted = 0;	
+
+	Kokkos::parallel_reduce
+	(
+		"boundaryExit::beforeIteration",
+		deviceRPolicyStatic(0,s),
+		LAMBDA_HD(uint32 i, uint32& delToUpdate)
+		{
+			if(p.pointInNegativeSide(points(i)))
+			{
+				deleteD(i)=1;
+				delToUpdate++;
+			}
+		}, 
+		numDeleted
+	);
+		
+	// no point is deleted
+	if(numDeleted == 0 )
+	{
+		return true;
+	}
+
+	return this->removeIndices(numDeleted, deleteFlags);
+}
+
+bool pFlow::boundaryExit::iterate
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
+{
+	return true;
+}
+
+bool pFlow::boundaryExit::afterIteration
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
+{
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/bitTransfer.hpp b/src/phasicFlow/structuredData/boundaries/boundaryExit/boundaryExit.hpp
similarity index 54%
rename from src/phasicFlow/structuredData/trisurfaceStructure/bitTransfer.hpp
rename to src/phasicFlow/structuredData/boundaries/boundaryExit/boundaryExit.hpp
index 720a2eb3..f8aa61c5 100644
--- a/src/phasicFlow/structuredData/trisurfaceStructure/bitTransfer.hpp
+++ b/src/phasicFlow/structuredData/boundaries/boundaryExit/boundaryExit.hpp
@@ -18,54 +18,60 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
-#ifndef __bitTransfer_hpp__
-#define __bitTransfer_hpp__
+#ifndef __boundaryExit_hpp__
+#define __boundaryExit_hpp__
 
 
-#include "types.hpp"
-#include "Vectors.hpp"
+#include "boundaryBase.hpp"
 
 namespace pFlow
 {
 
-// a simple functor that transfers 3 integers into a long variable and 
-// transfer the long to 3 integers
-
-class bitTransfer
+class boundaryExit
+:
+ 	public boundaryBase
 {
 protected:
 
-	static const int numBits_ = 21;
-	static const int numBits2_ = 2 * numBits_;
-	static const unsigned long mask1_ = 0x000000000001FFFFF;
-	static const unsigned long mask2_ = 0x0000003FFFFE00000;
-	static const unsigned long mask3_ = 0x07FFFFC0000000000;
+	/// @brief Length of margin in the negative side of 
+	/// boundary to still allow points stay in the 
+	/// simulation. 
+	real 	exitMarginLength_ = 0;
+
+	/// @brief between successive check for particle exit
+	/// (iteration-based).
+	uint32 	checkForExitInterval_ = 1;
 
 public:
 
-	bitTransfer(){}
+	TypeInfo("boundary<exit>");
+
+	boundaryExit(
+		const dictionary &dict,
+		const plane 	&bplane,
+		internalPoints 	&internal,
+		boundaryList	&bndrs,
+		uint32 			thisIndex);
+
+	virtual 
+	~boundaryExit() = default;
+	
+	add_vCtor
+	(
+		boundaryBase,
+		boundaryExit,
+		dictionary
+	);
+
+	bool beforeIteration(uint32 iterNum, real t, real dt) override;
+
+	bool iterate(uint32 iterNum, real t, real dt) override;
+
+	bool afterIteration(uint32 iterNum, real t, real dt) override;
 
-	inline unsigned long operator()(const unit3& int3 )
-	{
-		return 
-			static_cast<long>(int3.x()) |
-			static_cast<long>(int3.y()) << numBits_ |
-			static_cast<long>(int3.z()) << numBits2_;
-	}
 
-	inline unit3 operator() (const unsigned long& ul )
-	{
-		return unit3
-			(
-				 ul & mask1_,
-				(ul & mask2_)>> numBits_,
-				(ul & mask3_)>> numBits2_
-			);
-	}
 };
 
 }
 
-
-#endif
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryList.cpp b/src/phasicFlow/structuredData/boundaries/boundaryList.cpp
new file mode 100644
index 00000000..237e4bd7
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryList.cpp
@@ -0,0 +1,191 @@
+/*------------------------------- 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 "boundaryList.hpp"
+#include "pointStructure.hpp"
+
+
+bool pFlow::boundaryList::resetLists()
+{
+	clear();
+	listSet_ = false;
+    return true;
+}
+
+bool pFlow::boundaryList::updateLists()
+{
+    
+	std::array<real,6> dist;
+	dist[0] = boundary(0).neighborLength();
+	dist[1] = boundary(1).neighborLength();
+	dist[2] = boundary(2).neighborLength();
+	dist[3] = boundary(3).neighborLength();
+	dist[4] = boundary(4).neighborLength();
+	dist[5] = boundary(5).neighborLength();
+
+	realx3 lowerExt = 
+		boundary(0).boundaryExtensionLength() + 
+		boundary(2).boundaryExtensionLength() + 
+		boundary(4).boundaryExtensionLength();
+	
+	realx3 upperExt = 
+		boundary(1).boundaryExtensionLength()+
+		boundary(3).boundaryExtensionLength()+
+		boundary(5).boundaryExtensionLength();
+
+	auto extDomain = pStruct_.simDomain().extendThisDomain(lowerExt, upperExt);
+	pStruct_.updateFlag(
+			extDomain,
+			dist);
+	const auto& maskD = pStruct_.activePointsMaskDevice();
+	boundary(0).setSize( maskD.leftSize() );
+	boundary(1).setSize( maskD.rightSize() );
+	boundary(2).setSize( maskD.bottomSize() );
+	boundary(3).setSize( maskD.topSize() );
+	boundary(4).setSize( maskD.rearSize() );
+	boundary(5).setSize( maskD.frontSize() );
+
+	pStruct_.fillNeighborsLists(
+		boundary(0).indexList().deviceViewAll(),
+		boundary(1).indexList().deviceViewAll(),
+		boundary(2).indexList().deviceViewAll(),
+		boundary(3).indexList().deviceViewAll(),
+		boundary(4).indexList().deviceViewAll(),
+		boundary(5).indexList().deviceViewAll());
+
+	return true;	
+}
+
+pFlow::boundaryList::boundaryList
+(
+    pointStructure& pStruct
+)
+: 
+	ListPtr<boundaryBase>(pStruct.simDomain().sizeOfBoundaries()),
+	pStruct_(pStruct),
+	timeControl_
+	(
+		pStruct.simDomain().subDict("boundaries"), 
+		"update",
+		pStruct.currentTime()
+	)
+{}
+
+bool pFlow::boundaryList::updateLists(uint32 iter, real t, real dt)
+{
+	if( timeControl_.timeEvent(iter, t, dt))
+	{
+		return updateLists();
+	}
+	return true;
+}
+
+bool pFlow::boundaryList::setLists()
+{
+	if(listSet_)return true;
+
+	for(auto i=0; i<pStruct_.simDomain().sizeOfBoundaries();i++)
+	{
+		this->set
+		(
+			i,
+			boundaryBase::create
+			(
+				pStruct_.simDomain().boundaryDict(i),
+				pStruct_.simDomain().boundaryPlane(i),
+				pStruct_,
+				*this,
+				i
+			)
+		);
+	}
+	listSet_ = true;
+
+	return true;
+}
+
+bool pFlow::boundaryList::beforeIteration
+(
+	uint32 iter, 
+	real t, 
+	real dt
+)
+{
+	// it is time to update lists 
+	if(timeControl_.timeEvent(iter, t, dt))
+	{
+		if(!updateLists())
+		{
+			fatalErrorInFunction;
+			return false;
+		}
+	}
+
+	for(auto& bdry:*this)
+	{
+		if( !bdry->beforeIteration(iter, t, dt))
+		{
+			fatalErrorInFunction<<
+			"Error in beforeIteration in boundary "<<bdry->name()<<endl;
+			return false;
+		}
+		
+	}
+
+    return true;
+}
+
+bool pFlow::boundaryList::iterate
+(
+	uint32 iter, 
+	real t, 
+	real dt
+)
+{
+	for(auto& bdry:*this)
+	{
+		if( !bdry->iterate(iter, t, dt))
+		{
+			fatalErrorInFunction<<
+			"Error in iterate in boundary "<<bdry->name()<<endl;
+			return false;
+		}
+	}
+    return true;
+}
+
+bool pFlow::boundaryList::afterIteration
+(
+	uint32 iter, 
+	real t, 
+	real dt
+)
+{
+    for(auto& bdry:*this)
+	{
+		if( !bdry->afterIteration(iter, t, dt))
+		{
+			fatalErrorInFunction<<
+			"Error in afterIteration in boundary "<<bdry->name()<<endl;
+			return false;
+		}
+	}
+	return true;
+}
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryList.hpp b/src/phasicFlow/structuredData/boundaries/boundaryList.hpp
new file mode 100644
index 00000000..d9e6ce75
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryList.hpp
@@ -0,0 +1,103 @@
+/*------------------------------- 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 __boundaryList_hpp__
+#define __boundaryList_hpp__
+
+#include "boundaryBase.hpp"
+#include "ListPtr.hpp"
+#include "baseTimeControl.hpp"
+
+
+namespace pFlow
+{
+
+class pointStructure;
+
+class boundaryList
+:
+    public ListPtr<boundaryBase>
+{
+
+protected:
+
+	//// - data members
+		pointStructure& 		pStruct_;
+
+		baseTimeControl 		timeControl_;
+
+		bool                    listSet_ = false;
+
+		bool resetLists();
+
+		/// @brief update neighbor list of boundaries regardless
+		/// of the time intervals 
+		bool updateLists();
+
+public:
+	
+	/// type info
+	TypeInfo("boundaryList");
+	
+
+	//// - Constructors
+	boundaryList(pointStructure& pStruct);
+
+
+  	~boundaryList() = default;
+
+	/// @brief update neighbor list of boundaries based on 
+	/// the time intervals
+	bool updateLists(uint32 iter, real t, real dt);
+
+	bool setLists();
+
+	auto& boundary(size_t i)
+	{
+		return ListPtr<boundaryBase>::operator[](i);
+	}
+
+	const auto& boundary(size_t i)const
+	{
+		return ListPtr<boundaryBase>::operator[](i);
+	}
+
+	const baseTimeControl& timeControl()const
+	{
+		return timeControl_;
+	}
+
+	bool beforeIteration(uint32 iter, real t, real dt);
+
+	bool iterate(uint32 iter, real t, real dt);
+
+	bool afterIteration(uint32 iter, real t, real dt);
+	
+};
+
+} // pFlow
+
+
+
+
+#endif //__boundaryList_hpp__
+
+
diff --git a/src/Interaction/interaction/demInteraction.hpp b/src/phasicFlow/structuredData/boundaries/boundaryNone/boundaryNone.cpp
similarity index 65%
rename from src/Interaction/interaction/demInteraction.hpp
rename to src/phasicFlow/structuredData/boundaries/boundaryNone/boundaryNone.cpp
index 8c74639c..327330dd 100644
--- a/src/Interaction/interaction/demInteraction.hpp
+++ b/src/phasicFlow/structuredData/boundaries/boundaryNone/boundaryNone.cpp
@@ -18,42 +18,46 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __demInteraction_hpp__
-#define __demInteraction_hpp__
+#include "boundaryNone.hpp"
 
-#include "property.hpp"
-#include "demComponent.hpp"
-#include "pointFields.hpp"
-#include "triSurfaceFields.hpp"
-
-namespace pFlow
-{
-
-class demInteraction
+pFlow::boundaryNone::boundaryNone
+(
+	const dictionary &dict,
+    const plane 	&bplane,
+    internalPoints 	&internal,
+	boundaryList	&bndrs,
+	uint32 			thisIndex
+)
 :
-	public property,
-	public demComponent
+	boundaryBase(dict, bplane, internal, bndrs, thisIndex)
+{}
+
+bool pFlow::boundaryNone::beforeIteration
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
 {
-protected:
-
-public:
-	demInteraction(systemControl& control)
-	:
-		property(),
-		demComponent("interaction", control)
-	{}
-
-	demInteraction(systemControl& control, const fileSystem& file)
-	:
-		property(file),
-		demComponent("interaction", control)
-	{}
-
-
-
-};
-
-
+	return true;
 }
 
-#endif //__interaction_hpp__ 
+bool pFlow::boundaryNone::iterate
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
+{
+	return true;
+}
+
+bool pFlow::boundaryNone::afterIteration
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
+{
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryNone/boundaryNone.hpp b/src/phasicFlow/structuredData/boundaries/boundaryNone/boundaryNone.hpp
new file mode 100644
index 00000000..372a1c28
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryNone/boundaryNone.hpp
@@ -0,0 +1,66 @@
+/*------------------------------- 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 __boundaryNone_hpp__
+#define __boundaryNone_hpp__
+
+
+#include "boundaryBase.hpp"
+
+namespace pFlow
+{
+
+class boundaryNone
+:
+ 	public boundaryBase
+{
+
+public:
+
+	TypeInfo("boundary<none>");
+
+	boundaryNone(
+		const dictionary &dict,
+		const plane 	&bplane,
+		internalPoints 	&internal,
+		boundaryList	&bndrs,
+		uint32 			thisIndex);
+
+	~boundaryNone() override= default;
+	
+	add_vCtor
+	(
+		boundaryBase,
+		boundaryNone,
+		dictionary
+	);
+
+	bool beforeIteration(uint32 iterNum, real t, real dt) override;
+
+	bool iterate(uint32 iterNum, real t, real dt) override;
+
+	bool afterIteration(uint32 iterNum, real t, real dt) override;
+
+
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryPeriodic/boundaryPeriodic.cpp b/src/phasicFlow/structuredData/boundaries/boundaryPeriodic/boundaryPeriodic.cpp
new file mode 100644
index 00000000..ff02d83c
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryPeriodic/boundaryPeriodic.cpp
@@ -0,0 +1,129 @@
+/*------------------------------- 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 "boundaryPeriodic.hpp"
+#include "internalPoints.hpp"
+#include "dictionary.hpp"
+
+
+pFlow::boundaryPeriodic::boundaryPeriodic
+(
+	const dictionary &dict,
+    const plane 	&bplane,
+    internalPoints 	&internal,
+	boundaryList	&bndrs,
+	uint32 			thisIndex
+)
+:
+	boundaryBase(dict, bplane, internal, bndrs, thisIndex),
+	mirrorBoundaryIndex_(dict.getVal<uint32>("mirrorBoundaryIndex"))
+{
+	extendedPlane_ = boundaryBase::boundaryPlane().parallelPlane(-boundaryBase::neighborLength());
+}
+
+pFlow::real pFlow::boundaryPeriodic::neighborLength() const
+{
+    return 2.0*boundaryBase::neighborLength();
+}
+
+pFlow::realx3 pFlow::boundaryPeriodic::boundaryExtensionLength() const
+{
+    return -neighborLength()*boundaryBase::boundaryPlane().normal();
+}
+
+const pFlow::plane &pFlow::boundaryPeriodic::boundaryPlane() const
+{
+    return extendedPlane_;
+}
+
+bool pFlow::boundaryPeriodic::beforeIteration(
+    uint32 iterNum,
+    real t,
+    real dt)
+{
+	// nothing have to be done
+	if(empty())
+	{
+		return true;
+	}
+
+	uint32 s = size();
+	uint32Vector_D transferFlags("transferFlags",s+1, s+1, RESERVE()); 
+	transferFlags.fill(0u);
+	
+	auto points = thisPoints();
+	auto p = boundaryPlane().infPlane();
+	const auto & transferD = transferFlags.deviceViewAll();
+	uint32 numTransfered = 0;
+
+	Kokkos::parallel_reduce
+	(
+		"boundaryPeriodic::beforeIteration",
+		deviceRPolicyStatic(0u,s),
+		LAMBDA_HD(uint32 i, uint32& trnasToUpdate)
+		{
+			if(p.pointInNegativeSide(points(i)))
+			{
+				transferD(i)=1;
+				trnasToUpdate++;
+			}
+		}, 
+		numTransfered
+	);
+	
+	// no point to be transfered 
+	if(numTransfered == 0 )
+	{
+		return true;
+	}
+	
+	// to obtain the transfer vector 
+	const auto& thisP = boundaryPlane();
+	const auto& mirrorP = mirrorBoundary().boundaryPlane();
+	realx3 transferVec = thisP.normal()*(thisP.d() + mirrorP.d());
+
+	return transferPoints
+	(
+		numTransfered,
+		transferFlags, 
+		mirrorBoundaryIndex(), 
+		transferVec
+	);
+}
+
+bool pFlow::boundaryPeriodic::iterate
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
+{
+	return true;
+}
+
+bool pFlow::boundaryPeriodic::afterIteration
+(
+	uint32 iterNum, 
+	real t,
+	real dt
+)
+{
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/boundaries/boundaryPeriodic/boundaryPeriodic.hpp b/src/phasicFlow/structuredData/boundaries/boundaryPeriodic/boundaryPeriodic.hpp
new file mode 100644
index 00000000..3698926a
--- /dev/null
+++ b/src/phasicFlow/structuredData/boundaries/boundaryPeriodic/boundaryPeriodic.hpp
@@ -0,0 +1,78 @@
+/*------------------------------- 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 __boundaryPeriodic_hpp__
+#define __boundaryPeriodic_hpp__
+
+
+#include "boundaryBase.hpp"
+
+namespace pFlow
+{
+
+class boundaryPeriodic
+:
+ 	public boundaryBase
+{
+private:
+
+	uint32 mirrorBoundaryIndex_;
+
+	plane extendedPlane_;
+
+public:
+
+	TypeInfo("boundary<periodic>");
+
+	boundaryPeriodic(
+		const dictionary &dict,
+		const plane 	&bplane,
+		internalPoints 	&internal,
+		boundaryList	&bndrs,
+		uint32 			thisIndex);
+
+	 
+	~boundaryPeriodic() override= default;
+	
+	add_vCtor
+	(
+		boundaryBase,
+		boundaryPeriodic,
+		dictionary
+	);
+
+	real neighborLength()const override;
+
+	realx3 boundaryExtensionLength()const override;
+
+	const plane& boundaryPlane()const override;
+
+	bool beforeIteration(uint32 iterNum, real t, real dt) override;
+
+	bool iterate(uint32 iterNum, real t, real dt) override;
+
+	bool afterIteration(uint32 iterNum, real t, real dt) override;
+
+
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/box/box.hpp b/src/phasicFlow/structuredData/box/box.hpp
index 428e0534..4e78f2fc 100644
--- a/src/phasicFlow/structuredData/box/box.hpp
+++ b/src/phasicFlow/structuredData/box/box.hpp
@@ -62,18 +62,19 @@ public:
 		FUNCTION_H
 		box(iIstream& is);
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		box(const box&) = default;
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		box(box&&) = default;
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		box& operator=(const box&) = default;
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		box& operator=(box&&) = default;
 
+		INLINE_FUNCTION_HD
 		~box()=default;
 
 	//// - Methods 
@@ -85,17 +86,29 @@ public:
 		}
 
 		INLINE_FUNCTION_HD
-		realx3 minPoint()const
+		const realx3& minPoint()const
 		{
 			return min_;
 		}
 
 		INLINE_FUNCTION_HD
-		realx3 maxPoint()const
+		const realx3& maxPoint()const
 		{
 			return max_;
 		}
 
+        INLINE_FUNCTION_HD
+        realx3& minPoint()
+        {
+            return min_;
+        }
+
+        INLINE_FUNCTION_HD
+        realx3& maxPoint()
+        {
+            return max_;
+        }
+
 	//// - IO operation 
 		FUNCTION_H
 		bool read(iIstream & is);
diff --git a/src/phasicFlow/structuredData/domain/domain.cpp b/src/phasicFlow/structuredData/domain/domain.cpp
new file mode 100644
index 00000000..e81c0471
--- /dev/null
+++ b/src/phasicFlow/structuredData/domain/domain.cpp
@@ -0,0 +1,80 @@
+/*------------------------------- 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 "domain.hpp"
+
+FUNCTION_H 
+pFlow::domain::domain(const box& db)
+:
+	domainBox_(db),
+	left_(
+		db.minPoint(),
+		realx3(db.minPoint().x(), db.maxPoint().y(), db.minPoint().z()),
+		realx3(db.minPoint().x(), db.maxPoint().y(), db.maxPoint().z()),
+		realx3(db.minPoint().x(), db.minPoint().y(), db.maxPoint().z())),
+	right_(
+		db.maxPoint(),
+		realx3(db.maxPoint().x(), db.maxPoint().y(), db.minPoint().z()),
+		realx3(db.maxPoint().x(), db.minPoint().y(), db.minPoint().z()),
+		realx3(db.maxPoint().x(), db.minPoint().y(), db.maxPoint().z())),
+	bottom_(
+		db.minPoint(),
+		realx3(db.minPoint().x(), db.minPoint().y(), db.maxPoint().z()),
+		realx3(db.maxPoint().x(), db.minPoint().y(), db.maxPoint().z()),
+		realx3(db.maxPoint().x(), db.minPoint().y(), db.minPoint().z())),
+	top_(
+		db.maxPoint(),
+		realx3(db.minPoint().x(), db.maxPoint().y(), db.maxPoint().z()),
+		realx3(db.minPoint().x(), db.maxPoint().y(), db.minPoint().z()),
+		realx3(db.maxPoint().x(), db.maxPoint().y(), db.minPoint().z())),
+	rear_(
+		db.minPoint(),
+		realx3(db.maxPoint().x(), db.minPoint().y(), db.minPoint().z()),
+		realx3(db.maxPoint().x(), db.maxPoint().y(), db.minPoint().z()),
+		realx3(db.minPoint().x(), db.maxPoint().y(), db.minPoint().z())),
+	front_(
+		db.maxPoint(),
+		realx3(db.maxPoint().x(), db.minPoint().y(), db.maxPoint().z()),
+		realx3(db.minPoint().x(), db.minPoint().y(), db.maxPoint().z()),
+		realx3(db.minPoint().x(), db.maxPoint().y(), db.maxPoint().z()))
+{
+
+}
+
+
+FUNCTION_H
+pFlow::iIstream& pFlow::operator >>(
+    pFlow::iIstream& is, 
+    pFlow::domain& d)
+{
+    box b;
+    is>>b; 
+    d = domain(b);
+    return is;
+}
+
+FUNCTION_H
+pFlow::iOstream& pFlow::operator << (
+    pFlow::iOstream& os, 
+    const pFlow::domain& d)
+{
+    os<< d.domainBox();
+    return os;
+}
diff --git a/src/phasicFlow/structuredData/domain/domain.hpp b/src/phasicFlow/structuredData/domain/domain.hpp
new file mode 100644
index 00000000..f29b33ab
--- /dev/null
+++ b/src/phasicFlow/structuredData/domain/domain.hpp
@@ -0,0 +1,169 @@
+/*------------------------------- 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 __domain_hpp__
+#define __domain_hpp__
+
+
+#include "box.hpp"
+#include "plane.hpp"
+
+namespace pFlow
+{
+
+class domain
+{
+protected:
+	
+	box 		domainBox_;
+
+	/// -x
+	plane 		left_;
+
+	/// +x
+	plane 		right_;
+
+	/// -y
+	plane 		bottom_;
+
+	/// +y
+	plane		top_;
+
+	/// -z
+	plane 		rear_;
+
+	/// +z
+	plane 		front_;
+
+
+public:
+
+	// - type info
+	TypeInfoNV("domain");
+
+	//// - Constructors 
+		INLINE_FUNCTION_HD 
+		domain(){}
+
+		FUNCTION_H 
+		domain(const box& db);
+		
+		INLINE_FUNCTION_HD
+		domain(const domain&) = default;
+
+		INLINE_FUNCTION_HD
+		domain(domain&&) = default;
+
+		INLINE_FUNCTION_HD
+		domain& operator=(const domain&) = default;
+
+		INLINE_FUNCTION_HD
+		domain& operator=(domain&&) = default;
+
+		INLINE_FUNCTION_HD
+		~domain()=default;
+
+	//// - Methods 
+
+		INLINE_FUNCTION_HD
+		const auto& domainBox()const
+		{
+			return domainBox_;
+		}
+
+		INLINE_FUNCTION_HD
+		const auto& left()const
+		{
+			return left_;
+		}
+
+		INLINE_FUNCTION_HD
+		const auto& right()const
+		{
+			return right_;
+		}
+
+		INLINE_FUNCTION_HD
+		const auto& bottom()const
+		{
+			return bottom_;
+		}
+
+		INLINE_FUNCTION_HD
+		const auto& top()const
+		{
+			return top_;
+		}
+
+		INLINE_FUNCTION_HD
+		const auto& rear()const
+		{
+			return rear_;
+		}
+
+		INLINE_FUNCTION_HD
+		const auto& front()const
+		{
+			return front_;
+		}
+
+		INLINE_FUNCTION_H
+		const auto& boundaryPlane(uint32 i)const 
+		{
+			if(i==0) return left_;
+			if(i==1) return right_;
+			if(i==2) return bottom_;
+			if(i==3) return top_;
+			if(i==4) return rear_;
+			return front_;
+		}
+
+	
+}; // domain
+
+INLINE_FUNCTION_HD
+bool equal(const domain& d1, const domain& d2)
+{
+	return equal(d1.domainBox(), d2.domainBox());
+}
+
+INLINE_FUNCTION_HD
+bool equal(const domain& d1, const domain& d2, real tol)
+{
+	return equal(d1.domainBox(), d2.domainBox(), tol);
+}
+
+INLINE_FUNCTION_HD
+bool operator ==(const domain& d1, const domain& d2)
+{
+	return equal(d1, d2);
+}
+
+FUNCTION_H
+iIstream& operator >>(iIstream& is, domain& d);
+
+FUNCTION_H
+iOstream& operator << (iOstream& os, const domain& d);
+
+
+}
+
+
+#endif
diff --git a/src/phasicFlow/structuredData/domain/regularSimulationDomain.cpp b/src/phasicFlow/structuredData/domain/regularSimulationDomain.cpp
new file mode 100644
index 00000000..59ba7aa1
--- /dev/null
+++ b/src/phasicFlow/structuredData/domain/regularSimulationDomain.cpp
@@ -0,0 +1,195 @@
+#include <cstring>
+
+#include "regularSimulationDomain.hpp"
+#include "processors.hpp"
+#include "streams.hpp"
+
+bool pFlow::regularSimulationDomain::createBoundaryDicts()
+{
+    auto& boundaries = this->subDict("boundaries");
+    
+    this->addDict("regularBoundaries", boundaries);
+    auto& rbBoundaries = this->subDict("regularBoundaries");
+    
+	real neighborLength = boundaries.getVal<real>("neighborLength");
+
+	for(uint32 i=0; i<sizeOfBoundaries(); i++)
+	{
+		word bName = bundaryName(i);
+		if( !boundaries.containsDictionay(bName) )
+		{
+			fatalErrorInFunction<<"dictionary "<< bName<<
+			"does not exist in "<< boundaries.globalName()<<endl;
+			return false;
+		}
+		auto& bDict = rbBoundaries.subDict(bName);
+
+		if(!bDict.addOrKeep("neighborLength", neighborLength))
+		{
+			fatalErrorInFunction<<"error in adding neighborLength to "<< bName <<
+			"in dictionary "<< boundaries.globalName()<<endl;
+			return false;
+		}
+
+		if(!bDict.add("mirrorProcessorNo",(uint32) processors::globalRank()))
+		{
+			fatalErrorInFunction<<"error in adding mirrorProcessorNo to "<< bName <<
+			" in dictionary "<< boundaries.globalName()<<endl;
+			return false;
+		}
+		auto bType = bDict.getVal<word>("type");
+		uint32 mirrorIndex = 0;
+		if(bType == "periodic")
+		{
+			if(bName == bundaryName(0)) mirrorIndex = 1;
+			if(bName == bundaryName(1)) mirrorIndex = 0;
+			if(bName == bundaryName(2)) mirrorIndex = 3;
+			if(bName == bundaryName(3)) mirrorIndex = 2;
+			if(bName == bundaryName(4)) mirrorIndex = 5;
+			if(bName == bundaryName(5)) mirrorIndex = 4;
+
+			if(! bDict.addOrReplace("mirrorBoundaryIndex", mirrorIndex))
+			{
+				fatalErrorInFunction<<
+				"canno add entry mirroBoundaryIndex to dictionary "<<
+				bDict.globalName()<<endl;
+				return false;
+			}
+		}
+	}
+    
+    
+    return true;
+}
+
+bool pFlow::regularSimulationDomain::setThisDomain()
+{
+	thisDomain_ = domain(globalBox_);
+    return true;
+}
+
+pFlow::regularSimulationDomain::regularSimulationDomain
+(
+    systemControl& control
+)
+:
+    simulationDomain(control)
+{}
+
+bool pFlow::regularSimulationDomain::initialUpdateDomains(span<realx3> pointPos)
+{
+    initialNumPoints_ = pointPos.size();
+    if(!setThisDomain()) return false;
+    if(!createBoundaryDicts()) return false;
+    return true;
+}
+
+pFlow::uint32 pFlow::regularSimulationDomain::initialNumberInThis() const
+{
+    return initialNumPoints_;
+}
+
+/*bool pFlow::regularSimulationDomain::updateDomains(
+    span<realx3> pointPos,
+    pFlagTypeHost flags)
+{	
+    return true;
+}*/
+
+pFlow::uint32 pFlow::regularSimulationDomain::numberToBeImported() const
+{
+	return 0;	
+}
+
+pFlow::uint32 pFlow::regularSimulationDomain::numberToBeExported() const
+{
+    return 0;
+}
+
+bool pFlow::regularSimulationDomain::initialTransferBlockData
+(
+	span<char> src, 
+	span<char> dst,
+	size_t sizeOfElement
+) const
+{
+	size_t requiredSize = sizeOfElement*initialNumberInThis();
+	if(dst.size() < requiredSize)
+	{
+		fatalErrorInFunction<< 
+		"size of destination data block [in byte]"<< dst.size()<<
+		"is smaller than the required size [in byte]"<< requiredSize<<endl;
+		return false;
+	}
+	
+	if(src.size() < requiredSize )
+	{	
+		fatalErrorInFunction<< 
+		"size of source data block [in byte]"<< src.size()<<
+		"is smaller than the required size [in byte]"<< requiredSize<<endl;
+		return false;
+
+	}
+
+	std::memcpy(dst.data(), src.data(), requiredSize);
+
+    return true;
+}
+
+bool pFlow::regularSimulationDomain::initialTransferBlockData
+(
+    span<realx3> src, 
+    span<realx3> dst
+) const
+{
+    return initialTransferBlockData(
+        charSpan(src), 
+        charSpan(dst), 
+        sizeof(realx3)); 
+}
+
+bool pFlow::regularSimulationDomain::initialTransferBlockData
+(
+    span<real> src, 
+    span<real> dst
+) const
+{
+    return initialTransferBlockData(
+        charSpan(src), 
+        charSpan(dst), 
+        sizeof(real)); 
+}
+
+bool pFlow::regularSimulationDomain::initialTransferBlockData
+(
+    span<uint32> src, 
+    span<uint32> dst
+) const
+{
+    return initialTransferBlockData(
+        charSpan(src), 
+        charSpan(dst), 
+        sizeof(uint32)); 
+}
+
+bool pFlow::regularSimulationDomain::initialTransferBlockData
+(
+    span<int32> src, 
+    span<int32> dst
+) const
+{
+    return initialTransferBlockData(
+        charSpan(src), 
+        charSpan(dst), 
+        sizeof(int32)); 
+}
+
+const pFlow::dictionary &pFlow::regularSimulationDomain::thisBoundaryDict() const
+{
+    return this->subDict("regularBoundaries");
+}
+
+bool pFlow::regularSimulationDomain::requiresDataTransfer()const
+{
+    return false;
+}
diff --git a/src/phasicFlow/structuredData/domain/regularSimulationDomain.hpp b/src/phasicFlow/structuredData/domain/regularSimulationDomain.hpp
new file mode 100644
index 00000000..7eeb888a
--- /dev/null
+++ b/src/phasicFlow/structuredData/domain/regularSimulationDomain.hpp
@@ -0,0 +1,89 @@
+
+#ifndef __regularSimulationDomain_hpp__
+#define __regularSimulationDomain_hpp__
+
+#include "simulationDomain.hpp"
+
+namespace pFlow
+{
+
+class regularSimulationDomain
+:
+	public simulationDomain
+{
+protected:
+
+	uint32 		initialNumPoints_=0;
+
+	bool createBoundaryDicts() override;
+
+	bool setThisDomain()override;
+
+public:
+
+	TypeInfo("simulationDomain<regular>");
+
+	regularSimulationDomain(systemControl& control);
+
+	virtual
+	~regularSimulationDomain()=default;
+	
+	add_vCtor
+	(
+		simulationDomain,
+		regularSimulationDomain,
+		systemControl
+	);
+
+    bool initialUpdateDomains(span<realx3> pointPos) override;
+
+    uint32 initialNumberInThis()const override;
+
+	bool initialThisDomainActive()const override
+	{
+		return true;
+	}
+
+	/*bool updateDomains(
+		span<realx3> pointPos,
+        pFlagTypeHost flags) override;*/
+   
+	uint32 numberToBeImported()const override;
+
+	uint32 numberToBeExported()const override;
+
+	bool initialTransferBlockData(
+		span<char> src, 
+		span<char> dst,
+		size_t sizeOfElement) const override;
+
+
+    /// @brief 
+    /// @param src 
+    /// @param dst 
+    /// @return 
+    bool initialTransferBlockData(
+        span<realx3> src,
+        span<realx3> dst) const override;
+
+    bool initialTransferBlockData(
+        span<real> src,
+        span<real> dst) const override;
+
+    bool initialTransferBlockData(
+        span<uint32> src,
+        span<uint32> dst) const override;
+
+    bool initialTransferBlockData(
+        span<int32> src,
+        span<int32> dst) const override;
+    
+	
+	const dictionary& thisBoundaryDict()const override;
+
+	bool requiresDataTransfer() const override;
+};
+
+}
+
+#endif //__regularSimulationDomain_hpp__
diff --git a/src/phasicFlow/structuredData/domain/simulationDomain.cpp b/src/phasicFlow/structuredData/domain/simulationDomain.cpp
new file mode 100644
index 00000000..2930b1b4
--- /dev/null
+++ b/src/phasicFlow/structuredData/domain/simulationDomain.cpp
@@ -0,0 +1,79 @@
+/*------------------------------- 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 "simulationDomain.hpp"
+#include "pFlowProcessors.hpp"
+#include "systemControl.hpp"
+#include "vocabs.hpp"
+
+pFlow::simulationDomain::simulationDomain(systemControl& control)
+:
+	fileDictionary
+	(
+		objectFile
+		(
+			domainFile__,
+			"",
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_NEVER
+		),
+		&control.settings()
+	),
+    globalBox_(subDict("globalBox"))
+{
+    
+}
+
+pFlow::domain pFlow::simulationDomain::extendThisDomain
+(
+	const realx3 &lowerPointExtension, 
+	const realx3 &upperPointExtension
+) const
+{
+    realx3 minP = thisDomain().domainBox().minPoint() + lowerPointExtension;
+	realx3 maxP = thisDomain().domainBox().maxPoint() + upperPointExtension;
+	return domain({minP, maxP});
+}
+
+pFlow::uniquePtr<pFlow::simulationDomain>
+	pFlow::simulationDomain::create(systemControl &control)
+{
+	word sType = angleBracketsNames(
+        "simulationDomain", 
+        pFlowProcessors().localRunTypeName());
+
+
+	if( systemControlvCtorSelector_.search(sType) )
+	{
+		return systemControlvCtorSelector_[sType] (control);
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< sType << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			systemControlvCtorSelector_
+		);
+		fatalExit;
+	}
+    return nullptr;
+}
diff --git a/src/phasicFlow/structuredData/domain/simulationDomain.hpp b/src/phasicFlow/structuredData/domain/simulationDomain.hpp
new file mode 100644
index 00000000..af49ee21
--- /dev/null
+++ b/src/phasicFlow/structuredData/domain/simulationDomain.hpp
@@ -0,0 +1,210 @@
+/*------------------------------- 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 __simulationDomain_hpp__
+#define __simulationDomain_hpp__
+
+#include <array>
+
+#include "domain.hpp"
+#include "fileDictionary.hpp"
+#include "span.hpp"
+#include "streams.hpp"
+#include "virtualConstructor.hpp"
+#include "pointFlag.hpp"
+
+namespace pFlow
+{
+
+class systemControl;
+
+
+class simulationDomain
+:
+	public fileDictionary
+{
+private:
+
+static inline constexpr uint32 sizeOfBoundaries_ = 6;
+
+static 
+inline const std::array<word,6>  boundaryNames_ = 
+{
+	"left", "right", 
+	"bottom", "top",
+	"rear", "front"
+};
+
+protected:	
+
+	//fileDictionary 	globalDomainDict_ ;
+
+	/// @brief acutal limits of the simulation domain
+	box 			globalBox_;
+
+	/// @brief the actual limits of this processor domain 
+	domain 			thisDomain_;
+
+	bool 			boundariesSet_ = false;
+	
+	virtual bool    createBoundaryDicts() = 0;
+
+	virtual bool    setThisDomain() = 0;
+
+public:
+
+	// - type info
+	TypeInfo("simulationDomain");
+
+	/// Constrcut from components 
+	simulationDomain(systemControl& control);
+	
+	/// Destructor 
+	virtual 
+	~simulationDomain() = default;
+	
+
+	create_vCtor
+	(
+		simulationDomain,
+		systemControl,
+		(systemControl& control),
+		(control)	
+	);
+
+	virtual 
+	const dictionary& thisBoundaryDict()const = 0;
+	
+    virtual 
+    bool initialUpdateDomains(span<realx3> pointPos) = 0;
+
+    virtual
+    uint32 initialNumberInThis()const = 0;
+
+	virtual 
+	bool initialThisDomainActive()const = 0;
+
+    virtual 
+	bool initialTransferBlockData(
+		span<char> src, 
+		span<char> dst,
+		size_t sizeOfElement) const = 0;
+    
+    virtual 
+    bool initialTransferBlockData(
+        span<realx3> src,
+        span<realx3> dst) const = 0;
+    
+    virtual
+    bool initialTransferBlockData(
+        span<real> src,
+        span<real> dst) const = 0;
+
+    virtual
+    bool initialTransferBlockData(
+        span<uint32> src,
+        span<uint32> dst) const = 0;
+    
+    virtual 
+    bool initialTransferBlockData(
+        span<int32> src,
+        span<int32> dst) const = 0;
+    
+    
+    template<typename T>
+    bool initialTransferBlockData(
+        span<T> src,
+        span<T> dst )const
+    {
+        size_t el=sizeof(T);
+        return initialTransferBlockData
+        (
+            charSpan(src), 
+            charSpan(dst), 
+            el
+        );
+    } 
+
+
+
+    /// @brief Number of points to be imported after updating domains 
+	/// @return number of points
+	virtual
+	uint32 numberToBeImported()const = 0;
+
+    virtual 
+    uint32 numberToBeExported()const = 0;
+
+	
+
+	virtual 
+	bool requiresDataTransfer() const = 0;
+
+	inline 
+	const auto& thisDomain()const
+	{
+		return thisDomain_;
+	}
+
+	
+	domain extendThisDomain(
+		const realx3& lowerPointExtension, 
+		const realx3& upperPointExtension)const;
+
+	inline 
+	const auto& globalBoundaryDict()const
+	{
+		return static_cast<const fileDictionary&>(*this);
+	}
+
+	inline
+	const dictionary& boundaryDict(uint32 i)const
+	{
+		return thisBoundaryDict().subDict(bundaryName(i));
+	}
+	
+	inline
+	const auto& boundaryPlane(uint32 i)const
+	{
+		return thisDomain_.boundaryPlane(i);
+	}
+
+	static inline
+	const word& bundaryName(uint32 i)
+	{
+		return boundaryNames_[i];
+	}
+
+	static inline 
+	uint32 sizeOfBoundaries() 
+	{
+		return boundaryNames_.size();
+	}
+	
+	static
+	uniquePtr<simulationDomain> create(systemControl& control);
+
+}; // simulationDomain
+
+
+
+}
+
+
+#endif //__simulationDomain_hpp__
diff --git a/src/phasicFlow/structuredData/domain/subDomain.hpp b/src/phasicFlow/structuredData/domain/subDomain.hpp
new file mode 100644
index 00000000..b90ccb61
--- /dev/null
+++ b/src/phasicFlow/structuredData/domain/subDomain.hpp
@@ -0,0 +1,104 @@
+/*------------------------------- 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 __subDomain_hpp__
+#define __subDomain_hpp__
+
+#include "domain.hpp"
+
+
+namespace pFlow
+{
+
+class subDomain
+{
+protected:	
+
+	/// the actual limits of global domain 
+	const domain& 		globalDomain_;
+
+	/// @brief dictionary of boundaries
+	const dictionary& 	boundaryDict_;
+
+
+	/// the actual limits of this processor domain 
+	domain 		thisDomain_;
+
+
+
+public:
+
+	// - type info
+	TypeInfo("subDomain");
+
+
+	subDomain(
+		const domain& gDomain,
+		const domain& thisD, 
+		const dictionary& bDicts)
+	:
+		globalDomain_(gDomain),
+		thisDomain_(thisD),
+		boundaryDict_(bDicts)
+	{}
+	
+	const auto& thisDomain()const
+	{
+		return thisDomain_;
+	}
+
+	const dictionary& leftDict()const
+	{
+		return boundaryDict_.subDict("left");
+	}
+
+	const dictionary& rightDict()const
+	{
+		return boundaryDict_.subDict("right");
+	}
+
+	const dictionary& bottomDict()const
+	{
+		return boundaryDict_.subDict("bottom");;
+	}
+
+	const dictionary& topDict()const
+	{
+		return boundaryDict_.subDict("top");;
+	}
+
+	const dictionary& rearDict()const
+	{
+		return boundaryDict_.subDict("rear");;
+	}
+
+	const dictionary& frontDict()const
+	{
+		return boundaryDict_.subDict("front");;
+	}
+	
+}; // subDomain
+
+
+
+}
+
+
+#endif //__subDomain_hpp__
diff --git a/src/phasicFlow/structuredData/iBox/iBox.hpp b/src/phasicFlow/structuredData/iBox/iBox.hpp
index 89e7b225..b9105047 100644
--- a/src/phasicFlow/structuredData/iBox/iBox.hpp
+++ b/src/phasicFlow/structuredData/iBox/iBox.hpp
@@ -43,7 +43,7 @@ protected:
 public:
 
 	// - type info
-	TypeInfoTemplateNV("iBox", intType);
+	TypeInfoTemplateNV11("iBox", intType);
 
 	//// - Constructors 
 		INLINE_FUNCTION_HD 
diff --git a/src/phasicFlow/structuredData/infinitePlane/infinitePlane.cpp b/src/phasicFlow/structuredData/infinitePlane/infinitePlane.cpp
new file mode 100644
index 00000000..d9f41a38
--- /dev/null
+++ b/src/phasicFlow/structuredData/infinitePlane/infinitePlane.cpp
@@ -0,0 +1,64 @@
+/*------------------------------- 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 "infinitePlane.hpp"
+
+pFlow::infinitePlane::infinitePlane
+(
+  const realx3& p1, 
+  const realx3& p2, 
+  const realx3& p3
+)
+{
+	auto ln = cross(p2-p1, p3-p1);
+
+	if( equal(ln.length(),0.0) )
+	{
+		fatalErrorInFunction<<
+		"invalid input to form a infinte wall "<< realx3x3(p1,p2,p3)<<endl;
+		fatalExit;
+	}
+	normal_ = normalize(ln);
+	d_ = -dot(normal_, p1);
+}
+
+bool pFlow::infinitePlane::write(iOstream& os)const
+{
+	os.writeWordEntry("normal", normal_);
+	os.writeWordEntry("d", d_);
+	return os.check(FUNCTION_NAME);
+}
+
+bool pFlow::infinitePlane::read(iIstream & is)
+{
+	if(!is.nextData<realx3>("normal", normal_)) return false;
+	if(!is.nextData<real>("d", d_)) return false;
+	return true;
+}
+
+bool pFlow::infinitePlane::validPlane3
+(
+  const realx3& p1, 
+  const realx3& p2, 
+  const realx3& p3
+)
+{
+  return !equal(cross(p2-p1, p3-p1).length(), 0.0);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/infinitePlane/infinitePlane.hpp b/src/phasicFlow/structuredData/infinitePlane/infinitePlane.hpp
new file mode 100644
index 00000000..28c548bc
--- /dev/null
+++ b/src/phasicFlow/structuredData/infinitePlane/infinitePlane.hpp
@@ -0,0 +1,207 @@
+/*------------------------------- 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 __infinitePlane_hpp__
+#define __infinitePlane_hpp__
+
+#include "types.hpp"
+//#include "dictionary.hpp"
+#include "iIstream.hpp"
+#include "iOstream.hpp"
+
+namespace pFlow
+{
+
+class  infinitePlane
+{
+protected:
+	
+	/// normal vector 
+	realx3 	normal_{1,0,0};
+	
+	/// distance value 
+	real  	d_ = 0;
+
+public:
+
+	// - type info
+	TypeInfoNV("infinitePlane");
+
+	//// - Constructors 
+		
+		/// Default
+		INLINE_FUNCTION_HD 
+		infinitePlane(){}
+
+		/// From components
+		INLINE_FUNCTION_HD 
+		infinitePlane(const realx3& normal, const real& d)
+		:
+			normal_(normal),
+			d_(d)
+		{}
+
+		INLINE_FUNCTION_HD
+		infinitePlane(const realx3& normal, const realx3& p)
+		:
+			normal_(normal),
+			d_(-dot(normal,p))
+		{}
+
+		/// From 3 points
+		infinitePlane(const realx3& p1, const realx3& p2, const realx3& p3);
+		
+		FUNCTION_HD
+		infinitePlane(const infinitePlane&) = default;
+
+		FUNCTION_HD
+		infinitePlane(infinitePlane&&) = default;
+
+		FUNCTION_HD
+		infinitePlane& operator=(const infinitePlane&) = default;
+
+		FUNCTION_HD
+		infinitePlane& operator=(infinitePlane&&) = default;
+
+		~infinitePlane()=default;
+
+		/*FUNCTION_H
+		infinitePlane(const dictionary& dict);
+
+		FUNCTION_H
+		infinitePlane(iIstream& is);*/
+	
+
+	//// - Methods
+
+		INLINE_FUNCTION_HD
+		real pointFromPlane(const realx3& p)const
+		{
+			return dot(normal_, p) + d_;
+		}
+
+		INLINE_FUNCTION_HD
+		bool pointInPositiveSide(const realx3& p)const
+		{
+			return pointFromPlane(p)>=0;
+		}
+
+		INLINE_FUNCTION_HD
+		bool inPositiveDistance(const realx3& p, real dist)const
+		{	
+			real d = pointFromPlane(p);
+			return d >= 0.0 && d <= dist;
+		}
+
+		INLINE_FUNCTION_HD
+		bool inNegativeDistance(const realx3& p, real dist)const
+		{	
+			real d = pointFromPlane(p);
+			return d < 0.0 && d <= -dist;
+		}
+
+
+		INLINE_FUNCTION_HD
+		bool pointInNegativeSide(const realx3& p)const
+		{
+			return pointFromPlane(p)<0;
+		}
+
+		INLINE_FUNCTION_HD
+		bool pointOnPlane(const realx3& p)const
+		{
+			return equal(pointFromPlane(p),0.0);
+		}
+
+		INLINE_FUNCTION_HD
+		realx3 projectPoint(const realx3& p)const
+		{
+			real t = -(dot(normal_, p) + d_);
+			return t*normal_ + p;
+		}
+
+        INLINE_FUNCTION_HD
+        bool parallel(const infinitePlane& pln)const
+        {
+            return  equal(normal_, pln.normal_) ||
+                    equal(normal_,-pln.normal_);
+        }
+
+        INLINE_FUNCTION_HD
+        bool parallelTouch(const infinitePlane& pln)const
+        {
+            if(equal(normal_, pln.normal_) && equal(d_, pln.d_))return true;
+            if(equal(normal_,-pln.normal_) && equal(d_,-pln.d_))return true;
+            return false;
+        }
+
+        INLINE_FUNCTION_HD
+        const auto& normal()const
+        {
+            return normal_;
+        }
+
+        INLINE_FUNCTION_HD
+        const auto& d()const
+        {
+            return d_;
+        }
+
+	//// - IO operation 
+
+		FUNCTION_H
+		bool write(iOstream& os)const;
+
+		bool read(iIstream & is);
+
+		/*FUNCTION_H
+		bool read(iIstream & is);
+
+		FUNCTION_H
+		bool write(iOstream& os)const;
+
+		FUNCTION_H
+		bool read(const dictionary& dict);
+
+		FUNCTION_H
+		bool write(dictionary& dict)const;*/
+
+		static bool validPlane3(
+			const realx3& p1, 
+			const realx3& p2, 
+			const realx3& p3);
+};
+
+/*FUNCTION_H
+iIstream& operator >>(iIstream& is, box& b);
+
+FUNCTION_H
+iOstream& operator << (iOstream& os, const box& b);
+
+INLINE_FUNCTION_HD
+box extendBox(const box& b, const realx3& dl)
+{
+	return box(b.minPoint()-dl , b.maxPoint()+dl);
+}*/
+
+}
+
+
+#endif // __infinitePlane_hpp__
diff --git a/src/phasicFlow/structuredData/line/line.hpp b/src/phasicFlow/structuredData/line/line.hpp
index a8a302e2..375588a4 100755
--- a/src/phasicFlow/structuredData/line/line.hpp
+++ b/src/phasicFlow/structuredData/line/line.hpp
@@ -55,19 +55,27 @@ public:
 		FUNCTION_HD
 		line(const realx3 &lp1, const realx3 &lp2);
 
+		INLINE_FUNCTION_HD
+		line(const realx3 &v21, const realx3 &p1, bool)
+		:
+			v21_(v21),
+			p1_(p1)
+		{}
+
+
 		FUNCTION_H
 		line(const dictionary& dict);
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		line(const line& src) = default;
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		line(line&& src) = default;
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		line& operator = (const line&) = default;
 
-		FUNCTION_HD
+		INLINE_FUNCTION_HD
 		line& operator = (line&&) = default;
 
 	
diff --git a/src/phasicFlow/structuredData/plane/plane.cpp b/src/phasicFlow/structuredData/plane/plane.cpp
new file mode 100644
index 00000000..547c9cc0
--- /dev/null
+++ b/src/phasicFlow/structuredData/plane/plane.cpp
@@ -0,0 +1,66 @@
+/*------------------------------- 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 "plane.hpp"
+
+pFlow::plane::plane
+(
+	const realx3& p1, 
+	const realx3& p2, 
+	const realx3& p3, 
+	const realx3& p4
+)
+:
+	infinitePlane(p1,p2,p3),
+	p1_(p1),
+	p2_(p2),
+	p3_(p3),
+	p4_(p4)
+{
+
+	if(!pointOnPlane(p4))
+	{
+		fatalErrorInFunction<<
+		"points "<< realx4x3(p1,p2,p3,p4)<<" do not form a planner surface"<<endl;
+		fatalExit;
+	}
+}
+
+
+pFlow::plane pFlow::plane::parallelPlane(real distance)const
+{
+	auto pp1 = line(normal_, p1_, true).point(distance);
+	auto pp2 = line(normal_, p2_, true).point(distance);
+	auto pp3 = line(normal_, p3_, true).point(distance);
+	auto pp4 = line(normal_, p4_, true).point(distance);
+
+	return plane(pp1, pp2, pp3, pp4);
+}
+
+bool pFlow::plane::validPlane4(
+    const realx3 &p1,
+    const realx3 &p2,
+    const realx3 &p3,
+    const realx3 &p4)
+{
+	if( !validPlane3(p1,p2,p3)) return false;
+	if( !infinitePlane(p1,p2,p3).pointOnPlane(p4)) return false;
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/plane/plane.hpp b/src/phasicFlow/structuredData/plane/plane.hpp
new file mode 100644
index 00000000..93930a85
--- /dev/null
+++ b/src/phasicFlow/structuredData/plane/plane.hpp
@@ -0,0 +1,142 @@
+/*------------------------------- 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 __plane_hpp__
+#define __plane_hpp__
+
+#include "infinitePlane.hpp"
+#include "line.hpp"
+
+namespace pFlow
+{
+
+class plane
+:
+	public infinitePlane
+{
+protected:
+	
+	/// First point 
+	realx3 p1_;
+	
+	/// Second point 
+	realx3 p2_;
+	
+	/// Third point 
+	realx3 p3_;
+	
+	/// Fourth point 
+	realx3 p4_;
+
+public:
+
+	INLINE_FUNCTION_HD
+	plane(){}
+
+	plane(
+		const realx3& p1, 
+		const realx3& p2, 
+		const realx3& p3, 
+		const realx3& p4);
+
+	INLINE_FUNCTION_HD
+	plane(const plane&) = default;
+
+	INLINE_FUNCTION_HD
+	plane(plane&&) = default;
+
+	INLINE_FUNCTION_HD
+	plane& operator = (const plane&) = default;
+
+	INLINE_FUNCTION_HD
+	plane& operator =( plane&&)=default;
+	
+	INLINE_FUNCTION_HD
+	~plane()=default;
+
+	INLINE_FUNCTION_HD
+	const realx3& p1()const
+	{
+		return p1_;
+	}
+
+	INLINE_FUNCTION_HD
+	const realx3& p2()const
+	{
+		return p2_;
+	}
+
+	INLINE_FUNCTION_HD
+	const realx3& p3()const
+	{
+		return p3_;
+	}
+
+	INLINE_FUNCTION_HD
+	const realx3& p4()const
+	{
+		return p4_;
+	}
+
+	INLINE_FUNCTION_HD
+	line line1()const
+	{
+		return line(p1_,p2_);
+	}
+
+	INLINE_FUNCTION_HD
+	line line2()const
+	{
+		return line(p2_,p3_);
+	}
+
+	INLINE_FUNCTION_HD
+	line line3()const
+	{
+		return line(p3_,p4_);
+	}
+
+	INLINE_FUNCTION_HD
+	line line4()const
+	{
+		return line(p4_,p1_);
+	}
+
+	// return the parallel plane to this plane 
+	plane parallelPlane(real distance)const;
+
+	infinitePlane infPlane()const
+	{
+		return infinitePlane(normal(), d());
+	}
+
+
+	static 
+	bool validPlane4(
+		const realx3& p1, 
+		const realx3& p2, 
+		const realx3& p3, 
+		const realx3& p4);
+
+};
+
+}
+
+#endif //__plane_hpp__
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/pointStructure/internalPoints.cpp b/src/phasicFlow/structuredData/pointStructure/internalPoints.cpp
new file mode 100644
index 00000000..26c477c1
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/internalPoints.cpp
@@ -0,0 +1,371 @@
+/*------------------------------- 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 "Time.hpp"
+#include "internalPoints.hpp"
+#include "domain.hpp"
+#include "Vectors.hpp"
+#include "anyList.hpp"
+#include "internalPointsKernels.hpp"
+
+void pFlow::internalPoints::syncPFlag()const
+{
+	if(!pFlagSync_)
+	{
+		pFlagsH_ = pFlagsD_.clone<DefaultHostExecutionSpace>();
+		pFlagSync_ = true;
+	}
+}
+
+bool pFlow::internalPoints::deletePoints(const uint32Vector_D& delPoints)
+{
+	
+	if(delPoints.empty())return true;
+
+	auto oldRange = pFlagsD_.activeRange();
+	auto oldSize  = size();
+
+    if(!pFlagsD_.deletePoints(delPoints.deviceView()))
+	{
+		fatalErrorInFunction<<
+		"Error in deleting points from internal points"<<endl;
+		return false;
+	}
+	unSyncFlag();
+	
+	auto newRange = pFlagsD_.activeRange();
+	auto newSize  = size();
+
+	anyList varList;
+
+	varList.emplaceBack(
+		message::eventName(message::ITEM_DELETE), 
+		delPoints);
+	message msg(message::ITEM_DELETE);
+
+	if(oldSize!= newSize)
+	{
+		msg.add(message::SIZE_CHANGED); 
+		varList.emplaceBack(
+			message::eventName(message::SIZE_CHANGED),
+			newSize);
+	}
+	
+	if(oldRange!=newRange)
+	{
+		msg.add(message::RANGE_CHANGED);
+		varList.emplaceBack(
+			message::eventName(message::RANGE_CHANGED),
+			newRange);
+	}
+	auto iter = time().currentIter();
+	auto t = time().currentTime();
+	auto dt = time().dt();
+
+	if( !notify(iter, t, dt, msg, varList) )
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+
+	return true;
+}
+
+bool pFlow::internalPoints::changePointsFlagPosition
+(
+	const uint32Vector_D& changePoints,
+	realx3 transferVector, 
+	uint32 fromBoundaryIndex,
+	uint32 toBoundaryIndex
+)
+{
+	if(toBoundaryIndex>5)
+	{
+		fatalErrorInFunction<<
+		"Invalid boundary index "<< toBoundaryIndex<<endl;
+		return false;
+	}
+
+	// change the flag 
+	pFlagsD_.changeFlags(changePoints.deviceView(), toBoundaryIndex);
+	unSyncFlag();
+
+	// change the position 
+	pFlow::internalPointsKernels::changePosition
+	(
+		pointPosition_.deviceViewAll(),
+		changePoints.deviceView(),
+		transferVector
+	);
+
+	anyList varList;
+	message msg;
+	
+	varList.emplaceBack(
+		message::eventName(message::ITEM_FLAGCHANGED),
+		changePoints);
+	varList.emplaceBack("fromBoundaryIndex", fromBoundaryIndex);
+	varList.emplaceBack("toBoundaryIndex", toBoundaryIndex);
+
+	msg.add(message::ITEM_FLAGCHANGED);
+
+	if( !notify(
+		time().currentIter(), 
+		time().currentTime(), 
+		time().dt(),
+		msg,
+		varList))
+	{
+		fatalErrorInFunction<<
+		"Error in notify for item transfer from "<< fromBoundaryIndex<<
+		" to "<<toBoundaryIndex<< " boundary"<<endl;
+		return false;
+	}
+
+	return true;
+}
+
+
+
+pFlow::internalPoints::internalPoints()
+:
+	subscriber("internalPoints"),
+	pointPosition_("internalPoints", "internalPoints", initialCapacity_, 0, RESERVE()),
+	pFlagsD_(initialCapacity_, 0 , 0)
+{}
+
+
+pFlow::internalPoints::internalPoints
+(
+	const realx3Vector& posVec
+)
+:
+	subscriber("internalPoints"),
+	pointPosition_
+	(
+		"internalPoints", 
+		"internalPoints", 
+		posVec.capacity(), 
+		0, 
+		RESERVE()
+	),
+	pFlagsD_
+	(
+		static_cast<uint32>(posVec.capacity()), 
+		static_cast<uint32>(0),
+		static_cast<uint32>(posVec.size())
+	)
+{
+
+	pointPosition_.assign(posVec);
+
+}
+
+
+const pFlow::pFlagTypeDevice& 
+	pFlow::internalPoints::activePointsMaskDevice() const 
+{
+	return pFlagsD_;
+}
+
+
+const pFlow::pFlagTypeHost&
+	pFlow::internalPoints::activePointsMaskHost() const
+{
+	syncPFlag();
+	return pFlagsH_;
+}
+
+FUNCTION_H
+const typename pFlow::internalPoints::PointsType& 
+    pFlow::internalPoints::pointPosition()const
+{
+    return pointPosition_;
+}
+
+FUNCTION_H
+typename pFlow::internalPoints::PointsType&
+	pFlow::internalPoints::pointPosition()
+{
+    return pointPosition_;
+}
+
+typename pFlow::internalPoints::PointsTypeHost
+    pFlow::internalPoints::activePointsHost() const
+{
+    auto maskH = activePointsMaskHost();
+    auto pointsH = pointPositionHost();
+
+	PointsTypeHost aPoints
+	(
+		pointPosition_.name(),
+		pointPosition_.fieldKey(),
+		maskH.numActive(), 
+		maskH.numActive(),
+		RESERVE()
+	);
+
+    auto aRange = maskH.activeRange();
+    uint32 n = 0;
+	
+    for(auto i=aRange.start(); i<aRange.end(); i++)
+    {
+
+        if( maskH.isActive(i) )
+        {
+            aPoints[n] = pointsH[i];
+            n++;
+        }
+    }
+
+    return aPoints;
+}
+
+bool pFlow::internalPoints::deletePoints
+(
+	scatteredFieldAccess<uint32, memory_space> delPoints
+)
+{
+	if(!pFlagsD_.deletePoints(delPoints))
+	{
+		fatalErrorInFunction<<
+		"Error in deleting points from internal points"<<endl;
+		return false;
+	}
+	unSyncFlag();
+	WARNING<<"Notify the observersin in internalPoints"<<END_WARNING;
+
+    return true;
+}
+
+FUNCTION_H
+pFlow::uint32 pFlow::internalPoints::updateFlag
+(
+	const domain& dm, 
+	const std::array<real,6>& dist
+)
+{
+	unSyncFlag();
+	return pFlagsD_.markPointRegions
+	(
+		dm,
+		pointPosition_.deviceViewAll(),
+		dist[0],
+		dist[1],
+		dist[2],
+		dist[3],
+		dist[4],
+		dist[5]
+	);	
+}
+
+void pFlow::internalPoints::fillNeighborsLists
+(
+	ViewType1D<uint32, memory_space> leftList, 
+	ViewType1D<uint32, memory_space> rightList, 
+	ViewType1D<uint32, memory_space> bottomList, 
+	ViewType1D<uint32, memory_space> topList, 
+	ViewType1D<uint32, memory_space> rearList, 
+	ViewType1D<uint32, memory_space> frontList
+)
+{
+	pFlagsD_.fillNeighborsLists(
+		leftList,
+		rightList,
+		bottomList,
+		topList,
+		rearList,
+		frontList);
+		
+}
+
+FUNCTION_H
+bool pFlow::internalPoints::read
+(
+	iIstream& is
+)
+{
+	
+	PointsTypeHost fRead(pointPosition_.name(), pointPosition_.fieldKey());
+
+	if( !fRead.read(is))
+	{
+		fatalErrorInFunction<<
+		"Error in reading pointPosition from stream "<< is.name()<<endl;
+		return false;
+	}
+
+	pointPosition_.assignFromHost(fRead);
+
+	pFlagsD_ = pFlagTypeDevice(pointPosition_.capacity(), 0, pointPosition_.size());
+	unSyncFlag();
+	syncPFlag();
+
+	return true;
+}
+
+
+FUNCTION_H
+bool pFlow::internalPoints::write
+(
+	iOstream& os
+)const
+{
+	auto aPoints = this->activePointsHost();
+	return aPoints.write(os);
+}
+
+FUNCTION_H
+bool pFlow::internalPoints::read
+(
+	iIstream& is, 
+	const IOPattern& iop
+)
+{
+	
+	PointsTypeHost fRead(pointPosition_.name(), pointPosition_.fieldKey());
+
+	if( !fRead.read(is, iop))
+	{
+		fatalErrorInFunction<<
+		"Error in reading pointPosition from stream "<< is.name()<<endl;
+		return false;
+	}
+
+	pointPosition_.assignFromHost(fRead);
+
+	createDeviceFlag(pointPosition_.capacity(), 0, pointPosition_.size());
+	syncPFlag();
+
+	return true;
+}
+		
+
+
+FUNCTION_H
+bool pFlow::internalPoints::write
+(
+	iOstream& os, 
+	const IOPattern& iop
+)const
+{
+	auto aPoints = activePointsHost();
+	return aPoints.write(os,iop);	
+}
diff --git a/src/phasicFlow/structuredData/pointStructure/internalPoints.hpp b/src/phasicFlow/structuredData/pointStructure/internalPoints.hpp
new file mode 100644
index 00000000..71b79877
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/internalPoints.hpp
@@ -0,0 +1,278 @@
+/*------------------------------- 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 __internalPoints_hpp__
+#define __internalPoints_hpp__
+
+#include "subscriber.hpp"
+#include "Vectors.hpp"
+#include "VectorSingles.hpp"
+#include "Fields.hpp"
+#include "pointFlag.hpp"
+
+
+
+namespace pFlow
+{
+
+class domain;
+class boundaryBase;
+class Time; 
+
+class internalPoints
+:
+	public subscriber
+{
+public:
+	
+	inline static const uint32 initialCapacity_ = 10000;
+
+	using PointsType 		= realx3Field_D;
+
+	using PointsTypeHost 	= typename PointsType::FieldTypeHost;
+
+	using device_type 		= typename PointsType::device_type;
+
+	using memory_space 		= typename PointsType::memory_space;
+
+	using execution_space 	= typename PointsType::execution_space;
+
+private:
+
+	//// - friend et al.
+	
+		friend boundaryBase;
+
+	//// - data members
+
+		/// Position of points on device
+		PointsType 					pointPosition_;
+
+		/// flag of points on device
+		mutable pFlagTypeDevice 	pFlagsD_;
+
+		/// flag of points on host
+		mutable pFlagTypeHost 		pFlagsH_;
+
+		/// if both host and device flags sync
+		mutable bool 				pFlagSync_ = false;
+	
+	//// - protected members		
+
+		bool deletePoints(const uint32Vector_D& delPoints);
+
+		bool changePointsFlagPosition(
+			const uint32Vector_D& changePoints,
+			realx3 transferVector, 
+			uint32 fromBoundaryIndex,
+			uint32 toBoundaryIndex);
+
+protected:
+	
+	void syncPFlag()const;
+
+	inline
+	void unSyncFlag()
+	{
+		pFlagSync_ = false;
+	}
+
+	inline 
+	void createDeviceFlag(uint32 cap, uint32 start, uint32 end)
+	{
+		unSyncFlag();
+		pFlagsD_ = pFlagTypeDevice(cap, start, end);
+	}
+
+public:
+
+	//friend class dynamicinternalPoints;
+	
+	// - type info
+	TypeInfo("internalPoints");
+	
+
+	//// - Constructors 
+
+		// - an empty internalPoints, good for reading from file 
+		internalPoints();
+
+		
+		/// Construct from point positions, assume all points are active
+		explicit internalPoints(const realx3Vector& posVec);
+
+		/// No Copy construct
+		internalPoints(const internalPoints&) = delete;
+
+		/// Move construct 
+		internalPoints(internalPoints&&) = default;
+
+		/// No Copy assignment 
+		internalPoints& operator=(const internalPoints&) = delete;
+
+		/// Move assignment 
+		internalPoints& operator=(internalPoints&&) = default;
+
+		/// Destructor 
+		~internalPoints()override = default;
+
+
+	//// - Methods
+		FUNCTION_H
+		const pFlagTypeDevice& activePointsMaskDevice()const;
+
+
+		FUNCTION_H
+		const pFlagTypeHost& activePointsMaskHost()const;
+
+		// - Const access pointPosition
+		FUNCTION_H
+		const PointsType& pointPosition()const;
+		
+		FUNCTION_H
+        PointsType& pointPosition();
+
+        INLINE_FUNCTION_H
+        auto pointPositionHost()const
+        {
+            return pointPosition_.hostView();
+        }
+
+        INLINE_FUNCTION_H
+        auto pointPositionDevice()const
+        {
+            return pointPosition_.deviceView();
+        }
+
+		PointsTypeHost activePointsHost()const;
+
+		// - size of data structure
+		INLINE_FUNCTION_H
+		uint32 size()const
+		{
+			return pFlagsD_.activeRange_.end();
+		}
+		
+		// - maximum capacity of data structure 
+		INLINE_FUNCTION_H
+		uint32 capacity()const
+		{
+			return pointPosition_.capacity();
+		}
+
+		INLINE_FUNCTION_H
+		bool empty()const
+		{
+			return size()==0u;
+		}
+		
+		// - number of active points 
+		INLINE_FUNCTION_H
+		uint32 numActive() const
+		{
+			return pFlagsD_.numActive();
+		}
+				
+		// - if all points are active 
+		INLINE_FUNCTION_H
+		bool isAllActive()const
+		{
+			return pFlagsD_.isAllActive();
+		}
+
+		INLINE_FUNCTION_H
+		auto activeRange()const
+		{
+			return pFlagsD_.activeRange();
+		}
+		
+		virtual 
+		Time& time() = 0;
+
+		virtual
+		const Time& time() const = 0;
+
+		virtual 
+		boundaryBase& boundary(size_t boundaryIndex ) = 0;
+
+		virtual 
+		const boundaryBase& boundary(size_t boundaryIndex ) const = 0;
+
+		///@brief delete points at indices given in delPoints.
+		/// The default is that delPoints contains sorted indices 
+		FUNCTION_H
+		bool deletePoints(
+			scatteredFieldAccess<uint32, memory_space> delPoints);
+		
+		FUNCTION_H
+		uint32 updateFlag(
+			const domain& dm, 
+			const std::array<real,6>& dist);
+		
+		FUNCTION_H
+		void fillNeighborsLists(
+			ViewType1D<uint32, memory_space> leftList,
+			ViewType1D<uint32, memory_space> rightList,
+			ViewType1D<uint32, memory_space> bottomList,
+			ViewType1D<uint32, memory_space> topList,
+			ViewType1D<uint32, memory_space> rearList,
+			ViewType1D<uint32, memory_space> frontList);
+		
+
+		
+	
+	//// - IO operations 
+		
+		/// Read 
+		FUNCTION_H
+		bool read(iIstream& is);
+		
+
+		/// Write 
+		FUNCTION_H
+		bool write(iOstream& os)const;
+
+		/// Read 
+		FUNCTION_H
+		bool read(iIstream& is, const IOPattern& iop);
+		
+
+		/// Write 
+		FUNCTION_H
+		bool write(iOstream& os, const IOPattern& iop)const;	
+
+};
+
+inline
+iOstream& operator<<(iOstream& os, const internalPoints& ip)
+{
+	if( !ip.write(os) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+
+	return os;
+}
+
+} // pFlow
+
+
+#endif //__internalPoints_hpp__
+
diff --git a/src/phasicFlow/structuredData/pointStructure/internalPointsKernels.cpp b/src/phasicFlow/structuredData/pointStructure/internalPointsKernels.cpp
new file mode 100644
index 00000000..e5061d2a
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/internalPointsKernels.cpp
@@ -0,0 +1,44 @@
+/*------------------------------- 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 "internalPointsKernels.hpp"
+
+void pFlow::internalPointsKernels::changePosition
+(
+    deviceViewType1D<realx3> points,
+    deviceViewType1D<uint32> indices, 
+    realx3 transferVector
+)
+{
+    auto s = static_cast<uint32>(indices.size());
+    if(s==0u)return;
+
+    Kokkos::parallel_for
+    (
+        "internalPointsKernels::changePosition",
+        deviceRPolicyStatic(0u, s),
+        LAMBDA_HD(uint32 i)
+        {   
+            points[indices[i]] += transferVector;
+        }
+    );
+    Kokkos::fence();
+    
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/pointStructure/internalPointsKernels.hpp b/src/phasicFlow/structuredData/pointStructure/internalPointsKernels.hpp
new file mode 100644
index 00000000..2b31f294
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/internalPointsKernels.hpp
@@ -0,0 +1,31 @@
+/*------------------------------- 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 "phasicFlowKokkos.hpp"
+
+namespace pFlow::internalPointsKernels
+{
+
+void changePosition(
+    deviceViewType1D<realx3> points,
+    deviceViewType1D<uint32> indices,
+    realx3 transferVector);
+
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/pointStructure/pStcutold.txt b/src/phasicFlow/structuredData/pointStructure/pStcutold.txt
new file mode 100644
index 00000000..7d50ca4c
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/pStcutold.txt
@@ -0,0 +1,540 @@
+#include "pointStructureKernels.hpp"
+#include "setFieldList.hpp"
+#include "error.hpp"
+#include "iOstream.hpp"
+//#include "Time.hpp"
+#include "mortonIndexing.hpp"
+
+FUNCTION_H
+bool pFlow::pointStructure::evaluatePointStructure()
+{
+	if(pointFlag_.size() != pointPosition_.size())
+	{
+		fatalErrorInFunction<<
+		"number of elements in pointFlag and pointPosition is not equal \n";
+		return false;
+	}
+
+	setNumMaxPoints();
+
+	int32 minActive, maxActive;
+	numActivePoints_ = pFlow::pointStructureKernels::scanPointFlag(
+		0,
+		numPoints_,
+		static_cast<int8>(pointStructure::ACTIVE),
+		pointFlag_.deviceVectorAll(),
+		minActive,
+		maxActive
+		);
+	
+	activeRange_ = {minActive, maxActive};	
+	
+	return true;
+}
+
+FUNCTION_H
+void pFlow::pointStructure::setNumMaxPoints()
+{
+	maxPoints_ = pointFlag_.capacity();
+	numPoints_ = pointFlag_.size();
+}
+
+FUNCTION_H
+pFlow::realx3Field_D& pFlow::pointStructure::pointPosition()
+{
+	return pointPosition_;
+}
+
+FUNCTION_H
+pFlow::int8Field_HD& pFlow::pointStructure::pointFlag()
+{
+	return pointFlag_;
+}
+		
+pFlow::uniquePtr<pFlow::int32IndexContainer> 
+	pFlow::pointStructure::getNewPointsIndices(int32 numNewPoints)const
+{
+
+
+	if( capacity() - activeRange_.second >=  numNewPoints )
+	{
+		// fill the sequence starting from activeRange_.second-1
+		return makeUnique<int32IndexContainer>(
+			activeRange_.second,
+			activeRange_.second+numNewPoints);
+
+	}
+
+	// second, check if there is space at the beginning
+	if( activeRange_.first >= numNewPoints)
+	{
+		return makeUnique<int32IndexContainer>(
+			0,
+			numNewPoints);	
+	}
+
+	// otherwise scan the points from first to the end to find empty spaces 
+	int32Vector newPoints(
+		numNewPoints,
+		RESERVE());
+
+	newPoints.clear();
+	int32 numAdded = 0;
+	ForAll(i, pointFlag_)
+	{
+		if(!isActive(i))
+		{
+			newPoints.push_back(static_cast<int32>(i));
+			numAdded++;
+		}
+
+		if(numAdded == numNewPoints)
+		{
+			return makeUnique<int32IndexContainer>(
+				newPoints.data(),
+				numNewPoints);
+		}
+	}
+
+	// check if there is space at the end for the remaining of points
+	if( numAdded <numNewPoints && capacity() - size() >= numNewPoints - numAdded )
+	{
+		int32 ind = size();
+		for(int32 i=numAdded; i<numNewPoints; i++)
+		{
+			newPoints.push_back(ind);
+			ind++;
+		}
+		
+		return makeUnique<int32IndexContainer>(
+			newPoints.data(),
+			numNewPoints);
+	}
+	else
+	{
+		fatalErrorInFunction<<"not enough capacity for inserting particles into the point structure\n";
+		return nullptr;
+	}
+
+	return nullptr;
+}
+
+pFlow::pointStructure::pointStructure()
+:
+	eventSubscriber(),	
+	pointFlag_("pointFlag", "pointFlag", maxPoints_, 0 , RESERVE()),
+	pointPosition_("pointPosition", "pointPosition", maxPoints_, 0, RESERVE()),
+	activeRange_(0,0)
+{}
+
+pFlow::pointStructure::pointStructure
+(
+	const int8Vector& flgVec,
+	const realx3Vector& posVec
+)
+:
+	eventSubscriber(),	
+	maxPoints_(posVec.capacity()),
+	pointFlag_("pointFlag", "pointFlag", maxPoints_, 0 , RESERVE()),
+	pointPosition_("pointPosition", "pointPosition", maxPoints_, 0, RESERVE()),
+	activeRange_(0,0)
+{
+	
+	pointFlag_.assign(flgVec);
+
+	pointPosition_.assign(posVec);
+
+	if( !evaluatePointStructure() )
+	{
+		fatalExit;
+	}
+}
+
+pFlow::pointStructure::pointStructure
+(
+	const realx3Vector& posVec
+)
+:
+	eventSubscriber(),	
+	maxPoints_(posVec.capacity()),
+	pointFlag_("pointFlag", "pointFlag", maxPoints_, 0 , RESERVE()),
+	pointPosition_("pointPosition", "pointPosition", maxPoints_, 0, RESERVE()),
+	activeRange_(0,0)
+{
+
+	pointPosition_.assign(posVec);
+
+	pointFlag_.resize(pointPosition_.size(), static_cast<int8>(pointStructure::ACTIVE) );
+	//pointFlag_.syncViews();
+
+	if( !evaluatePointStructure() )
+	{
+		fatalExit;
+	}
+}
+
+FUNCTION_H
+const pFlow::realx3Field_D& pFlow::pointStructure::pointPosition()const
+{
+	return pointPosition_;
+}
+
+FUNCTION_H
+const pFlow::int8Field_HD& pFlow::pointStructure::pointFlag()const
+{
+	return pointFlag_;
+}
+
+// - size of data structure
+FUNCTION_H
+pFlow::label pFlow::pointStructure::size()const
+{
+	return numPoints_;
+}
+
+FUNCTION_H
+pFlow::label pFlow::pointStructure::capacity()const
+{
+	return maxPoints_;
+}
+
+FUNCTION_H
+pFlow::label pFlow::pointStructure::numActive() const
+{
+	return numActivePoints_;
+}
+
+FUNCTION_H
+bool pFlow::pointStructure::allActive()const
+{
+	return numActivePoints_ == numPoints_;
+}
+
+FUNCTION_H
+bool pFlow::pointStructure::mortonSortPoints(const box& domain, real dx)
+{
+	if( !getSortedIndex(
+		domain, 
+		dx, 
+		activeRange_,
+		pointPosition_.deviceVectorAll(),
+		pointFlag_.deviceVectorAll(),
+		mortonSortedIndex_) )
+	{
+		fatalErrorInFunction<<"failed to perform morton sorting!"<<endl;
+		return false;
+	}
+
+	pointPosition_.sortItems(mortonSortedIndex_);
+	pointFlag_.sortItems(mortonSortedIndex_);
+
+	auto oldSize 			= size();
+	auto oldCapacity 	= capacity();
+	auto oldRange 		= activeRange();
+
+	// update size, range, capacity
+	setNumMaxPoints();
+	activeRange_ = {0, static_cast<int>(mortonSortedIndex_.size())};
+	numActivePoints_ = mortonSortedIndex_.size();
+
+	eventMessage msg(eventMessage::REARRANGE);
+
+	if(oldSize != size() )
+	{
+		msg.add(eventMessage::SIZE_CHANGED);
+	}
+
+	if(oldCapacity != capacity())
+	{
+		msg.add(eventMessage::CAP_CHANGED);
+	}
+
+	if( oldRange != activeRange_)
+	{
+		msg.add(eventMessage::RANGE_CHANGED);
+	}
+
+	// notify all the registered objects except the exclusionList 
+	if( !this->notify(msg) ) return false;
+
+	return true;
+}
+
+FUNCTION_H
+size_t pFlow::pointStructure::markDeleteOutOfBox(const box& domain)
+{
+	if(numPoints_==0) return 0;
+
+	int32 minRange, maxRange;
+	int32 numMarked = 
+	pFlow::pointStructureKernels::markDeleteOutOfBox(
+		domain,
+		activeRange_.first,
+		activeRange_.second,
+		pointStructure::DELETED,
+		pointPosition_.deviceVectorAll(),
+		pointFlag_.deviceVectorAll(),
+		activePointsMaskD(),
+		minRange, maxRange );
+
+	if(numMarked)
+	{
+		pointFlag_.modifyOnDevice();
+		pointFlag_.syncViews();	
+	}
+
+	if( numMarked<=numActivePoints_)
+	{
+		numActivePoints_ -= numMarked;
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"number of points marked as delete ("<<numMarked<<
+		") is greater than the activePoints ("<<numActivePoints_<<
+		").\n";
+		fatalExit;
+	}
+
+	range newRange = {minRange, maxRange};
+	
+	if( activeRange_ != newRange )
+	{
+		activeRange_ = newRange;
+		eventMessage msg(eventMessage::RANGE_CHANGED);
+		
+		// notify all the registered objects about active range change
+		if( !this->notify(msg) ) 
+		{
+			fatalExit<<
+			"something went wrong in notifying registered object about range change. \n";
+			fatalExit;
+		}
+	}	
+
+	return numMarked;
+	
+}
+
+FUNCTION_H
+bool pFlow::pointStructure::updateForDelete()
+{
+	notImplementedFunction;
+
+	return true;
+}
+
+/*FUNCTION_H
+pFlow::uniquePtr<pFlow::int32IndexContainer> pFlow::pointStructure::insertPoints
+(
+	const realx3Vector& pos,
+	const setFieldList& setField,
+	repository& owner,
+	const List<eventObserver*>& exclusionList
+)
+{
+
+	auto numNew = pos.size();
+	if( numNew==0)
+	{
+		return makeUnique<int32IndexContainer>();
+	}
+		
+	auto newPointsPtr = getNewPointsIndices( numNew );
+
+	if(!newPointsPtr)return nullptr;
+
+	auto oldSize 			= size();
+	auto oldCapacity 	= capacity();
+	auto oldRange 		= activeRange();
+
+	tobeInsertedIndex_ = newPointsPtr();
+
+	// set the position of new points
+	
+	if(!pointPosition_.insertSetElement(
+		newPointsPtr(),
+		pos)
+		)return nullptr;
+
+	
+	if(!pointFlag_.insertSetElement(
+		newPointsPtr(),
+		static_cast<int8>(PointFlag::ACTIVE))
+		)return nullptr;
+
+	
+	setNumMaxPoints();
+	auto minInd = newPointsPtr().min();
+	auto maxInd = newPointsPtr().max();
+
+
+	List<eventObserver*> localExlusion(exclusionList);
+
+	for(auto sfEntry:setField)
+	{
+
+		if(void* fieldPtr = 
+			sfEntry.setPointFieldSelectedAll( 
+				owner, 
+				newPointsPtr(), 
+				false );
+			fieldPtr)
+
+			localExlusion.push_back( 
+				static_cast<eventObserver*>(fieldPtr)
+				);
+		else
+			return nullptr;
+	}
+
+	// changes the active rage based on the new inserted points 
+	activeRange_ = { static_cast<int>(min(activeRange_.first, minInd )),
+					 static_cast<int>(max(activeRange_.second, maxInd+1))};
+
+	numActivePoints_ += numNew;
+
+	eventMessage msg(eventMessage::INSERT);
+
+	if( oldRange != activeRange_ )
+		msg.add(eventMessage::RANGE_CHANGED);
+
+	if( oldSize != size() )
+		msg.add(eventMessage::SIZE_CHANGED);
+
+	if( oldCapacity != capacity() )
+		msg.add(eventMessage::CAP_CHANGED);
+	
+	// notify all the registered objects except the exclusionList 
+	if( !this->notify(msg, localExlusion) ) return nullptr;
+
+	return newPointsPtr;
+}
+
+
+
+/*FUNCTION_H
+bool pFlow::pointStructure::readPointStructure
+(
+	iIstream& is
+)
+{
+	auto psCapacity = is.lookupDataOrSet("pointStructureCapacity", maxSizeDefault_);
+	pointPosition_.reallocate(psCapacity);
+	pointFlag_.reallocate(psCapacity);
+
+	if( !pointPosition_.read(is))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"Error in reading pointPosition in pointStructure \n";
+		return false;	
+	}
+
+	if(! pointFlag_.read(is, true))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"Error in reading pointFlag in pointStructure \n";
+		return false;
+	}
+
+	
+	return evaluatePointStructure();
+}*/
+
+/*FUNCTION_H
+bool pFlow::pointStructure::writePointStructure
+(
+	iOstream& os
+)const
+{
+	os.writeWordEntry("pointStructureCapacity", maxPoints_);
+
+	if(!pointPosition_.write(os))
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+		"error in writing pointPosition to file \n";
+		return false;
+	}
+
+	if(!pointFlag_.write(os))
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+		"error in writing pointFlag to file \n";
+		return false;
+	}
+	return true;
+}*/
+
+
+/*pFlow::uniquePtr<pFlow::int32Vector> 
+pFlow::pointStructure::newPointsIndices(
+	int32 numNewPoints
+)const
+{
+	
+	auto newPointsPtr = makeUnique<int32Vector>(
+		"pointStructure::newPointsPtr",
+		numNewPoints);
+
+	auto& newPoints = newPointsPtr();
+	
+
+	// first, check if there is space at the end
+	if( capacity() - activeRange_.second >=  numNewPoints )
+	{
+		// fill the sequence starting from activeRange_.second-1
+		fillSequence(newPoints, activeRange_.second-1);
+		return newPointsPtr;
+	}
+
+	// second, check if there is space at the beggining
+	if( activeRange_.first >= numNewPoints)
+	{
+		// fill the sequence starting from 0
+		fillSequence(newPoints, 0);
+		return newPointsPtr;
+	}
+
+	// otherwise scan the points from first to the end to find empty spaces 
+	newPoints.clear();
+	int32 numAdded = 0;
+	ForAll(i, pointFlag_)
+	{
+		if(!isActive(i))
+		{
+			newPoints.push_back(static_cast<int32>(i));
+			numAdded++;
+		}
+
+		if(numAdded == numNewPoints)
+		{
+			
+			return newPointsPtr;
+		}
+	}
+
+	// check if there is space at the end for the remaining of points
+	if( capacity() - size() >= numNewPoints - numAdded )
+	{
+		int32 ind = size();
+		for(int32 i=numAdded; i<numNewPoints; i++)
+		{
+			newPoints.push_back(ind);
+			ind++;
+		}
+		
+		return newPointsPtr;
+	}
+	else
+	{
+		fatalErrorInFunction<<"not enough capacity for inserting particles into the point structure\n";
+		return nullptr;
+	}
+
+	return nullptr;
+}*/
+
+pFlow::pointStructure::pointStructure(const dictionary &domainDict)
+{
+
+}
diff --git a/src/phasicFlow/structuredData/pointStructure/pointFlag.hpp b/src/phasicFlow/structuredData/pointStructure/pointFlag.hpp
new file mode 100644
index 00000000..ebdeb1ae
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/pointFlag.hpp
@@ -0,0 +1,360 @@
+/*------------------------------- 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 __pointFlag_hpp__
+#define __pointFlag_hpp__
+
+
+#include "phasicFlowKokkos.hpp"
+#include "domain.hpp"
+#include "scatteredFieldAccess.hpp"
+
+namespace pFlow
+{
+
+template<typename ExecutionSpace>
+class pointFlag
+{
+	enum Flag: uint8
+	{
+		DELETED 	= 1, 	//00000001
+		INTERNAL 	= 2,	//00000010
+		LEFT 		= 4,	//00000100
+		RIGHT 		= 8,    //00001000
+		BOTTOM 		= 16,	//00010000
+		TOP 		= 32,	//00100000
+		REAR 		= 64, 	//01000000
+		FRONT 		= 128	//10000000
+	};
+
+	using execution_space 	= ExecutionSpace;
+
+	using memory_space 		= typename execution_space::memory_space;
+
+	using viewType 			= ViewType1D<uint8, memory_space>;
+
+	using device_type 		= typename viewType::device_type;
+
+	using rPolicy = Kokkos::RangePolicy<
+		execution_space,  
+		Kokkos::IndexType<uint32>>;
+
+protected:
+	
+	viewType 	flags_;
+
+	uint32 		numActive_ 		= 0;
+
+	rangeU32 	activeRange_ 	= {0,0};
+
+	bool 		isAllActive_	= false;
+
+	uint32 		nLeft_ 	= 0;
+
+	uint32 		nRight_ = 0;
+
+	uint32 		nBottom_= 0;
+
+	uint32 		nTop_ 	= 0;
+
+	uint32 		nRear_ 	= 0;
+
+	uint32 		nFront_ = 0;
+
+	//- Protected methods 
+
+	uint8 getBoundaryFlag(uint32 index)const
+	{
+		uint8 flg;
+		switch (index){
+			case 0u:
+				flg = Flag::LEFT;
+				break;
+			case 1u:
+				flg = Flag::RIGHT;
+				break;
+			case 2u:
+				flg = Flag::BOTTOM;
+				break;
+			case 3u:
+				flg = Flag::TOP;
+				break;
+			case 4u:
+				flg = Flag::REAR;
+				break;
+			case 5u:
+				flg = Flag::FRONT;
+				break;
+			default:
+				flg=0;
+		}
+
+		return flg;
+	}
+
+public:
+
+	friend class internalPoints;
+
+	pointFlag()
+	{}
+
+	pointFlag(uint32 capacity, uint32 start, uint32 end )
+	:
+		flags_("pointFlag", capacity ),
+		numActive_(end-start),
+		activeRange_(start, end),
+		isAllActive_(true)
+	{
+		fill(flags_, 0, capacity, static_cast<uint8>(Flag::DELETED));
+		fill(flags_, activeRange_, static_cast<uint8>(Flag::INTERNAL));
+	}
+
+	pointFlag(
+		viewType 	flags,
+		uint32 		numActive,
+		rangeU32 	activeRange,
+		bool 		isAllActive)
+	:
+		flags_(flags),
+		numActive_(numActive),
+		activeRange_(activeRange),
+		isAllActive_(isAllActive)
+	{}
+
+	pointFlag(const pointFlag&) = default;
+
+	pointFlag& operator=(const pointFlag&) = default;
+
+	pointFlag(pointFlag&&) = default;
+
+	pointFlag& operator=(pointFlag&&) = default;
+
+	~pointFlag() = default;	
+
+	INLINE_FUNCTION_HD
+	bool isAllActive()const
+	{
+		return isAllActive_;
+	}
+
+	INLINE_FUNCTION_HD
+	const auto& activeRange()const
+	{
+		return activeRange_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto numActive()const
+	{
+		return numActive_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto leftSize()const
+	{
+		return nLeft_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto rightSize()const
+	{
+		return nRight_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto bottomSize()const
+	{
+		return nBottom_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto topSize()const
+	{
+		return nTop_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto rearSize()const
+	{
+		return nRear_;
+	}
+
+	INLINE_FUNCTION_HD
+	auto frontSize()const
+	{
+		return nFront_;
+	}
+
+
+	INLINE_FUNCTION_HD
+	bool operator()(uint32 i)const
+	{
+		return isActive(i);
+	}
+
+	INLINE_FUNCTION_HD
+	bool isActive(uint32 i)const
+	{
+		return flags_[i] > DELETED;
+	}
+
+	
+	INLINE_FUNCTION_HD
+	bool isBoundary(uint8 flg)const
+	{
+		return flg > INTERNAL;
+	}
+
+	
+	INLINE_FUNCTION_HD
+	bool isLeft(uint8 flg)const
+	{
+		return flg&LEFT;
+	}
+
+	INLINE_FUNCTION_HD
+	bool isRight(uint8 flg)const
+	{
+		return flg&RIGHT;
+	}
+
+
+	INLINE_FUNCTION_HD
+	bool isBottom(uint8 flg)const
+	{
+		return flg&BOTTOM;
+	}
+
+	INLINE_FUNCTION_HD
+	bool isTop(uint8 flg)const
+	{
+		return flg&TOP;
+	}
+
+	INLINE_FUNCTION_HD
+	bool isRear(uint8 flg)const
+	{
+		return flg&REAR;
+	}
+
+	INLINE_FUNCTION_HD
+	bool isFront(uint8 flg)const
+	{
+		return flg&FRONT;
+	}
+
+	template<typename ExeSpace>
+	pointFlag<ExeSpace> clone()const
+	{
+		using newViewType = ViewType1D<uint8, typename ExeSpace::memory_space>;
+		newViewType newFlags(
+			"pointFlag",
+			flags_.size());
+
+		copy(newFlags, flags_);
+
+		return pointFlag<ExeSpace>(
+			newFlags,
+			numActive_,
+			activeRange_,
+			isAllActive_);
+	}
+
+	ViewType1D<uint32, memory_space> getActivePoints();
+	
+
+	/// @brief Loop over the active points and mark those out of the box
+	/// and return number of deleted points 
+	/// @param validBox the box whose inside is valid 
+	/// @param points list of all points 
+	/// @return number of deleted points 
+	uint32 markOutOfBoxDelete(
+		const box& validBox,
+		ViewType1D<realx3, memory_space> points);
+
+	bool deletePoints(
+		scatteredFieldAccess<uint32, memory_space> points);
+
+	bool deletePoints(
+		ViewType1D<uint32, memory_space> points);
+	
+	bool changeFlags(
+		ViewType1D<uint32, memory_space> changePoints, 
+		uint32 boundaryIndex);
+	
+	/// @brief mark points based on their position in the domain.
+	/// This should be the first method to be called when updating
+	/// boundaries (step 1 of 2).
+	/// @param dm the domain for which particles are tested 
+	/// @param points list of points 
+	/// @param leftLength neighbor length of the left face 
+	/// @param rightLength neighbor length of the right face 
+	/// @param bottomLength neighbor length of the bottom face 
+	/// @param topLength neighbor length of the top face 
+	/// @param rearLength neighbor length of the rear face 
+	/// @param frontLength neighbor length of the front face 
+	/// @return number of deleted points 
+	uint32 markPointRegions(
+		domain 								dm,
+		ViewType1D<realx3, memory_space> 	points,
+		real leftLength,
+		real rightLength,
+		real bottomLength,
+		real topLength,
+		real rearLength,
+		real frontLength);
+
+	
+	/// @brief fill the lists for boundary faces. Lists keep the index 
+	/// of particles in the neighborhood of the faces. This mehtod is 
+	/// called after markPointRegions (step 2 of 2).
+	/// @param leftList neighbor list of the left face 
+	/// @param rightList neighbor list of the right face 
+	/// @param bottomList neighbor list of the bottom face 
+	/// @param topList neighbor list of the top face 
+	/// @param rearList neighbor list of the rear face 
+	/// @param frontList neighbor list of the front face 
+	void fillNeighborsLists(
+		ViewType1D<uint32, memory_space> leftList,
+		ViewType1D<uint32, memory_space> rightList,
+		ViewType1D<uint32, memory_space> bottomList,
+		ViewType1D<uint32, memory_space> topList,
+		ViewType1D<uint32, memory_space> rearList,
+		ViewType1D<uint32, memory_space> frontList);
+
+	uint32 markDelete(
+		const plane& 		pln,
+		ViewType1D<realx3, memory_space> 	points,
+		ViewType1D<uint32, memory_space> 	indices,
+		ViewType1D<uint32, memory_space> 	onOff);
+
+
+
+};
+
+using pFlagTypeDevice 	= pointFlag<DefaultExecutionSpace>;
+
+using pFlagTypeHost 	= pointFlag<DefaultHostExecutionSpace>;
+
+}
+
+#include "pointFlagKernels.hpp"
+
+#endif // __pointFlag_hpp__
diff --git a/src/phasicFlow/structuredData/pointStructure/pointFlagKernels.hpp b/src/phasicFlow/structuredData/pointStructure/pointFlagKernels.hpp
new file mode 100644
index 00000000..ff43112f
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/pointFlagKernels.hpp
@@ -0,0 +1,552 @@
+/*------------------------------- 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 __pointFlagKernels_hpp__
+#define __pointFlagKernels_hpp__
+
+template<typename ExecutionSpace>
+pFlow::ViewType1D<pFlow::uint32, typename pFlow::pointFlag<ExecutionSpace>::memory_space>
+	pFlow::pointFlag<ExecutionSpace>::getActivePoints()
+{
+	using rpAPoints = Kokkos::RangePolicy<execution_space,  
+			Kokkos::IndexType<uint32>>;
+
+	ViewType1D<pFlow::uint32,memory_space> 
+		aPoints("activePoints", activeRange_.end()+1);
+	
+
+	Kokkos::parallel_for(
+		"pFlow::pointFlag<ExecutionSpace>::getActivePoints",
+		rpAPoints(0,activeRange_.end()),
+		CLASS_LAMBDA_HD(uint32 i)
+		{
+			if( isActive(i))
+			{
+				aPoints[i] = 1;
+			}
+			else
+			{
+				aPoints[i] = 0;
+			}
+		}
+	);
+	Kokkos::fence();
+	return aPoints;
+}
+
+
+template<typename ExecutionSpace>
+pFlow::uint32 pFlow::pointFlag<ExecutionSpace>::markOutOfBoxDelete
+(
+	const box& validBox,
+	ViewType1D<realx3, memory_space> points
+)
+{
+	using rpScanFlag = Kokkos::RangePolicy<execution_space,  
+			Kokkos::IndexType<uint32>>;
+
+	uint32 numDeleted = 0;
+	
+	uint32 start = activeRange().start();
+	uint32 end   = activeRange().end();
+
+	uint32 minRange = end;
+	uint32 maxRange = start;
+
+	if(start<end)
+	{
+		Kokkos::parallel_reduce(
+			"pointFlagKernels::markOutOfBox",
+			rpScanFlag(start, end),
+			CLASS_LAMBDA_HD(
+				uint32 i, 
+				uint32& minUpdate, 
+				uint32& maxUpdate, 
+				uint32& delToUpdate)
+			{
+				if(isActive(i))
+				{
+					if(validBox.isInside(points[i]))
+					{
+						
+						minUpdate = min(minUpdate,i);
+						maxUpdate = max(maxUpdate,i);
+					}
+					else
+					{
+						flags_[i] = DELETED;
+						delToUpdate++;
+					}
+
+				}
+				
+			},
+			Kokkos::Min<uint32>(minRange), 
+			Kokkos::Max<uint32>(maxRange),
+			numDeleted);	
+	}
+	
+	if(numDeleted >= numActive_)
+	{
+		minRange = 0;
+		maxRange = 0;
+		numDeleted == numActive_;
+	}
+	else
+	{
+		// add one to maxRange to make it half-open
+		maxRange ++;
+	}
+
+	activeRange_ = {minRange, maxRange};
+	numActive_ 	= numActive_ - numDeleted;
+	isAllActive_ = 
+		(activeRange_.numElements() == numActive_)&& numActive_>0;
+	
+	return numDeleted;
+}
+
+/*template<typename ExecutionSpace>
+pFlow::uint32 pFlow::pointFlag<ExecutionSpace>::scanPointFlag()
+{
+		
+	using rpScanFlag = Kokkos::RangePolicy<execution_space,  
+			Kokkos::IndexType<uint32>>;
+
+	uint32 numActive = 0;
+	
+	
+	uint32 start = activeRange().start();
+	uint32 end   = activeRange().end();
+
+	uint32 minRange = end;
+	uint32 maxRange = start;
+
+	if(start<end)
+	{
+		Kokkos::parallel_reduce(
+			"pointFlagKernels::scanPointFlag",
+			rpScanFlag(start, end),
+			CLASS_LAMBDA_HD(
+				uint32 i, 
+				uint32& minUpdate, 
+				uint32& maxUpdate, 
+				uint32& sumToUpdate)
+			{
+				if(this->isActive(i))
+				{
+					sumToUpdate++;
+					minUpdate = min(minUpdate,i);
+					maxUpdate = max(maxUpdate,i);
+				}
+			},
+			Kokkos::Min<uint32>(minRange), 
+			Kokkos::Max<uint32>(maxRange),
+			numActive);	
+	}
+	
+	if(numActive==0)
+	{
+		minRange = 0;
+		maxRange = 0;
+	}
+	else
+	{
+		// add one to maxRange to make it half-open
+		maxRange ++;
+	}
+
+	activeRange_ = {minRange, maxRange};
+	numActive_ 	= numActive;
+	isAllActive_ = activeRange_.numElements() == numActive_;
+
+	return numActive;
+}*/
+
+template<typename ExecutionSpace>
+bool pFlow::pointFlag<ExecutionSpace>::deletePoints
+(
+	scatteredFieldAccess<uint32, memory_space>  points
+)
+{
+	if(points.empty())return true;
+	
+	//uint32 minIndex = points.getFirstCopy();
+	//uint32 maxIndex = points.getLastCopy();
+	
+	//if(maxIndex<minIndex) return false;
+	//if(maxIndex>activeRange_.end())return false;
+	//if(minIndex<activeRange_.start())return false;
+
+	using policy = Kokkos::RangePolicy<
+		execution_space,  
+		Kokkos::IndexType<uint32>>;
+
+	uint32 numDeleted = 0;
+	Kokkos::parallel_reduce
+	(
+		"pointFlagKernels::deletePoints",
+		policy(0u, points.size()),
+		CLASS_LAMBDA_HD(uint32 i, uint32& valDelUpdate)
+		{
+			uint32 n = points(i);
+			if(isActive(n))
+			{
+				valDelUpdate++;
+				flags_[n] = Flag::DELETED;
+			}
+		},
+		numDeleted
+	);	
+
+	if(numDeleted >= numActive_)
+	{
+		activeRange_ = {0, 0};
+		numDeleted == numActive_;
+	}
+		
+	numActive_ 	= numActive_ - numDeleted;
+	isAllActive_ = 
+		(activeRange_.numElements() == numActive_)&& numActive_>0;
+	
+	return true;
+}
+template<typename ExecutionSpace>
+bool pFlow::pointFlag<ExecutionSpace>::deletePoints
+(
+	ViewType1D<uint32, memory_space> points
+)
+{
+
+	uint32 s = points.size();
+	if(s==0u)return true;
+	
+	//if(maxIndex<minIndex) return false;
+	//if(maxIndex>activeRange_.end())return false;
+	//if(minIndex<activeRange_.start())return false;
+
+	using policy = Kokkos::RangePolicy<
+		execution_space,  
+		Kokkos::IndexType<uint32>>;
+
+	uint32 numDeleted = 0;
+	Kokkos::parallel_reduce
+	(
+		"pointFlagKernels::deletePoints",
+		policy(0u, points.size()),
+		CLASS_LAMBDA_HD(uint32 i, uint32& valDelUpdate)
+		{
+			uint32 n = points(i);
+			if(isActive(n))
+			{
+				valDelUpdate++;
+				flags_[n] = Flag::DELETED;
+			}
+		},
+		numDeleted
+	);	
+
+	if(numDeleted >= numActive_)
+	{
+		activeRange_ = {0, 0};
+		numDeleted == numActive_;
+	}
+		
+	numActive_ 	= numActive_ - numDeleted;
+	isAllActive_ = 
+		(activeRange_.numElements() == numActive_)&& numActive_>0;
+	
+	return true;
+}
+
+
+template<typename ExecutionSpace>
+bool pFlow::pointFlag<ExecutionSpace>::changeFlags
+(
+	ViewType1D<uint32, memory_space> changePoints, 
+	uint32 boundaryIndex
+)
+{
+	auto flg = getBoundaryFlag(boundaryIndex);
+	Kokkos::parallel_for
+	(
+		"pointFlag::changeFlags",
+		rPolicy(0, changePoints.size()),
+		LAMBDA_HD(uint32 i)
+		{
+			flags_[changePoints(i)] = flg;
+		}
+	);
+	Kokkos::fence();
+	return true;
+}
+
+template<typename ExecutionSpace>
+pFlow::uint32 pFlow::pointFlag<ExecutionSpace>::markPointRegions
+(
+	domain 								dm,
+	ViewType1D<realx3, memory_space> 	points,
+	real leftLength,
+	real rightLength,
+	real bottomLength,
+	real topLength,
+	real rearLength,
+	real frontLength)
+{
+	
+	using rpMark = Kokkos::RangePolicy<execution_space,  
+			Kokkos::IndexType<uint32>>;
+
+	uint32 start = activeRange().start();
+	uint32 end   = activeRange().end();
+
+	uint32 minRange = end;
+	uint32 maxRange = start;
+
+	uint32 numMarkedDelete = 0;
+	uint32 nLeft = 0, nRight = 0;
+	uint32 nBottom = 0, nTop = 0;
+	uint32 nRear = 0, nFront = 0;
+
+	if(start<end)
+	{
+		
+		Kokkos::parallel_reduce(
+			"pointFlagKernels::markDeleteInDomain",
+			rpMark(start,end),
+			CLASS_LAMBDA_HD(
+				uint32 i, 
+				uint32& minUpdate, 
+				uint32& maxUpdate, 
+				uint32& valDelete,
+				uint32& valLeft,
+				uint32& valRight,
+				uint32& valBottom,
+				uint32& valTop,
+				uint32& valRear,
+				uint32& valFront){
+				if(this->isActive(i))
+				{
+					realx3 p = points[i];
+					if( !dm.domainBox().isInside(p) )
+					{
+						flags_[i] = DELETED;
+						valDelete++;
+					}
+					else
+					{
+
+						uint8 flg  = 0;
+						minUpdate = min(minUpdate,i);
+						maxUpdate = max(maxUpdate,i);
+
+						if(dm.left().inPositiveDistance(p, leftLength))
+						{
+							flg += LEFT;
+							valLeft++;	
+						} 
+
+						if(dm.right().inPositiveDistance(p, rightLength))
+						{
+							flg += RIGHT;
+							valRight++;
+						}
+						
+						if(dm.bottom().inPositiveDistance(p, bottomLength))
+						{
+							flg += BOTTOM;
+							valBottom++;
+						} 
+
+						if(dm.top().inPositiveDistance(p, topLength)) 
+						{
+							flg += TOP;
+							valTop++;
+						}
+						
+						if(dm.rear().inPositiveDistance(p, rearLength)) 
+						{
+							flg += REAR;
+							valRear++;
+						}
+
+						if(dm.front().inPositiveDistance(p, frontLength))
+						{
+							flg += FRONT;
+							valFront++;
+						} 
+
+						flags_[i] = flg>static_cast<uint8>(0)? flg: INTERNAL;
+					}
+				}
+			},
+			Kokkos::Min<uint32>(minRange), 
+			Kokkos::Max<uint32>(maxRange),
+			numMarkedDelete,
+			nLeft,
+			nRight,
+			nBottom,
+			nTop,
+			nRear,
+			nFront);
+
+	}
+	
+	// means either range was empty or all points have been deleted.
+	if(numMarkedDelete>= numActive_)
+	{
+		minRange = 0;
+		maxRange = 0;
+		numMarkedDelete =  numActive_;
+	}
+	else
+	{
+		maxRange++; // add one to make it half
+	}
+
+	activeRange_ = {minRange, maxRange};
+	numActive_ 	-= numMarkedDelete;
+	isAllActive_ = (activeRange_.numElements() == numActive_)&& numActive_>0;
+
+	nLeft_ 	= nLeft;
+	nRight_	= nRight;
+	nBottom_= nBottom;
+	nTop_ 	= nTop;
+	nRear_	= nRear;
+	nFront_ = nFront;
+
+	return numMarkedDelete;
+}
+
+template<typename ExecutionSpace>
+void pFlow::pointFlag<ExecutionSpace>::fillNeighborsLists
+(
+	ViewType1D<uint32, memory_space> leftList,
+	ViewType1D<uint32, memory_space> rightList,
+	ViewType1D<uint32, memory_space> bottomList,
+	ViewType1D<uint32, memory_space> topList,
+	ViewType1D<uint32, memory_space> rearList,
+	ViewType1D<uint32, memory_space> frontList
+)
+{
+	using rpMark = Kokkos::RangePolicy<execution_space,  
+			Kokkos::IndexType<uint32>>;
+
+	uint32 start = activeRange().start();
+	uint32 end   = activeRange().end();
+
+	ViewType1D<uint32, memory_space> nElems("nElems",6);
+	
+	fill(nElems, 0, 6, static_cast<uint32>(0));
+		
+	if(start<end)
+	{
+		Kokkos::parallel_for(
+			"pointFlagKernels::markDeleteInDomain",
+			rpMark(start,end),
+			CLASS_LAMBDA_HD(uint32 i){
+
+				uint8 flg = flags_(i);
+				if(this->isBoundary(flg))
+				{
+					if(this->isLeft(flg)) leftList[Kokkos::atomic_fetch_add(&nElems[0],1)] = i;
+					if(this->isRight(flg))rightList[Kokkos::atomic_fetch_add(&nElems[1],1)] = i;
+					if(this->isBottom(flg))bottomList[Kokkos::atomic_fetch_add(&nElems[2],1)] = i;
+					if(this->isTop(flg))topList[Kokkos::atomic_fetch_add(&nElems[3],1)] = i;
+					if(this->isRear(flg))rearList[Kokkos::atomic_fetch_add(&nElems[4],1)] = i;
+					if(this->isFront(flg))frontList[Kokkos::atomic_fetch_add(&nElems[5],1)] = i;
+				}
+			});
+		Kokkos::fence();	
+	}
+}
+
+template<typename ExecutionSpace>
+pFlow::uint32 pFlow::pointFlag<ExecutionSpace>::markDelete
+(
+	const plane& 		pln,
+	ViewType1D<realx3, memory_space> 	points,
+	ViewType1D<uint32, memory_space> 	indices,
+	ViewType1D<uint32, memory_space> 	onOff
+)
+{
+	// if it is empty, do nothing
+	if(indices.size() == 0 )return 0;
+
+	using rpMark = Kokkos::RangePolicy<execution_space,  
+			Kokkos::IndexType<uint32>>;
+
+	uint32 start = activeRange().start();
+	uint32 end   = activeRange().end();
+
+	uint32 minRange = end;
+	uint32 maxRange = start;
+
+	uint32 numMarked = 0;
+
+	if(start<end)
+	{
+		Kokkos::parallel_reduce(
+			"pointFlagKernels::markDelete",
+			rpScanFlag(0, indices.size()),
+			CLASS_LAMBDA_HD(
+				uint32 i, 
+				uint32& minUpdate, 
+				uint32& maxUpdate, 
+				uint32& sumToUpdate)
+			{
+				auto indx = indices(i);
+				
+				if( pln.pointInNegativeSide(points(indx)))
+				{
+					flags_[indx] = DELETED;
+					sumToUpdate++;
+					onOff[i] = 0;
+				}
+				else
+				{
+					minUpdate = min(minUpdate,i);
+					maxUpdate = max(maxUpdate,i);
+					onOff[i] = 1;
+				}
+			},
+			Kokkos::Min<uint32>(minRange), 
+			Kokkos::Max<uint32>(maxRange),
+			numMarked);	
+	}
+
+	// means either range was empty or all points have been deleted.
+	if(minRange<start || maxRange>end)
+	{
+		minRange = 0;
+		maxRange = 0;
+	}
+	else
+	{
+		maxRange++; // add one to make it half
+	}
+
+	activeRange_ = {minRange, maxRange};
+	isAllActive_ = isAllActive_ && numMarked == 0; 
+	numActive_ 	-= numMarked;
+
+	return numMarked;
+}
+
+#endif // __pointFlagKernels_hpp__
diff --git a/src/phasicFlow/structuredData/pointStructure/pointStructure.cpp b/src/phasicFlow/structuredData/pointStructure/pointStructure.cpp
index 8dd2494e..30b81c10 100644
--- a/src/phasicFlow/structuredData/pointStructure/pointStructure.cpp
+++ b/src/phasicFlow/structuredData/pointStructure/pointStructure.cpp
@@ -1,3 +1,4 @@
+
 /*------------------------------- phasicFlow ---------------------------------
       O        C enter of
      O O       E ngineering and
@@ -18,540 +19,210 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
 #include "pointStructure.hpp"
-#include "pointStructureKernels.hpp"
-#include "setFieldList.hpp"
-#include "error.hpp"
-#include "iOstream.hpp"
-//#include "Time.hpp"
-#include "mortonIndexing.hpp"
+#include "systemControl.hpp"
+#include "vocabs.hpp"
 
-FUNCTION_H
-bool pFlow::pointStructure::evaluatePointStructure()
+bool pFlow::pointStructure::setupPointStructure(const realx3Vector& points)
 {
-	if(pointFlag_.size() != pointPosition_.size())
-	{
-		fatalErrorInFunction<<
-		"number of elements in pointFlag and pointPosition is not equal \n";
-		return false;
-	}
+    PointsTypeHost hPoints
+    (
+        pointPosition().name(), 
+        pointPosition().fieldKey()
+    );
 
-	setNumMaxPoints();
-
-	int32 minActive, maxActive;
-	numActivePoints_ = pFlow::pointStructureKernels::scanPointFlag(
-		0,
-		numPoints_,
-		static_cast<int8>(pointStructure::ACTIVE),
-		pointFlag_.deviceVectorAll(),
-		minActive,
-		maxActive
-		);
-	
-	activeRange_ = {minActive, maxActive};	
-	
-	return true;
+    hPoints.assign(points);
+    
+    return setupPointStructure(hPoints);
 }
 
-FUNCTION_H
-void pFlow::pointStructure::setNumMaxPoints()
+bool pFlow::pointStructure::setupPointStructure(const PointsTypeHost &points)
 {
-	maxPoints_ = pointFlag_.capacity();
-	numPoints_ = pointFlag_.size();
+    if(!simulationDomain_->initialUpdateDomains(points.getSpan()))
+    {
+        fatalErrorInFunction<<
+        "error in updating domains"<<endl;
+        return false;
+    }
+    
+    uint32 thisN = simulationDomain_->initialNumberInThis();
+
+    PointsTypeHost internal
+    (
+        pointPosition().name(), 
+        pointPosition().fieldKey(), 
+        thisN, 
+        thisN, 
+        RESERVE()
+    );
+    
+    auto pSpan  = points.getSpan();
+    
+    if(auto iSpan  = internal.getSpan(); 
+        !simulationDomain_->initialTransferBlockData(pSpan, iSpan))
+    {
+        fatalErrorInFunction<<
+        "Error in transfering the block data "<<endl;
+        return false;
+    }
+    
+    if( !initializePoints(internal) )
+    {
+        fatalErrorInFunction;
+        return false;
+    }
+
+    boundaries_.setLists();
+
+    return true;
 }
 
-FUNCTION_H
-pFlow::realx3Field_D& pFlow::pointStructure::pointPosition()
+
+bool pFlow::pointStructure::initializePoints(const PointsTypeHost &points)
 {
-	return pointPosition_;
-}
+    pointPosition().assignFromHost(points);
 
-FUNCTION_H
-pFlow::int8Field_HD& pFlow::pointStructure::pointFlag()
-{
-	return pointFlag_;
-}
-		
-pFlow::uniquePtr<pFlow::int32IndexContainer> 
-	pFlow::pointStructure::getNewPointsIndices(int32 numNewPoints)const
-{
+    createDeviceFlag(pointPosition().capacity(), 0, pointPosition().size());
+    syncPFlag();
 
-
-	if( capacity() - activeRange_.second >=  numNewPoints )
-	{
-		// fill the sequence starting from activeRange_.second-1
-		return makeUnique<int32IndexContainer>(
-			activeRange_.second,
-			activeRange_.second+numNewPoints);
-
-	}
-
-	// second, check if there is space at the beginning
-	if( activeRange_.first >= numNewPoints)
-	{
-		return makeUnique<int32IndexContainer>(
-			0,
-			numNewPoints);	
-	}
-
-	// otherwise scan the points from first to the end to find empty spaces 
-	int32Vector newPoints(
-		numNewPoints,
-		RESERVE());
-
-	newPoints.clear();
-	int32 numAdded = 0;
-	ForAll(i, pointFlag_)
-	{
-		if(!isActive(i))
-		{
-			newPoints.push_back(static_cast<int32>(i));
-			numAdded++;
-		}
-
-		if(numAdded == numNewPoints)
-		{
-			return makeUnique<int32IndexContainer>(
-				newPoints.data(),
-				numNewPoints);
-		}
-	}
-
-	// check if there is space at the end for the remaining of points
-	if( numAdded <numNewPoints && capacity() - size() >= numNewPoints - numAdded )
-	{
-		int32 ind = size();
-		for(int32 i=numAdded; i<numNewPoints; i++)
-		{
-			newPoints.push_back(ind);
-			ind++;
-		}
-		
-		return makeUnique<int32IndexContainer>(
-			newPoints.data(),
-			numNewPoints);
-	}
-	else
-	{
-		fatalErrorInFunction<<"not enough capacity for inserting particles into the point structure\n";
-		return nullptr;
-	}
-
-	return nullptr;
-}
-
-pFlow::pointStructure::pointStructure()
-:
-	eventSubscriber(),	
-	pointFlag_("pointFlag", "pointFlag", maxPoints_, 0 , RESERVE()),
-	pointPosition_("pointPosition", "pointPosition", maxPoints_, 0, RESERVE()),
-	activeRange_(0,0)
-{}
-
-pFlow::pointStructure::pointStructure
-(
-	const int8Vector& flgVec,
-	const realx3Vector& posVec
-)
-:
-	eventSubscriber(),	
-	maxPoints_(posVec.capacity()),
-	pointFlag_("pointFlag", "pointFlag", maxPoints_, 0 , RESERVE()),
-	pointPosition_("pointPosition", "pointPosition", maxPoints_, 0, RESERVE()),
-	activeRange_(0,0)
-{
-	
-	pointFlag_.assign(flgVec);
-
-	pointPosition_.assign(posVec);
-
-	if( !evaluatePointStructure() )
-	{
-		fatalExit;
-	}
+    return true;
 }
 
 pFlow::pointStructure::pointStructure
 (
-	const realx3Vector& posVec
+    systemControl& control
 )
 :
-	eventSubscriber(),	
-	maxPoints_(posVec.capacity()),
-	pointFlag_("pointFlag", "pointFlag", maxPoints_, 0 , RESERVE()),
-	pointPosition_("pointPosition", "pointPosition", maxPoints_, 0, RESERVE()),
-	activeRange_(0,0)
+    IOobject
+    (
+        objectFile
+        (
+            pointStructureFile__,
+            "",
+            objectFile::READ_ALWAYS,
+            objectFile::WRITE_ALWAYS
+        ),
+        IOPattern::MasterProcessorDistribute,
+        &control.time()
+    ),
+	demComponent("particlesCenterMass", control),
+  	internalPoints(),
+	simulationDomain_
+	(
+		simulationDomain::create(control)
+	),
+	boundaries_
+	(
+        *this
+	)
 {
+    REPORT(1)<< "Reading "<< Green_Text("pointStructure")<<
+    " from "<<IOobject::path()<<END_REPORT;
 
-	pointPosition_.assign(posVec);
-
-	pointFlag_.resize(pointPosition_.size(), static_cast<int8>(pointStructure::ACTIVE) );
-	//pointFlag_.syncViews();
-
-	if( !evaluatePointStructure() )
-	{
-		fatalExit;
-	}
+    if( !IOobject::readObject() )
+    {
+        fatalErrorInFunction<<
+        "Error in reading from file "<<IOobject::path()<<endl;
+        fatalExit;
+    }
 }
 
-FUNCTION_H
-const pFlow::realx3Field_D& pFlow::pointStructure::pointPosition()const
+
+pFlow::pointStructure::pointStructure(
+    systemControl& control,
+    const realx3Vector &posVec)
+:
+	IOobject
+    (
+        objectFile
+        (
+            pointStructureFile__,
+            "",
+            objectFile::READ_NEVER,
+            objectFile::WRITE_ALWAYS
+        ),
+        IOPattern::MasterProcessorDistribute,
+        &control.time()
+    ),
+	demComponent("particlesCenterMass", control),
+  	internalPoints(),
+	simulationDomain_
+	(
+		simulationDomain::create(control)
+	),
+	boundaries_
+	(
+		*this
+	)
 {
-	return pointPosition_;
+    if(!setupPointStructure(posVec))
+    {
+        fatalErrorInFunction<<
+        "Error in seting up pointStructure"<<endl;
+        fatalExit;
+    }
 }
 
-FUNCTION_H
-const pFlow::int8Field_HD& pFlow::pointStructure::pointFlag()const
+bool pFlow::pointStructure::beforeIteration()
 {
-	return pointFlag_;
+    if( !boundaries_.beforeIteration(currentIter(), currentTime(), dt()) )
+    {
+        fatalErrorInFunction<<
+        "Unable to perform beforeIteration for boundaries"<<endl;
+        return false;
+    }
+    return true;
 }
 
-// - size of data structure
-FUNCTION_H
-pFlow::label pFlow::pointStructure::size()const
+bool pFlow::pointStructure::iterate()
 {
-	return numPoints_;
+    if( !boundaries_.iterate(currentIter(), currentTime(), dt()) )
+    {
+        fatalErrorInFunction<<
+        "Unable to perform iterate for boundaries"<<endl;
+        return false;
+    }
+    
+    return true;
 }
 
-FUNCTION_H
-pFlow::label pFlow::pointStructure::capacity()const
+bool pFlow::pointStructure::afterIteration()
 {
-	return maxPoints_;
+    if( !boundaries_.afterIteration(currentIter(), currentTime(), dt()) )
+    {
+        fatalErrorInFunction<<
+        "Unable to perform afterIteration for boundaries"<<endl;
+        return false;
+    }
+    return true;
 }
 
-FUNCTION_H
-pFlow::label pFlow::pointStructure::numActive() const
+bool pFlow::pointStructure::read(
+    iIstream &is,
+    const IOPattern& iop)
 {
-	return numActivePoints_;
-}
+    
+    PointsTypeHost fRead
+    (
+        this->pointPosition().name(),
+        this->pointPosition().fieldKey()
+    );
 
-FUNCTION_H
-bool pFlow::pointStructure::allActive()const
-{
-	return numActivePoints_ == numPoints_;
-}
-
-FUNCTION_H
-bool pFlow::pointStructure::mortonSortPoints(const box& domain, real dx)
-{
-	if( !getSortedIndex(
-		domain, 
-		dx, 
-		activeRange_,
-		pointPosition_.deviceVectorAll(),
-		pointFlag_.deviceVectorAll(),
-		mortonSortedIndex_) )
-	{
-		fatalErrorInFunction<<"failed to perform morton sorting!"<<endl;
-		return false;
-	}
-
-	pointPosition_.sortItems(mortonSortedIndex_);
-	pointFlag_.sortItems(mortonSortedIndex_);
-
-	auto oldSize 			= size();
-	auto oldCapacity 	= capacity();
-	auto oldRange 		= activeRange();
-
-	// update size, range, capacity
-	setNumMaxPoints();
-	activeRange_ = {0, static_cast<int>(mortonSortedIndex_.size())};
-	numActivePoints_ = mortonSortedIndex_.size();
-
-	eventMessage msg(eventMessage::REARRANGE);
-
-	if(oldSize != size() )
-	{
-		msg.add(eventMessage::SIZE_CHANGED);
-	}
-
-	if(oldCapacity != capacity())
-	{
-		msg.add(eventMessage::CAP_CHANGED);
-	}
-
-	if( oldRange != activeRange_)
-	{
-		msg.add(eventMessage::RANGE_CHANGED);
-	}
-
-	// notify all the registered objects except the exclusionList 
-	if( !this->notify(msg) ) return false;
-
-	return true;
-}
-
-FUNCTION_H
-size_t pFlow::pointStructure::markDeleteOutOfBox(const box& domain)
-{
-	if(numPoints_==0) return 0;
-
-	int32 minRange, maxRange;
-	int32 numMarked = 
-	pFlow::pointStructureKernels::markDeleteOutOfBox(
-		domain,
-		activeRange_.first,
-		activeRange_.second,
-		pointStructure::DELETED,
-		pointPosition_.deviceVectorAll(),
-		pointFlag_.deviceVectorAll(),
-		activePointsMaskD(),
-		minRange, maxRange );
-
-	if(numMarked)
-	{
-		pointFlag_.modifyOnDevice();
-		pointFlag_.syncViews();	
-	}
-
-	if( numMarked<=numActivePoints_)
-	{
-		numActivePoints_ -= numMarked;
-	}
-	else
+	if( !fRead.read(is, iop))
 	{
 		fatalErrorInFunction<<
-		"number of points marked as delete ("<<numMarked<<
-		") is greater than the activePoints ("<<numActivePoints_<<
-		").\n";
-		fatalExit;
-	}
-
-	range newRange = {minRange, maxRange};
-	
-	if( activeRange_ != newRange )
-	{
-		activeRange_ = newRange;
-		eventMessage msg(eventMessage::RANGE_CHANGED);
-		
-		// notify all the registered objects about active range change
-		if( !this->notify(msg) ) 
-		{
-			fatalExit<<
-			"something went wrong in notifying registered object about range change. \n";
-			fatalExit;
-		}
-	}	
-
-	return numMarked;
-	
-}
-
-FUNCTION_H
-bool pFlow::pointStructure::updateForDelete()
-{
-	notImplementedFunction;
-
-	return true;
-}
-
-FUNCTION_H
-pFlow::uniquePtr<pFlow::int32IndexContainer> pFlow::pointStructure::insertPoints
-(
-	const realx3Vector& pos,
-	const setFieldList& setField,
-	repository& owner,
-	const List<eventObserver*>& exclusionList
-)
-{
-
-	auto numNew = pos.size();
-	if( numNew==0)
-	{
-		return makeUnique<int32IndexContainer>();
-	}
-		
-	auto newPointsPtr = getNewPointsIndices( numNew );
-
-	if(!newPointsPtr)return nullptr;
-
-	auto oldSize 			= size();
-	auto oldCapacity 	= capacity();
-	auto oldRange 		= activeRange();
-
-	tobeInsertedIndex_ = newPointsPtr();
-
-	// set the position of new points
-	
-	if(!pointPosition_.insertSetElement(
-		newPointsPtr(),
-		pos)
-		)return nullptr;
-
-	
-	if(!pointFlag_.insertSetElement(
-		newPointsPtr(),
-		static_cast<int8>(PointFlag::ACTIVE))
-		)return nullptr;
-
-	
-	setNumMaxPoints();
-	auto minInd = newPointsPtr().min();
-	auto maxInd = newPointsPtr().max();
-
-
-	List<eventObserver*> localExlusion(exclusionList);
-
-	for(auto sfEntry:setField)
-	{
-
-		if(void* fieldPtr = 
-			sfEntry.setPointFieldSelectedAll( 
-				owner, 
-				newPointsPtr(), 
-				false );
-			fieldPtr)
-
-			localExlusion.push_back( 
-				static_cast<eventObserver*>(fieldPtr)
-				);
-		else
-			return nullptr;
-	}
-
-	// changes the active rage based on the new inserted points 
-	activeRange_ = { static_cast<int>(min(activeRange_.first, minInd )),
-					 static_cast<int>(max(activeRange_.second, maxInd+1))};
-
-	numActivePoints_ += numNew;
-
-	eventMessage msg(eventMessage::INSERT);
-
-	if( oldRange != activeRange_ )
-		msg.add(eventMessage::RANGE_CHANGED);
-
-	if( oldSize != size() )
-		msg.add(eventMessage::SIZE_CHANGED);
-
-	if( oldCapacity != capacity() )
-		msg.add(eventMessage::CAP_CHANGED);
-	
-	// notify all the registered objects except the exclusionList 
-	if( !this->notify(msg, localExlusion) ) return nullptr;
-
-	return newPointsPtr;
-}
-
-
-
-FUNCTION_H
-bool pFlow::pointStructure::readPointStructure
-(
-	iIstream& is
-)
-{
-	auto psCapacity = is.lookupDataOrSet("pointStructureCapacity", maxSizeDefault_);
-	pointPosition_.reallocate(psCapacity);
-	pointFlag_.reallocate(psCapacity);
-
-	if( !pointPosition_.read(is))
-	{
-		ioErrorInFile(is.name(), is.lineNumber())<<
-		"Error in reading pointPosition in pointStructure \n";
-		return false;	
-	}
-
-	if(! pointFlag_.read(is, true))
-	{
-		ioErrorInFile(is.name(), is.lineNumber())<<
-		"Error in reading pointFlag in pointStructure \n";
+		"Error in reading pointPosition from stream "<< is.name()<<endl;
 		return false;
 	}
 
-	
-	return evaluatePointStructure();
+    return setupPointStructure(fRead);
 }
 
-FUNCTION_H
-bool pFlow::pointStructure::writePointStructure
+bool pFlow::pointStructure::write
 (
-	iOstream& os
+    iOstream& os, 
+    const IOPattern& iop
 )const
 {
-	os.writeWordEntry("pointStructureCapacity", maxPoints_);
-
-	if(!pointPosition_.write(os))
-	{
-		ioErrorInFile(os.name(), os.lineNumber())<<
-		"error in writing pointPosition to file \n";
-		return false;
-	}
-
-	if(!pointFlag_.write(os))
-	{
-		ioErrorInFile(os.name(), os.lineNumber())<<
-		"error in writing pointFlag to file \n";
-		return false;
-	}
-	return true;
+    return internalPoints::write(os, iop);
 }
-
-
-/*pFlow::uniquePtr<pFlow::int32Vector> 
-pFlow::pointStructure::newPointsIndices(
-	int32 numNewPoints
-)const
-{
-	
-	auto newPointsPtr = makeUnique<int32Vector>(
-		"pointStructure::newPointsPtr",
-		numNewPoints);
-
-	auto& newPoints = newPointsPtr();
-	
-
-	// first, check if there is space at the end
-	if( capacity() - activeRange_.second >=  numNewPoints )
-	{
-		// fill the sequence starting from activeRange_.second-1
-		fillSequence(newPoints, activeRange_.second-1);
-		return newPointsPtr;
-	}
-
-	// second, check if there is space at the beggining
-	if( activeRange_.first >= numNewPoints)
-	{
-		// fill the sequence starting from 0
-		fillSequence(newPoints, 0);
-		return newPointsPtr;
-	}
-
-	// otherwise scan the points from first to the end to find empty spaces 
-	newPoints.clear();
-	int32 numAdded = 0;
-	ForAll(i, pointFlag_)
-	{
-		if(!isActive(i))
-		{
-			newPoints.push_back(static_cast<int32>(i));
-			numAdded++;
-		}
-
-		if(numAdded == numNewPoints)
-		{
-			
-			return newPointsPtr;
-		}
-	}
-
-	// check if there is space at the end for the remaining of points
-	if( capacity() - size() >= numNewPoints - numAdded )
-	{
-		int32 ind = size();
-		for(int32 i=numAdded; i<numNewPoints; i++)
-		{
-			newPoints.push_back(ind);
-			ind++;
-		}
-		
-		return newPointsPtr;
-	}
-	else
-	{
-		fatalErrorInFunction<<"not enough capacity for inserting particles into the point structure\n";
-		return nullptr;
-	}
-
-	return nullptr;
-}*/
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/pointStructure/pointStructure.hpp b/src/phasicFlow/structuredData/pointStructure/pointStructure.hpp
index be70072d..51e76aea 100644
--- a/src/phasicFlow/structuredData/pointStructure/pointStructure.hpp
+++ b/src/phasicFlow/structuredData/pointStructure/pointStructure.hpp
@@ -17,362 +17,163 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
-
 #ifndef __pointStructure_hpp__
 #define __pointStructure_hpp__
 
-
-
-#include "Vectors.hpp"
-#include "VectorSingles.hpp"
-#include "VectorDuals.hpp"
-#include "Fields.hpp"
-#include "eventSubscriber.hpp"
-#include "indexContainer.hpp"
-
-
+#include "IOobject.hpp"
+#include "demComponent.hpp"
+#include "internalPoints.hpp"
+#include "simulationDomain.hpp"
+#include "boundaryList.hpp"
+#include "streams.hpp"
 
 namespace pFlow
 {
 
-//forward
-class box;
-class setFieldList;
-class repository;
-
 class pointStructure
 :
-	public eventSubscriber
+    public IOobject,
+    public demComponent,
+	public internalPoints
 {
 public:
 	
-	enum PointFlag: int8
-	{
-		DELETED 	= -1,
-		ACTIVE 		= 1
-	};
+	using PointsType 		= typename internalPoints::PointsType;
 
-	
-	inline static const size_t maxSizeDefault_ = 10000;
+	using PointsTypeHost 	= typename PointsType::FieldTypeHost;
 
-	class activePointsDevice
-	{
-	protected:
-		ViewType1D<int8> 	flag_;
+	using device_type 		= typename PointsType::device_type;
 
-		bool allActive_;
+	using memory_space 		= typename PointsType::memory_space;
 
-		range activeRange_;
+	using execution_space 	= typename PointsType::execution_space;
 
-	public:
-
-		INLINE_FUNCTION_H
-		activePointsDevice(bool allActive, range active, const ViewType1D<int8>& flag)
-		:
-			flag_(flag),
-			allActive_(allActive),
-			activeRange_(active)
-		{}
-
-		INLINE_FUNCTION_HD
-		activePointsDevice(const activePointsDevice&) = default;
-
-		INLINE_FUNCTION_HD
-		activePointsDevice& operator=(const activePointsDevice&) = default;
-
-		INLINE_FUNCTION_HD
-		bool operator()(int32 i)const {
-			if(i<activeRange_.second && flag_[i] == 1)return true;
-			return false;
-		}
-
-		INLINE_FUNCTION_HD
-		auto activeRange()const {
-			return activeRange_; 
-		}
-
-		INLINE_FUNCTION_HD
-		auto allActive()const {
-			return allActive_;
-		}
-
-	};
-
-	class activePointsHost
-	{
-	protected:
-		
-		ViewType1D<int8, HostSpace> 	flag_;
-
-		bool allActive_;
-
-		range activeRange_;
-
-	public:
-
-		INLINE_FUNCTION_H
-		activePointsHost(bool allActive, range active, const ViewType1D<int8, HostSpace>& flag)
-		:
-			flag_(flag),
-			allActive_(allActive),
-			activeRange_(active){}
-
-		INLINE_FUNCTION_H
-		activePointsHost(const activePointsHost&) = default;
-
-		INLINE_FUNCTION_H
-		activePointsHost& operator=(const activePointsHost&) = default;
-
-		INLINE_FUNCTION_H
-		bool operator()(int32 i)const {
-			if(i <activeRange_.second && flag_[i] == PointFlag::ACTIVE)return true;
-			return false;
-		}
-
-		INLINE_FUNCTION_H
-		auto activeRange()const{
-			return activeRange_;
-		}
-
-		INLINE_FUNCTION_H
-		bool allActive()const {
-			return allActive_;
-		}
-	};
-
-protected:
+private:
 
 	//// - data members 
+	uniquePtr<simulationDomain> simulationDomain_ = nullptr;
 
-		// number of points / size of structure
-		size_t 			numPoints_ 		= 0;	
+	boundaryList 				boundaries_;
+    
+	bool setupPointStructure(const realx3Vector& points);
 
-		// maximum number of points
-		size_t 			maxPoints_ 		= maxSizeDefault_;
+    bool setupPointStructure(const PointsTypeHost& points);
 
-		// flag of points on device
-		int8Field_HD 			pointFlag_;
-
-		// position of points on device
-		realx3Field_D 			pointPosition_;
-
-		// number of active points
-		size_t 					numActivePoints_ = 0;
-
-		// index range of active points (half-open range)
-		range 					activeRange_;	
-
-		/// Index vector for points to be inserted 
-		int32IndexContainer   	tobeInsertedIndex_;
-
-		/// Sorted index of particles based on morton code 
-		int32IndexContainer 	mortonSortedIndex_;
-	
-
-	//// - protected methods
-		FUNCTION_H
-		bool evaluatePointStructure();
-
-		FUNCTION_H
-		void setNumMaxPoints();
-
-		// - access to pointPosition
-		FUNCTION_H
-		realx3Field_D& pointPosition();
-		
-		// - access to pointFlag
-		FUNCTION_H
-		int8Field_HD& pointFlag();
-
-		FUNCTION_H
-		uniquePtr<int32IndexContainer> 
-			getNewPointsIndices(int32 numNewPoints)const;
+    bool initializePoints(const PointsTypeHost& points);
 
 public:
 
-	friend class dynamicPointStructure;
-	
+		
 	// - type info
 	TypeInfo("pointStructure");
 	
 
 	//// - Constructors 
 
-		// - an empty pointStructure, good for reading from file 
-		pointStructure();
+		/// an empty pointStructure, good for reading from file 
+		explicit pointStructure(systemControl& control);
 
-		// - construct from components
-		pointStructure(const int8Vector& flgVec, const realx3Vector& posVec);
+		/// construct from point positions, assume all points are active
+		pointStructure(
+            systemControl& control,
+			const realx3Vector& posVec);
 
-		// - construct from point positions, assume all points are active
-		pointStructure(const realx3Vector& posVec);
+		pointStructure(const pointStructure&) = delete;
 
-		// - copy construct
-		//
-		//   should be changed, may causs undefined behavior 
-		//////////////////////////////////////////////////////////////
-		pointStructure(const pointStructure&) = default;
-
-		
 		// - no move construct 
 		pointStructure(pointStructure&&) = delete;
 
-		// - copy assignment 
-		//
-		//   should be changed, may causs undefined behavior 
-		//////////////////////////////////////////////////////////////
-		pointStructure& operator=(const pointStructure&) = default;
+		
+		pointStructure& operator=(const pointStructure&) = delete;
 
 		// - no move assignment 
 		pointStructure& operator=(pointStructure&&) = delete;
 
 		// - destructor 
-		virtual ~pointStructure() = default;
+		~pointStructure() override = default;
 
+	// - Iteration methods
 
-	//// - Methods
-		activePointsDevice activePointsMaskD()const
+		/// 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;
+
+		/// This is called in time loop, after iterate.
+		bool afterIteration() override;
+
+    // - Access methods 
+
+        auto& boundaries()
+        {
+            return boundaries_;
+        }
+
+        const auto& boundaries()const
+        {
+            return boundaries_;
+        }
+
+		Time& time() override
 		{
-			return activePointsDevice(
-				this->allActive(),
-				activeRange(),
-				pointFlag_.deviceVectorAll()
-				);
+			return demComponent::time();
 		}
-
-		activePointsHost activePointsMaskH()const
-		{
-			return activePointsHost(
-				this->allActive(),
-				activeRange(),
-				pointFlag_.hostVectorAll()
-				);
-		}
-
-		// - const access pointPosition
-		FUNCTION_H
-		const realx3Field_D& pointPosition()const;
 		
-		// - const access to pointFlag
-		FUNCTION_H
-		const int8Field_HD& pointFlag()const;
-
-		INLINE_FUNCTION_H
-		auto pointPositionHostAll()
+		const Time& time() const override
 		{
-			return pointPosition_.hostVectorAll();
+			return demComponent::time();
 		}
-
-		// - size of data structure
-		FUNCTION_H
-		label size()const;
 		
-		// - maximum capacity of data structure 
-		FUNCTION_H
-		label capacity()const;
+        boundaryBase& boundary(size_t i ) override
+        {
+            return boundaries_[i];
+        }
+
+        const boundaryBase& boundary(size_t i)const override
+        {
+            return boundaries_[i];
+        }
+
+		inline
+		const auto& simDomain()const
+		{
+			return simulationDomain_();
+		}
+
+		inline 
+		const auto& thisDomain()const
+		{
+			return simulationDomain_().thisDomain();
+		}
 		
-		// - number of active points 
-		FUNCTION_H
-		label numActive() const;
-				
-		// - if all points are active 
-		FUNCTION_H
-		bool allActive()const;
+	// - IO methods 
 
-		INLINE_FUNCTION_H
-		range activeRange()const
-		{
-			return activeRange_;
-		}
-
-		INLINE_FUNCTION_H
-		bool isActive(label i)const
-		{
-			return pointFlag_[i] == ACTIVE;
-		}
-
-		FUNCTION_H
-		size_t markDeleteOutOfBox(const box& domain);
-
-		// - update data structure by removing the marked points 
-		//   Notifies all the fields that are built based on this data structure
-		//   and then apply removing to the pointPosition_ and pointFlag_
-		FUNCTION_H
-		virtual bool updateForDelete();
-
-
-		FUNCTION_H
-		virtual bool mortonSortPoints(const box& domain, real dx);
-
-		///////////////////////////////////////////////////////////////////////////////////////////////////
+		/// @brief read the point structure from the input stream.
+		/// @param is: input stream
+		/// @param iop: type of input pattern
+		/// @return true on success
+		bool read(iIstream& is, const IOPattern& iop) override;
 		
-		// - const access to points to be newly inserted
-		FUNCTION_H 
-		auto insertedPointIndex()const
-		{
-			return tobeInsertedIndex_;
-		}
 
-		FUNCTION_H 
-		auto insertedPointIndexH()const
-		{
-			return tobeInsertedIndex_.hostView();
-		}
-
-		FUNCTION_H 
-		auto insertedPointIndexD()const
-		{
-			return tobeInsertedIndex_.deviceView();
-		}
-
-
-		FUNCTION_H
-		auto mortonSortedIndex()const
-		{
-			return mortonSortedIndex_;
-		}
-
-
-		// - update data structure by inserting/setting new points 
-		//   Notifies all the fields in the registered list of data structure
-		//   and exclude the fields that re in the exclusionList
-		//   retrun nullptr if it fails 
-		FUNCTION_H
-		virtual uniquePtr<int32IndexContainer> insertPoints(
-			const realx3Vector& pos,
-			const setFieldList& setField,
-			repository& owner,
-			const List<eventObserver*>& exclusionList={nullptr}
-		);
-
-	
-	//// - IO operations 
-		// - read pointStructure from is
-		FUNCTION_H
-		bool readPointStructure(iIstream& is);
-
-		// - write pointStructure to os
-		FUNCTION_H
-		bool writePointStructure(iOstream& os)const;
-
-		// - read 
-		FUNCTION_H
-		bool read(iIstream& is)
-		{
-			return readPointStructure(is);
-		}
-
-		// - write 
-		FUNCTION_H
-		bool write(iOstream& os)const
-		{
-			return writePointStructure(os);
-		}
+		/// Write 
+		bool write(iOstream& os, const IOPattern& iop)const override;
+        
 
 };
 
 
+/*inline iOstream& operator << (iOstream& os, const pointStructure& ps )
+{	
+	if( !ps.write(os, IOPattern::AllProcessorsDifferent) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+	return os; 
+}*/
+
 } // pFlow
 
 
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.hpp b/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.hpp
index ee8b099b..a3ce07cc 100644
--- a/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.hpp
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.hpp
@@ -62,9 +62,9 @@ public:
 		const pointStructure& pStruct()const;
 
 
-		virtual const int32Vector& selectedPoinsts()const = 0;
+		virtual const uint32Vector& selectedPoinsts()const = 0;
 
-		virtual int32Vector& selectedPoinsts() = 0;
+		virtual uint32Vector& selectedPoinsts() = 0;
 
 
 	static
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.cpp b/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.cpp
index 89e89cfc..a384b820 100644
--- a/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.cpp
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.cpp
@@ -31,7 +31,7 @@ void pFlow::selectBox::selectAllPointsInBox()
 	);
 
 	selectedPoints_.clear();
-	auto pPos = pStruct().pointPosition().hostVector();
+	auto pPos = pStruct().pointPosition().hostView();
 	
 	ForAll(i , pPos)
 	{
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.hpp b/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.hpp
index cacc8afa..88c5a5b2 100644
--- a/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.hpp
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/selectBox/selectBox.hpp
@@ -38,7 +38,7 @@ class selectBox
 {
 protected:
 	
-	int32Vector selectedPoints_;
+	uint32Vector selectedPoints_;
 
 	box 		box_;
 
@@ -63,12 +63,12 @@ public:
 
 	//// - Methods
 
-		virtual const int32Vector& selectedPoinsts()const override
+		virtual const uint32Vector& selectedPoinsts()const override
 		{
 			return selectedPoints_;
 		}
 
-		virtual int32Vector& selectedPoinsts() override
+		virtual uint32Vector& selectedPoinsts() override
 		{
 			return selectedPoints_;
 		}
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.cpp b/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.cpp
index f25ef4c2..0963220b 100644
--- a/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.cpp
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.cpp
@@ -21,31 +21,31 @@ Licence:
 
 #include "selectRandom.hpp"
 #include "dictionary.hpp"
-#include "uniformRandomInt32.hpp"
+#include "uniformRandomUint32.hpp"
 #include "Set.hpp"
 
 
 bool pFlow::selectRandom::selectAllPointsInRange()
 {
 	// to reduct allocations
-	int32 maxNum = number_+1;
+	uint32 maxNum = number_+1;
 	
 	selectedPoints_.reserve	(maxNum);
 
 	selectedPoints_.clear();
 	
-	uniformRandomInt32 intRand (begin_, end_);
+	uniformRandomUint32 intRand (begin_, end_);
 
 
-	int32 n = 0;
-	int32 iter = 0;
+	uint32 n = 0;
+	uint32 iter = 0;
 	bool finished = false;
 
-	Set<int32> selctedIndices;
+	Set<uint32> selctedIndices;
 
 	while( iter < number_*100)
 	{
-		int32 newInd = intRand.randomNumber();
+		uint32 newInd = intRand.randomNumber();
 
 		if( auto [it, inserted] = selctedIndices.insert(newInd); inserted )
 		{
@@ -91,7 +91,7 @@ pFlow::selectRandom::selectRandom
 	),
 	begin_
 	(
-		dict.subDict("selectRandomInfo").getVal<int32>("begin")
+		dict.subDict("selectRandomInfo").getVal<uint32>("begin")
 	),
 	end_
 	(
@@ -102,9 +102,9 @@ pFlow::selectRandom::selectRandom
 		dict.subDict("selectRandomInfo").getValOrSet("number", 1)
 	)
 {
-	begin_ 	= max(begin_,1);
-	end_ 	= min(end_, static_cast<int32>(pStruct.size()));
-	number_ = max(number_,0);
+	begin_ 	= max(begin_,1u);
+	end_ 	= min(end_, static_cast<uint32>(pStruct.size()));
+	number_ = max(number_,0u);
 	if(end_-begin_ < number_)
 	{
 
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.hpp b/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.hpp
index 48a7cd1c..b132e9ee 100644
--- a/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.hpp
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/selectRandom/selectRandom.hpp
@@ -37,16 +37,16 @@ class selectRandom
 {
 protected:
 	
-	int32Vector selectedPoints_;
+	uint32Vector selectedPoints_;
 
 	// begin index
-	int32 	begin_;
+	uint32 	begin_;
 
 	// end index
-	int32 	end_;
+	uint32 	end_;
 
 	// stride
-	int32 	number_;
+	uint32 	number_;
 
 	bool selectAllPointsInRange();
 	
@@ -69,12 +69,12 @@ public:
 
 	//// - Methods
 
-		virtual const int32Vector& selectedPoinsts()const override
+		virtual const uint32Vector& selectedPoinsts()const override
 		{
 			return selectedPoints_;
 		}
 
-		virtual int32Vector& selectedPoinsts() override
+		virtual uint32Vector& selectedPoinsts() override
 		{
 			return selectedPoints_;
 		}
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.cpp b/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.cpp
index 09315952..ad7079e9 100644
--- a/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.cpp
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.cpp
@@ -25,13 +25,13 @@ Licence:
 void pFlow::selectRange::selectAllPointsInRange()
 {
 	// to reduct allocations
-	int32 maxNum = (end_ - begin_)/stride_+2;
+	uint32 maxNum = (end_ - begin_)/stride_+2;
 	
 	selectedPoints_.reserve	(maxNum);
 
 	selectedPoints_.clear();
 		
-	for(int32 i = begin_; i<end_; i+= stride_)
+	for(uint32 i = begin_; i<end_; i+= stride_)
 	{
 		selectedPoints_.push_back(i);
 	}
@@ -49,20 +49,20 @@ pFlow::selectRange::selectRange
 	),
 	begin_
 	(
-		dict.subDict("selectRangeInfo").getVal<int32>("begin")
+		dict.subDict("selectRangeInfo").getVal<uint32>("begin")
 	),
 	end_
 	(
-		dict.subDict("selectRangeInfo").getValOrSet("end", pStruct.size())
+		dict.subDict("selectRangeInfo").getValOrSet<uint32>("end", pStruct.size())
 	),
 	stride_
 	(
-		dict.subDict("selectRangeInfo").getValOrSet("stride", 1)
+		dict.subDict("selectRangeInfo").getValOrSet<uint32>("stride", 1u)
 	)
 {
-	begin_ 	= max(begin_,1);
-	end_ 	= min(end_, static_cast<int32>(pStruct.size()));
-	stride_ = max(stride_,1);
+	begin_ 	= max(begin_,1u);
+	end_ 	= min(end_, static_cast<uint32>(pStruct.size()));
+	stride_ = max(stride_,1u);
 
 	selectAllPointsInRange();
 }
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.hpp b/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.hpp
index 842b3278..9c86625a 100644
--- a/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.hpp
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/selectRange/selectRange.hpp
@@ -37,16 +37,16 @@ class selectRange
 {
 protected:
 	
-	int32Vector selectedPoints_;
+	uint32Vector selectedPoints_;
 
 	// begin index
-	int32 	begin_;
+	uint32 	begin_;
 
 	// end index
-	int32 	end_;
+	uint32 	end_;
 
 	// stride
-	int32 	stride_;
+	uint32 	stride_;
 
 	void selectAllPointsInRange();
 	
@@ -69,12 +69,12 @@ public:
 
 	//// - Methods
 
-		virtual const int32Vector& selectedPoinsts()const override
+		virtual const uint32Vector& selectedPoinsts()const override
 		{
 			return selectedPoints_;
 		}
 
-		virtual int32Vector& selectedPoinsts() override
+		virtual uint32Vector& selectedPoinsts() override
 		{
 			return selectedPoints_;
 		}
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.cpp b/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.cpp
deleted file mode 100644
index fe37308c..00000000
--- a/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-/*------------------------------- 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 "multiTriSurface.hpp"
-
-void pFlow::multiTriSurface::calculateVars()
-{
-	numSurfaces_ = surfaceNames_.size();
-
-	// make sure the host and device are sync
-	lastPointIndex_.syncViews();
-
-	surfaceNumPoints_.clear();
-	
-	int32 last = 0;
-	for(auto& pi:lastPointIndex_) 
-	{
-		surfaceNumPoints_.push_back(pi+1-last);
-		last = pi+1;
-	}
-	
-	// update views
-	surfaceNumPoints_.syncViews();
-
-	surfaceNumVertices_.clear();
-	last = 0;
-
-	lastVertexIndex_.syncViews();
-	
-
-	for(auto& vi:lastVertexIndex_)
-	{
-		surfaceNumVertices_.push_back(vi+1-last);
-		last = vi+1;
-	}
-	surfaceNumVertices_.syncViews();
-	
-	pointsStartPos_.reallocate(surfaceNumPoints_.capacity());
-	pointsStartPos_.clear();
-	
-	pointsStartPos_.push_back(0);
-
-	ForAll( i, surfaceNumPoints_)
-	{
-		if(i==0)continue;
-
-		pointsStartPos_.push_back( pointsStartPos_[i-1] + surfaceNumPoints_[i-1] );
-	}
-
-	pointsStartPos_.syncViews();
-	
-
-	verticesStartPos_.reallocate(surfaceNumVertices_.capacity());
-	verticesStartPos_.clear();
-
-	verticesStartPos_.push_back(0);
-	ForAll(i, surfaceNumVertices_)
-	{
-		if(i==0)continue;
-		verticesStartPos_.push_back(verticesStartPos_[i-1] + surfaceNumVertices_[i-1]);
-	}
-	verticesStartPos_.syncViews();
-	
-
-}
-
-pFlow::multiTriSurface::multiTriSurface()
-:
-	triSurface(),
-	lastPointIndex_("lastPointIndex", "lastPointIndex"),
-	lastVertexIndex_("lastVertexIndex", "lastVertexIndex"),
-	surfaceNames_("surfaceNames", "surfaceNames")
-{
-	calculateVars();
-}
-
-bool pFlow::multiTriSurface::addTriSurface
-(
-	const word& name,
-	const triSurface& tSurf
-)
-{
-
-	const auto& newPoints = tSurf.points();
-	const auto& newVertices = tSurf.vertices();
-	const auto& newAreas = tSurf.area();
-	
-	// 
-	
-	
-	points_.append(newPoints);
-	
-	
-	// add new vertices to the existing one
-	auto vOldSize = vertices_.size();
-	auto vNewSize =  vOldSize + newVertices.size();
-	vertices_.resize(vNewSize);
-	area_.resize(vNewSize);
-	
-	auto verVec = vertices_.deviceVectorAll();
-	auto areaVec = area_.deviceVectorAll();
-
-	auto newVerVec = newVertices.deviceVectorAll();
-	auto newArea = newAreas.deviceVectorAll();
-
-	auto maxIdx = maxIndex();
-
-	Kokkos::parallel_for(
-		"multiTriSurface::addTriSurface",
-		newVertices.size(),
-		LAMBDA_HD(int32 i){
-			verVec[vOldSize+i] = newVerVec[i]+(maxIdx+1);
-			areaVec[vOldSize+i] = newArea[i];
-		}
-		);
-	Kokkos::fence();
-
-	if( !check() )
-	{
-		fatalErrorInFunction<<
-		"the indices and number of points do not match. \n";
-		return false;
-	}
-
-	lastPointIndex_.push_back(points_.size()-1);
-	lastPointIndex_.syncViews();
-	
-	lastVertexIndex_.push_back(vertices_.size()-1);
-	lastVertexIndex_.syncViews();
-
-	surfaceNames_.push_back(name);
-
-	calculateVars();
-
-	return true;
-
-}
-
-bool pFlow::multiTriSurface::addTriSurface
-(
-	const word& name,
-	const realx3x3Vector& vertices
-)
-{
-	triSurface newSurf(vertices);
-
-	return addTriSurface(name, newSurf);
-}
-
-/*pFlow::real3*
-	pFlow::multiTriSurface::beginSurfacePoint
-(
-	unit i
-)
-{
-	if(i== 0) return points_.data();
-	if(i>=numSurfaces())return points_.data()+numPoints();
-	return points_.data()+lastPointIndex_[i-1]+1;
-}
-
-const pFlow::real3*
-	pFlow::multiTriSurface::beginSurfacePoint
-(
-	unit i
-)const
-{
-	if(i== 0) return points_.data();
-	if(i>=numSurfaces())return points_.data()+numPoints();
-	return points_.data()+lastPointIndex_[i-1]+1;
-}
-
-pFlow::real3* 
-	pFlow::multiTriSurface::endSurfacePoint
-(
-	unit i
-)
-{
-	if(i>=numSurfaces())return points_.data()+numPoints();
-	return points_.data()+lastPointIndex_[i]+1;
-}
-
-const pFlow::real3*
-	pFlow::multiTriSurface::endSurfacePoint
-(
-	unit i
-)const
-{
-	if(i>=numSurfaces())return points_.data()+numPoints();
-	return points_.data()+lastPointIndex_[i]+1;
-}*/
-
-bool pFlow::multiTriSurface::readMultiTriSurface
-(
-	iIstream& is
-)
-{
-	if( !readTriSurface(is) )return false;
-
-	// from current position
-	if(!lastPointIndex_.read(is, true)) return false;
-
-	if(!lastVertexIndex_.read(is, true) ) return false;
-
-	if( !surfaceNames_.read(is, true)) return false;
-
-	calculateVars();
-
-	return true;
-}
-
-bool pFlow::multiTriSurface::writeMultiTriSurface
-(
-	iOstream& os
-)const
-{
-	if(!writeTriSurface(os)) return false;
-
-	os << lastPointIndex_;
-	os << lastVertexIndex_;
-	os << surfaceNames_;
-
-	return os.check(FUNCTION_NAME);
-}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.hpp b/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.hpp
deleted file mode 100644
index 8791be86..00000000
--- a/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.hpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/*------------------------------- 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 __multiTriSurface_hpp__
-#define __multiTriSurface_hpp__
-
-
-#include "triSurface.hpp"
-#include "VectorDuals.hpp"
-
-namespace pFlow
-{
-
-
-class multiTriSurface
-:
-	public triSurface
-{
-protected:
-
-	// - the index of last point of each triSurface 
-	int32Field_HD 	lastPointIndex_;
-
-	// - the index of the last vertex of each triSurface 
-	int32Field_HD   lastVertexIndex_;
-
-	// - name of each surface 
-	wordField 		surfaceNames_;
-
-	int32Field_HD 	surfaceNumPoints_;
-
-	int32Vector_HD  pointsStartPos_;
-
-	int32Field_HD   surfaceNumVertices_;
-
-	int32Vector_HD  verticesStartPos_;
-
-	int32 			numSurfaces_ = 0;
-
-	void        calculateVars();
-
-public:
-
-	// - type info
-	TypeInfoNV("multiTriSurface");
-
-	//// - Constructors
-
-		// - emtpy
-		multiTriSurface();
-
-		multiTriSurface(const multiTriSurface&) = default;
-
-		multiTriSurface& operator = (const multiTriSurface&) = default;
-
-		multiTriSurface(multiTriSurface&&) = delete;
-
-		multiTriSurface& operator = (multiTriSurface&&) = delete;		
-
-		~multiTriSurface() = default;
-
-	//// - Methods
-
-		bool addTriSurface(const word& name, const triSurface& tSurf);
-
-		bool addTriSurface(const word& name, const realx3x3Vector& vertices);
-
-		int32 numSurfaces()const
-		{
-			return numSurfaces_;
-		}
-
-		void clear()
-		{
-			triSurface::clear();
-
-			lastPointIndex_.clear();
-			surfaceNames_.clear();
-		}
-
-		
-		const auto& pointsStartPos()const
-		{
-			return pointsStartPos_;
-		}
-
-		const auto& verticesStartPos()const
-		{
-			return verticesStartPos_;
-		}
-
-		const auto& surfaceNumPoints()const
-		{
-			return surfaceNumPoints_;
-		}
-
-		auto& surfaceNumPoints()
-		{
-			return surfaceNumPoints_;
-		}
-
-		int32 surfNumPoints(int32 i)const
-		{
-			return surfaceNumPoints_[i];
-		}
-
-		int32 surfNumTriangles(int32 i)const
-		{
-			return surfaceNumVertices_[i];
-		}
-
-		int32 surfSize(int32 i)const
-		{
-			return surfNumTriangles(i);
-		}
-
-		word surfaceName(int32 i)const
-		{
-			return surfaceNames_[i];
-		}
-
-	//// - IO operations
-
-		bool readMultiTriSurface(iIstream& is);
-
-		bool writeMultiTriSurface(iOstream& os)const;
-
-		bool read(iIstream& is)
-		{
-			return readMultiTriSurface(is);
-		}
-
-		bool write(iOstream& os)const
-		{
-			return writeMultiTriSurface(os);
-		}
-
-};
-
-inline iIstream& operator >> (iIstream & is, multiTriSurface & tri )
-{
-	if(!tri.readMultiTriSurface(is))
-	{
-	 	ioErrorInFile(is.name(), is.lineNumber())<<
-	 	"  error in reading multiTriSurface from file.\n";
-	 	fatalExit;
-	}
-	return is;
-}
-
-inline iOstream& operator << (iOstream& os, const multiTriSurface& tri)
-{
-	if( !tri.writeMultiTriSurface(os) )
-	{
-		ioErrorInFile(os.name(), os.lineNumber())<<
-	 	"  error in writing multiTriSurface to file.\n";
-	 	fatalExit;
-	}
-	return os;
-}
-
-}
-
-
-#endif
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.cpp b/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.cpp
deleted file mode 100644
index ff23104b..00000000
--- a/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-/*------------------------------- 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 "triSurface.hpp"
-#include "error.hpp"
-#include "iOstream.hpp"
-#include "triSurfaceKernels.hpp"
-
-
-pFlow::int32  pFlow::triSurface::addTriangle
-(
-	const realx3x3 & tri,
-	realx3Vector& points,
-	int32x3Vector& vertices
-)
-{
-	int32x3 newTri;
-
-		// first point
-	if ( int32 i = find(points, tri.x()) ; i > -1)
-	{ 
-		newTri.x() = i; // existing point 
-	}
-	else
-	{ 
-		points.push_back(tri.x());  // new point
-		newTri.x() = static_cast<int32>(points.size()) - 1;
-	}
-	
-	// second point
-	
-	if ( int32 j = find(points, tri.y()) ; j > -1)
-	{ 
-		newTri.y() = j; // existing point 
-	}
-	else
-	{ 
-		points.push_back(tri.y());  // new point
-		newTri.y() = static_cast<int32>(points.size()) - 1;
-	}
-	
-	// third point 
-	
-	if ( int32 k = find(points, tri.z()) ; k > -1)
-	{ 
-		newTri.z() = k; // existing point 
-	}
-	else
-	{ 
-		points.push_back(tri.z());  // new point
-		newTri.z() = static_cast<int32>(points.size()) - 1;
-	}
-	
-	// adds the new tirple vertices to the list
-	vertices.push_back( newTri );
-
-	//output<< " points " <<points << endl;
-	//output<< " vertices "<<vertices <<endl;
-
-	return static_cast<int32>(vertices.size()) -1;
-}
-
-pFlow::int32 pFlow::triSurface::calcMaxIndex()const
-{
-
-	int32 maxIdx = -1;
-
-	if(vertices_.size()>0)
-	{
-		auto verDeviceVec = vertices_.deviceVectorAll();
-		
-		Kokkos::parallel_reduce(
-			"triSurface::calcMaxIndex",
-			vertices_.size(),
-			LAMBDA_HD(int32 i, int32& valueToUpdate){
-				valueToUpdate = max(valueToUpdate, max(verDeviceVec[i]));
-			},
-			Kokkos::Max<int32>( maxIdx )
-			);
-	}
-
-	return maxIdx;
-}
-
-bool pFlow::triSurface::check()
-{
-
-	auto maxIdx = calcMaxIndex();
-	maxIndex_ = maxIdx;
-	if( maxIdx >= static_cast<int32>(points_.size())) return false;
-	return true;
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
-pFlow::triSurface::triSurface()
-:
-	points_("points"),
-	vertices_("vertices"),
-	area_("area"),
-	maxIndex_(-1)
-{}
-
-pFlow::triSurface::triSurface
-(
-	const realx3Vector& points,
-	const int32x3Vector& vertices
-)
-:
-	points_("points", "points", points),
-	vertices_("vertices", "vertices", vertices),
-	area_("area", "area"),
-	maxIndex_(-1)
-{
-	if( check() )
-	{
-		fatalErrorInFunction<<
-		"the indices and number of points do not match. \n";
-		fatalExit;
-	}
-
-	area_.reallocate(vertices_.capacity(), vertices_.size());
-
-	pFlow::triSurfaceKernels::calculateArea(points_, vertices_, area_);
-
-}
-
-
-pFlow::triSurface::triSurface
-(
-	const realx3x3Vector& triangles
-)
-:
-	points_("points"),
-	vertices_("vertices"),
-	area_("area")
-{
-
-	Vector<realx3> points;
-	Vector<int32x3> vertices;
-	
-	points.clear();
-	vertices.clear();
-
-	for( const auto& tr: triangles)
-	{
-		if(auto i= addTriangle(tr, points, vertices); i < 0 )
-		{
-			fatalErrorInFunction <<
-			"failed to insert a triangle into triSurface. \n";
-			fatalExit;
-		}
-	}
-
-	points_.assign(points);
-
-	vertices_.assign(vertices);
-
-	area_.reallocate(vertices_.capacity(), vertices_.size());
-
-	pFlow::triSurfaceKernels::calculateArea(points_, vertices_, area_);
-
-	if( !check() )
-	{
-		fatalErrorInFunction<<
-		"the indices and number of points do not match. \n";
-		fatalExit;
-	}
-}
-
-
-bool pFlow::triSurface::readTriSurface
-(
-	iIstream& is
-)
-{
-
-	std::cout<<"triSurface file is binary "<< is.isBinary()<<std::endl;
-
-	is.fatalCheck(FUNCTION_NAME);
-
-	// from start of file
-	if(!points_.read(is)) return false;
-	
-	// from the current position
-	if(!vertices_.read(is, true)) return false;
-	
-	if( !check() )
-	{
-		ioErrorInFile( is.name(), is.lineNumber() ) <<
-		"the indices and number of points do not match. \n";
-		return false;
-	}
-
-	area_.reallocate(vertices_.capacity(), vertices_.size());
-
-	pFlow::triSurfaceKernels::calculateArea(points_, vertices_, area_);
-
-	return true;
-}
-
-bool pFlow::triSurface::writeTriSurface
-(
-	iOstream& os
-)const
-{
-	
-	os << points_;
-	os << vertices_;
-
-	return os.check(FUNCTION_NAME);;
-}
-
-
-
-
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.hpp b/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.hpp
deleted file mode 100644
index 0583b353..00000000
--- a/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.hpp
+++ /dev/null
@@ -1,288 +0,0 @@
-/*------------------------------- 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 __triSurface_hpp__
-#define __triSurface_hpp__
-
-#include "eventSubscriber.hpp"
-#include "types.hpp"
-#include "Vectors.hpp"
-#include "VectorSingles.hpp"
-#include "Fields.hpp"
-
-namespace pFlow
-{
-
-
-class iIstream;
-class iOstream;
-
-class triSurface
-:
-	public eventSubscriber
-{
-public:
-	
-	class triangleAccessor
-	{
-	public:
-
-	protected:
-		int32 		numPoints_;
-		
-		int32 		numTriangles_;
-
-		deviceViewType1D<realx3> dPoints_;
-		
-		deviceViewType1D<int32x3>  dVectices_;
-	public:
-
-		INLINE_FUNCTION_H
-		triangleAccessor(
-			int32 	numPoints,
-			deviceViewType1D<realx3> points,
-			int32 	numTrianlges,
-			deviceViewType1D<int32x3> vertices )
-		:
-			numPoints_(numPoints),
-			numTriangles_(numTrianlges),
-			dPoints_(points),
-			dVectices_(vertices)
-		{}
-
-		INLINE_FUNCTION_HD
-		triangleAccessor(const triangleAccessor&)= default;
-
-		INLINE_FUNCTION_HD
-		triangleAccessor& operator=(const triangleAccessor&)= default;
-
-		INLINE_FUNCTION_HD
-		triangleAccessor(triangleAccessor&&)= default;
-
-		INLINE_FUNCTION_HD
-		triangleAccessor& operator=(triangleAccessor&&)= default;
-
-		INLINE_FUNCTION_HD
-		~triangleAccessor()=default;
-
-		INLINE_FUNCTION_HD
-		realx3x3 triangle(int32 i)const	{
-			auto v = dVectices_[i];
-			return realx3x3(
-					dPoints_[v.x_],
-					dPoints_[v.y_],
-					dPoints_[v.z_]);
-		}
-
-		INLINE_FUNCTION_HD
-		realx3x3 operator()(int32 i)const { return triangle(i);	}
-
-		INLINE_FUNCTION_HD
-		realx3x3 operator[](int32 i)const {	return triangle(i);	}
-
-		INLINE_FUNCTION_HD
-		int32 numPoints()const { return numPoints_; }
-
-		INLINE_FUNCTION_HD
-		int32 numTrianlges()const { return numTriangles_;}
-	};
-
-protected:
-
-	/// points of triangles
-	realx3Field_D points_;
-
-	/// vectices indices of triangles 
-	int32x3Field_D vertices_;
-
-	/// area of each triangle 
-	realField_D  	area_;
-
-	int32 maxIndex_ = -1; 
-
-	
-	// protected methods 
-
-
-		int32 addTriangle(const realx3x3 & tri, realx3Vector& points, int32x3Vector& vertices);
-
-		// - check if the range of indices in vectors match 
-		bool check();
-
-public:
-
-	// - type info
-	TypeInfo("triSurface");
-
-	//// - Constructors
-
-		// - empty
-		triSurface();
-
-		// - construct from components
-		triSurface(const realx3Vector& points, const int32x3Vector& vertices);
-
-		// - construct from vertices of triangles 
-		triSurface(const realx3x3Vector& triangles);
-
-		virtual ~triSurface() = default;
-
-	//// - Methods
-		size_t numPoints() const
-		{
-			return points_.size();
-		}
-
-		size_t numTriangles()const
-		{
-			return vertices_.size();
-		}
-
-		size_t size()const
-		{
-			return numTriangles();
-		}
-
-		size_t capacity()const
-		{
-			return vertices_.capacity();
-		}
-
-		int32 maxIndex()const
-		{
-			return maxIndex_;
-		}
-
-		auto getTriangleAccessor()const
-		{
-			return triangleAccessor(
-				numPoints(),
-				points_.deviceVectorAll(),
-				numTriangles(),
-				vertices_.deviceVectorAll()
-				);
-		}
-
-		const realx3Vector_D& points() const
-		{
-			return points_;
-		}
-
-		realx3Vector_D& points()
-		{
-			return points_;
-		}
-
-		const realVector_D& area()const
-		{
-			return area_;
-		}
-
-		realVector_D& area()
-		{
-			return area_;
-		}		
-
-		const realx3* pointsData_D()const
-		{
-			return points_.deviceVectorAll().data();
-		}
-
-		realx3* pointsData_D()
-		{
-			return points_.deviceVectorAll().data();
-		}
-
-		const int32x3Vector_D& vertices() const
-		{
-			return vertices_;
-		}
-
-		int32x3Vector_D& vertices()
-		{
-			return vertices_;
-		}
-
-		int32x3* verticesData_D()
-		{
-			return vertices_.deviceVectorAll().data();
-		}
-
-		const int32x3* verticesData_D()const
-		{
-			return vertices_.deviceVectorAll().data();
-		}
-
-		void clear()
-		{
-			points_.clear();
-			vertices_.clear();
-			area_.clear();
-		}
-
-		int32 calcMaxIndex()const;
-		
-	//// - IO operations 
-
-		bool readTriSurface(iIstream& is);
-
-		bool writeTriSurface(iOstream& os)const;
-
-		bool read(iIstream& is)
-		{
-			return readTriSurface(is);
-		}
-
-		bool write(iOstream& os)const
-		{
-			return writeTriSurface(os);
-		}
-
-};
-
-inline iIstream& operator >> (iIstream & is, triSurface & tri )
-{
-	if(!tri.readTriSurface(is))
-	{
-	 	ioErrorInFile(is.name(), is.lineNumber())<<
-	 	"  error in reading triSurface from file.\n";
-	 	fatalExit;
-	}
-	return is;
-}
-
-inline iOstream& operator << (iOstream& os, const triSurface& tri)
-{
-	if( !tri.writeTriSurface(os) )
-	{
-		ioErrorInFile(os.name(), os.lineNumber())<<
-	 	"  error in writing triSurface to file.\n";
-	 	fatalExit;
-	}
-	return os;
-}
-
-
-} // pFlow
-
-
-
-#endif
diff --git a/src/phasicFlow/triSurface/multiTriSurface.cpp b/src/phasicFlow/triSurface/multiTriSurface.cpp
new file mode 100644
index 00000000..e73f4382
--- /dev/null
+++ b/src/phasicFlow/triSurface/multiTriSurface.cpp
@@ -0,0 +1,105 @@
+/*------------------------------- 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 "multiTriSurface.hpp"
+
+pFlow::multiTriSurface::multiTriSurface
+(
+	const objectFile &obj, 
+	repository *owner
+)
+:
+	triSurface(obj, owner),
+	subscriber("multiTriSurface")
+{
+	if( !IOobject::readObject() )
+    {
+        fatalErrorInFunction<<
+        "Error in reading from file "<<IOobject::path()<<endl;
+        fatalExit;
+    }
+}
+
+pFlow::multiTriSurface::multiTriSurface
+(
+	const objectFile &objf, 
+	repository *owner, 
+	const multiTriSurface &surf
+)
+:
+	triSurface(objf, owner, surf),
+	subscriber("multiTriSurface"),
+	subSurfaces_(surf.subSurfaces_)
+{
+	
+}
+
+bool pFlow::multiTriSurface::appendSurface
+(
+	const word &name, 
+	const realx3x3Vector &triangles
+)
+{
+	uint32 start = size();
+	uint32 pointStart = numPoints();
+
+	if(!triSurface::append(triangles))
+	{
+		fatalErrorInFunction;
+		return false;
+	}
+	uint32 end = size();
+	uint32 pointEnd = numPoints();
+	subSurfaces_.emplace_back(name, start, end, pointStart, pointEnd);
+
+    return true;
+}
+
+bool pFlow::multiTriSurface::read(iIstream &is, const IOPattern &iop)
+{	
+	subSurfaces_.clear();
+
+	if( !is.findKeywordAndVal("subSurfaces", subSurfaces_ ) )
+	{
+		fatalErrorInFunction<<
+		"Error in reading subSurfaces from stream "<< is.name()<<endl;
+		return false;
+	}
+
+    return triSurface::read(is, iop);
+}
+
+bool pFlow::multiTriSurface::write
+(
+    iOstream &os,
+    const IOPattern &iop
+) const
+{	
+
+	
+	if( iop.thisProcWriteData() )
+	{
+		os.writeWordEntry("subSurfaces", subSurfaces_);
+		if(!os.check(FUNCTION_NAME))return false;
+	}
+	
+	return triSurface::write(os,iop);
+}
diff --git a/src/phasicFlow/triSurface/multiTriSurface.hpp b/src/phasicFlow/triSurface/multiTriSurface.hpp
new file mode 100644
index 00000000..b95977d3
--- /dev/null
+++ b/src/phasicFlow/triSurface/multiTriSurface.hpp
@@ -0,0 +1,184 @@
+/*------------------------------- 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 __multiTriSurface_hpp__
+#define __multiTriSurface_hpp__
+
+#include "subscriber.hpp"
+#include "triSurface.hpp"
+#include "subSurface.hpp"
+
+namespace pFlow
+{
+
+class multiTriSurface
+:
+	public triSurface,
+	public subscriber
+{
+private:
+
+	subSurfaceList subSurfaces_;
+
+public:
+
+	// - type info
+	TypeInfo("multiTriSurface");
+
+	//// - Constructors
+
+		/// @brief  Construct from objectFile and owner repository.
+		/// This is mainly used for reading from file.
+		/// @param obj object file 
+		/// @param owner owner repository 
+		multiTriSurface(const objectFile& obj, repository* owner);
+
+		/// @brief Construct from another multiTriSurface 
+		multiTriSurface(
+			const objectFile& objf, 
+			repository* owner, 
+			const multiTriSurface& surf);
+
+		/// @brief Copy construct (default)
+		multiTriSurface(const multiTriSurface&) = default;
+
+		/// @brief Copy assignment (default)
+		multiTriSurface& operator = (const multiTriSurface&) = default;
+
+		/// @brief  No move construct
+		multiTriSurface(multiTriSurface&&) = delete;
+
+		/// @brief No move assignment 
+		multiTriSurface& operator = (multiTriSurface&&) = delete;
+
+		/// @brief  default destructor 
+		~multiTriSurface() override = default;
+
+	//// - Methods
+
+		bool appendSurface(
+			const word& name, 
+			const realx3x3Vector& vertices);
+
+		uint32 numSurfaces()const
+		{
+			return static_cast<uint32>(subSurfaces_.size());
+		}
+
+		const subSurfaceList& subSurfaces()const
+		{
+			return subSurfaces_;
+		}
+		
+		rangeU32 subSurfaceRange(uint32 nSub)const
+		{
+			if( !(nSub < numSurfaces() ) )
+			{
+				fatalErrorInFunction;
+				fatalExit;
+			}
+			return {subSurfaces_[nSub].start(),subSurfaces_[nSub].end()};
+		}
+
+		rangeU32 subSurfacePointRange(uint32 nSub)const
+		{
+			if( !(nSub < numSurfaces() ) )
+			{
+				fatalErrorInFunction;
+				fatalExit;
+			}
+			return {
+				subSurfaces_[nSub].pointStart(),
+				subSurfaces_[nSub].pointEnd()};
+		}
+
+		/// @brief Clear the content of object
+		void clear()
+		{
+			triSurface::clear();
+			subSurfaces_.clear();
+		}
+
+		
+		uint32 subSurfaceSize(uint32 nSub)const
+		{
+			if(nSub<numSurfaces())
+			{
+				return subSurfaceRange(nSub).numElements();
+			}
+			else
+			{
+				return 0;
+			}
+		}
+
+		uint32 subSurfaceNumPoints(uint32 nSub)const
+		{
+			if(nSub<numSurfaces())
+			{
+				return subSurfacePointRange(nSub).numElements();
+			}
+			else
+			{
+				return 0;
+			}
+		}
+		
+		word subSurfaceName(uint32 nSub)const
+		{
+			if(nSub<numSurfaces())
+			{
+				return subSurfaces_[nSub].name();
+			}
+			else
+			{
+				return "";
+			}
+		}
+
+	//// - IO operations
+
+		
+
+		bool read(iIstream& is, const IOPattern& iop)override;
+
+
+		bool write(iOstream& os, const IOPattern& iop)const override;
+		
+
+};
+
+
+inline iOstream& operator << (iOstream& os, const multiTriSurface& tri)
+{
+	if( !tri.write(os, IOPattern::AllProcessorsDifferent) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+	 	"  error in writing multiTriSurface to file.\n";
+	 	fatalExit;
+	}
+	return os;
+}
+
+} // pFlow
+
+
+#endif
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.cpp b/src/phasicFlow/triSurface/stlFile.cpp
similarity index 100%
rename from src/phasicFlow/structuredData/trisurfaceStructure/stlFile.cpp
rename to src/phasicFlow/triSurface/stlFile.cpp
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.hpp b/src/phasicFlow/triSurface/stlFile.hpp
similarity index 97%
rename from src/phasicFlow/structuredData/trisurfaceStructure/stlFile.hpp
rename to src/phasicFlow/triSurface/stlFile.hpp
index b072690f..6f47fbd5 100644
--- a/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.hpp
+++ b/src/phasicFlow/triSurface/stlFile.hpp
@@ -106,10 +106,10 @@ public:
 		size_t size()const;
 		
 		// - vertecies of ith solid
-		const realx3x3Vector& solid(label i)const;
+		const realx3x3Vector& solid(uint64 i)const;
 
 		// - name of ith solid 
-		const word& name(label i)const;
+		const word& name(uint64 i)const;
 
 };
 
diff --git a/src/phasicFlow/triSurface/subSurface.cpp b/src/phasicFlow/triSurface/subSurface.cpp
new file mode 100644
index 00000000..9fbd406b
--- /dev/null
+++ b/src/phasicFlow/triSurface/subSurface.cpp
@@ -0,0 +1,26 @@
+#include "subSurface.hpp"
+
+pFlow::iOstream& pFlow::operator<<(iOstream &str, const subSurface &sub)
+{
+    
+    str.beginSquare()<<sub.name_<<token::SPACE<<
+    sub.start_<<token::SPACE<<sub.end_<<token::SPACE<<
+    sub.pointStart_<<token::SPACE<<sub.pointEnd_;
+    str.endSquare();  
+	str.check(FUNCTION_NAME);
+    return str;
+
+}
+
+pFlow::iIstream& pFlow::operator>>(iIstream &str, subSurface &sub)
+{
+    str.readBeginSquare("subSurface");
+    str >> sub.name_;
+    str >> sub.start_;
+    str >> sub.end_;
+    str >> sub.pointStart_;
+    str >> sub.pointEnd_;
+    str.readEndSquare("subSurface");
+    str.check(FUNCTION_NAME);
+    return str;
+}
diff --git a/src/phasicFlow/triSurface/subSurface.hpp b/src/phasicFlow/triSurface/subSurface.hpp
new file mode 100644
index 00000000..f6cdc75f
--- /dev/null
+++ b/src/phasicFlow/triSurface/subSurface.hpp
@@ -0,0 +1,105 @@
+/*------------------------------- 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 "types.hpp"
+#include "List.hpp"
+
+namespace pFlow
+{
+
+class subSurface
+{
+private:
+    uint32  start_= 0;
+
+    uint32  end_ =  0;
+
+    uint32  pointStart_ = 0;
+
+    uint32  pointEnd_=0;
+
+    word    name_;
+
+public:
+    subSurface()=default;
+
+    subSurface(const word& name, uint32 start, uint32 end, uint32 pointStart, uint32 pointEnd)
+    :
+        start_(start),
+        end_(end),
+        pointStart_(pointStart),
+        pointEnd_(pointEnd),
+        name_(name)
+    {}
+
+    subSurface(const subSurface&) = default;
+
+    subSurface& operator = (const subSurface&) = default;
+
+    ~subSurface()=default;
+
+    uint32 operator()(uint32 i)const
+    {
+        return start_ + i;
+    }
+    uint32 start()const
+    {
+        return start_;
+    }
+
+    uint32 end()const
+    {
+        return end_;
+    }
+
+    uint32 pointStart()const
+    {
+        return pointStart_;
+    }
+
+    uint32 pointEnd()const
+    {
+        return pointEnd_;
+    }
+    
+    const auto& name()const
+    {
+        return name_;
+    }
+
+    uint32 size()const
+    {
+        return end_-start_;
+    }
+
+    friend iOstream& operator<< (iOstream& str, const subSurface & sub);
+		
+		/// >> operator 
+	friend iIstream& operator >> (iIstream & str, subSurface & sub);
+};
+
+iOstream& operator<< (iOstream& str, const subSurface & sub);
+
+iIstream& operator >> (iIstream & str, subSurface & sub);
+
+using subSurfaceList = List<subSurface>;
+
+
+}
\ No newline at end of file
diff --git a/src/phasicFlow/triSurface/triSurface.cpp b/src/phasicFlow/triSurface/triSurface.cpp
new file mode 100644
index 00000000..4daf1387
--- /dev/null
+++ b/src/phasicFlow/triSurface/triSurface.cpp
@@ -0,0 +1,299 @@
+/*------------------------------- 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 "triSurface.hpp"
+#include "error.hpp"
+#include "iOstream.hpp"
+#include "Vectors.hpp"
+#include "triSurfaceKernels.hpp"
+
+
+
+namespace pFlow
+{
+bool convertToTriSurfaceComponents
+(
+	uint32 basePointIndex,
+	span<realx3x3> tris, 
+	realx3Vector& points,
+	uint32x3Vector& vertices,
+	realVector& area,
+	realx3Vector& normal
+)
+{
+	auto nt = tris.size();
+
+	points.clear();
+	points.reserve(nt);
+	
+	vertices.clear();
+	vertices.resize(nt);
+
+	area.clear();
+	area.resize(nt);
+
+	normal.clear();
+	normal.resize(nt);
+
+	for(auto i=0; i<nt; i++)
+	{
+		uint32x3 newTri;
+		const auto& tri = tris[i];
+		if(!pFlow::triangle::valid(tri.comp1(),tri.comp2(), tri.comp3()))
+		{
+			fatalErrorInFunction<<
+			"Invalid triangle "<< tri << endl;
+			return false;
+		}
+
+		if(auto np = find(points, tri.comp1()); np<0 )
+		{
+			points.push_back(tri.comp1());  // new point
+			newTri.comp1() = static_cast<uint32>( basePointIndex + points.size() - 1);
+		}
+		else
+		{
+			newTri.comp1() = basePointIndex+static_cast<uint32>(np);
+		}
+
+		if(auto np = find(points, tri.comp2()); np<0 )
+		{
+			points.push_back(tri.comp2());  // new point
+			newTri.comp2() = static_cast<uint32>( basePointIndex + points.size() - 1);
+		}
+		else
+		{
+			newTri.comp2() = basePointIndex+static_cast<uint32>(np);
+		}
+
+		if(auto np = find(points, tri.comp3()); np<0 )
+		{
+			points.push_back(tri.comp3());  // new point
+			newTri.comp3() = static_cast<uint32>( basePointIndex + points.size() - 1);
+		}
+		else
+		{
+			newTri.comp3() = basePointIndex+static_cast<uint32>(np);
+		}
+
+		vertices[i] = newTri;
+		normal[i] = triangle::normal(tri.comp1(), tri.comp2(), tri.comp3());
+		area[i] = triangle::surface(tri.comp1(), tri.comp2(), tri.comp3());
+	}
+	
+	return true;
+}
+
+}
+
+bool pFlow::triSurface::calculateNormals()
+{
+    return pFlow::triSurfaceKernels::calculateNormals(
+		points_, 
+		vertices_, 
+		normals_);
+}
+
+bool pFlow::triSurface::calculateArea()
+{
+    return pFlow::triSurfaceKernels::calculateArea(
+		points_,
+		vertices_,
+		area_);
+}
+
+bool pFlow::triSurface::append
+(
+	const realx3x3Field_H &triangles
+)
+{
+	uint32 basePointIndex = numPoints();
+
+	auto triData = triangles.getSpan();
+
+	realx3Vector points("points");
+	uint32x3Vector vertices("vertices");
+	realVector area("area");
+	realx3Vector normal("normal");
+
+	if( !convertToTriSurfaceComponents(
+		basePointIndex, 
+		triData,
+		points,
+		vertices,
+		area,
+		normal))
+	{
+		fatalErrorInFunction<<
+		"Error in constructing triSuface from raw data "<<triangles.name()<<endl;
+		return false;
+	}
+
+	points_.append(points);
+	vertices_.append(vertices);
+	area_.append(area);
+	normals_.append(normal);
+
+    return true;
+}
+
+bool pFlow::triSurface::append(const realx3x3Vector &triangles)
+{
+    uint32 basePointIndex = numPoints();
+
+	auto triData = triangles.getSpan();
+
+	realx3Vector points("points");
+	uint32x3Vector vertices("vertices");
+	realVector area("area");
+	realx3Vector normal("normal");
+
+	if( !convertToTriSurfaceComponents(
+		basePointIndex, 
+		triData,
+		points,
+		vertices,
+		area,
+		normal))
+	{
+		fatalErrorInFunction<<
+		"Error in constructing triSuface from raw data "<<triangles.name()<<endl;
+		return false;
+	}
+
+	points_.append(points);
+	vertices_.append(vertices);
+	area_.append(area);
+	normals_.append(normal);
+
+    return true;
+}
+
+pFlow::triSurface::triSurface
+(
+    const objectFile &obj,
+    repository *owner
+)
+: 
+	IOobject
+	(
+        obj,
+        IOPattern::AllProcessorsSimilar,
+        owner
+	) 
+{
+	// this constructor is used by multiTrisurface and read operation is 
+	// done in that class 
+}
+
+pFlow::triSurface::triSurface
+(
+	const objectFile &objf,
+	repository* owner, 
+	const triSurface &surf
+)
+:
+	IOobject
+	(
+		objectFile
+		(
+			objf.name(),
+			objf.localPath(),
+			objectFile::READ_NEVER,
+			objf.wFlag()
+		),
+		IOPattern::AllProcessorsSimilar,
+		owner
+	),
+	points_(surf.points_),
+	vertices_(surf.vertices_),
+	area_(surf.area_),
+	normals_(surf.normals_)
+{}
+
+pFlow::triSurface::triSurface
+(
+    const realx3x3Field_H &triangles,
+    repository *owner
+)
+: 
+	IOobject
+	(
+        objectFile(
+            triangles.name(),
+            "",
+            IOobject::READ_NEVER,
+            IOobject::WRITE_ALWAYS),
+        IOPattern::AllProcessorsSimilar,
+        owner
+	)
+{
+	if( !append(triangles) )
+	{
+		fatalExit;
+	}
+}
+
+
+
+bool pFlow::triSurface::read(iIstream &is, const IOPattern &iop)
+{
+	points_.clear();
+	if(!points_.read(is, iop))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		" when reading field "<< points_.name()<<endl;
+		return false;
+	}
+
+	vertices_.clear();
+	if(!vertices_.read(is, iop))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		" when reading field "<< vertices_.name()<<endl;
+		return false;
+	}
+	
+	normals_.reallocate(vertices_.capacity(), vertices_.size());
+	area_.reallocate(vertices_.capacity(), vertices_.size());
+	calculateArea();
+	calculateNormals();
+    return true;
+}
+
+bool pFlow::triSurface::write(iOstream &os, const IOPattern &iop) const
+{
+	if( !points_.write(os, iop))
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+		"when writing field "<<points_.name()<<endl;
+		return false;
+	}
+
+	if( !vertices_.write(os,iop) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+		"when writing field "<<vertices_.name()<<endl;
+		return false;
+	}
+
+    return true;
+}
diff --git a/src/phasicFlow/triSurface/triSurface.hpp b/src/phasicFlow/triSurface/triSurface.hpp
new file mode 100644
index 00000000..09a572a0
--- /dev/null
+++ b/src/phasicFlow/triSurface/triSurface.hpp
@@ -0,0 +1,264 @@
+/*------------------------------- 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 __triSurface_hpp__
+#define __triSurface_hpp__
+
+
+#include "Vectors.hpp"
+#include "Fields.hpp"
+#include "IOobject.hpp"
+
+namespace pFlow
+{
+
+
+class iIstream;
+class iOstream;
+class repository;
+
+
+class triangleAccessor
+{
+private:
+	uint32 		numPoints_;
+	
+	uint32 		numTriangles_;
+
+	deviceViewType1D<realx3> dPoints_;
+	
+	deviceViewType1D<uint32x3>  dVectices_;
+public:
+
+	INLINE_FUNCTION_H
+	triangleAccessor(
+		uint32 	numPoints,
+		deviceViewType1D<realx3> points,
+		uint32 	numTrianlges,
+		deviceViewType1D<uint32x3> vertices )
+	:
+		numPoints_(numPoints),
+		numTriangles_(numTrianlges),
+		dPoints_(points),
+		dVectices_(vertices)
+	{}
+
+	INLINE_FUNCTION_HD
+	triangleAccessor(const triangleAccessor&)= default;
+
+	INLINE_FUNCTION_HD
+	triangleAccessor& operator=(const triangleAccessor&)= default;
+
+	INLINE_FUNCTION_HD
+	triangleAccessor(triangleAccessor&&)= default;
+
+	INLINE_FUNCTION_HD
+	triangleAccessor& operator=(triangleAccessor&&)= default;
+
+	INLINE_FUNCTION_HD
+	~triangleAccessor()=default;
+
+	INLINE_FUNCTION_HD
+	realx3x3 triangle(uint32 i)const	{
+		auto v = dVectices_[i];
+		return realx3x3(
+				dPoints_[v.x_],
+				dPoints_[v.y_],
+				dPoints_[v.z_]);
+	}
+
+	INLINE_FUNCTION_HD
+	realx3x3 operator()(uint32 i)const { return triangle(i);	}
+
+	INLINE_FUNCTION_HD
+	realx3x3 operator[](uint32 i)const { return triangle(i);	}
+
+	INLINE_FUNCTION_HD
+	uint32 numPoints()const { return numPoints_; }
+
+	INLINE_FUNCTION_HD
+	uint32 numTrianlges()const { return numTriangles_;}
+};
+
+
+
+class triSurface
+:
+	public IOobject
+{
+private:
+
+	/// points of triangles
+	realx3Field_D 		points_{"points", "points"};
+
+	/// vectices indices of triangles 
+	uint32x3Field_D 	vertices_{"vertices", "vertices"};
+
+	/// area of each triangle 
+	realField_D  		area_{"area", "area"};
+
+	/// normal vector of triangles 
+	realx3Field_D 		normals_{"normals", "normals"};
+
+protected:
+	
+	bool calculateNormals();
+
+	bool calculateArea();
+
+	bool append(const realx3x3Field_H& triangles);
+
+	bool append(const realx3x3Vector& triangles);
+
+
+	// to be used by multiTriSurface
+	triSurface(const objectFile& obj, repository* owner);
+
+public:
+
+	// - type info
+	TypeInfo("triSurface");
+
+	triSurface(
+		const objectFile& objf, 
+		repository* owner, 
+		const triSurface& surf);
+
+	//// - Constructors
+		
+		// - construct from vertices of triangles 
+		explicit triSurface(const realx3x3Field_H& triangles, repository* owner=nullptr);
+
+		// - construct from components
+		//triSurface(const realx3Vector& points, const uint32x3Vector& vertices);		
+
+		~triSurface() override = default;
+
+
+	//// - Methods
+		uint32 numPoints() const
+		{
+			return points_.size();
+		}
+
+		uint32 size()const
+		{
+			return vertices_.size();
+		}
+
+		uint32 capacity()const
+		{
+			return vertices_.capacity();
+		}
+
+		const auto& points() const
+		{
+			return points_;
+		}
+
+		auto& points()
+		{
+			return points_;
+		}
+
+		const auto& area()const
+		{
+			return area_;
+		}
+
+		auto& area()
+		{
+			return area_;
+		}		
+
+		const auto& vertices() const
+		{
+			return vertices_;
+		}
+
+		auto& vertices()
+		{
+			return vertices_;
+		}
+
+		auto& normals()
+		{
+			return normals_;
+		}
+
+		const auto& normals()const
+		{
+			return normals_;
+		}
+
+		void clear()
+		{
+			points_.clear();
+			vertices_.clear();
+			area_.clear();
+			normals_.clear();
+		}
+
+		/// Obtain an object for accessing triangles 
+		auto getTriangleAccessor()const
+		{
+			return triangleAccessor( 
+				points_.size(),
+				points_.deviceViewAll(),
+				vertices_.size(),
+				vertices_.deviceViewAll());
+		}
+		
+	//// - IO operations 
+		
+		bool read(iIstream& is, const IOPattern& iop) override;
+
+		bool write(iOstream& os, const IOPattern& iop)const override;
+};
+
+inline iIstream& operator >> (iIstream & is, triSurface & tri )
+{
+	if(!tri.read(is, IOPattern::AllProcessorsDifferent))
+	{
+	 	ioErrorInFile(is.name(), is.lineNumber())<<
+	 	"  error in reading triSurface from file.\n";
+	 	fatalExit;
+	}
+	return is;
+}
+
+inline iOstream& operator << (iOstream& os, const triSurface& tri)
+{
+	if( !tri.write(os, IOPattern::AllProcessorsDifferent) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+	 	"  error in writing triSurface to file.\n";
+	 	fatalExit;
+	}
+	return os;
+}
+
+
+} // pFlow
+
+
+
+#endif
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/triSurfaceKernels.hpp b/src/phasicFlow/triSurface/triSurfaceKernels.hpp
similarity index 62%
rename from src/phasicFlow/structuredData/trisurfaceStructure/triSurfaceKernels.hpp
rename to src/phasicFlow/triSurface/triSurfaceKernels.hpp
index f9cba450..7f79d06a 100644
--- a/src/phasicFlow/structuredData/trisurfaceStructure/triSurfaceKernels.hpp
+++ b/src/phasicFlow/triSurface/triSurfaceKernels.hpp
@@ -29,19 +29,47 @@ namespace pFlow::triSurfaceKernels
 {
 
 INLINE_FUNCTION_H
-bool calculateArea(const realx3Field_D& points, const int32x3Field_D& vertices, realField_D& area)
+bool calculateArea(
+	const realx3Field_D& points, 
+	const uint32x3Field_D& vertices, 
+	realField_D& area)
 {
 	auto numTri = vertices.size();
-	auto areaD = area.deviceVectorAll();
-	auto pointsD = points.deviceVectorAll();
-	auto verticesD = vertices.deviceVectorAll();
+	auto& areaD = area.deviceViewAll();
+	auto& pointsD = points.deviceViewAll();
+	auto& verticesD = vertices.deviceViewAll();
 
 	Kokkos::parallel_for(
 		"pFlow::triSurfaceKernels::calculateArea",
 		numTri,
-		LAMBDA_HD(int32 i){
+		LAMBDA_HD(uint32 i){
 			auto v = verticesD[i];
-			areaD[i] = pFlow::triangleFunctions::triangleSurface(
+			areaD[i] = pFlow::triangle::surface(
+				pointsD[v.x()],
+				pointsD[v.y()],
+				pointsD[v.z()]);
+		});
+
+	return true;
+}
+
+INLINE_FUNCTION_H
+bool calculateNormals(
+	const realx3Field_D& points, 
+	const uint32x3Field_D& vertices, 
+	realx3Field_D& normals)
+{
+	auto numTri = vertices.size();
+	auto& normalsD = normals.deviceViewAll();
+	auto& pointsD = points.deviceViewAll();
+	auto& verticesD = vertices.deviceViewAll();
+
+	Kokkos::parallel_for(
+		"pFlow::triSurfaceKernels::calculateNormals",
+		numTri,
+		LAMBDA_HD(uint32 i){
+			auto v = verticesD[i];
+			normalsD[i] = pFlow::triangle::normal(
 				pointsD[v.x()],
 				pointsD[v.y()],
 				pointsD[v.z()]);
diff --git a/src/phasicFlow/triSurface/triangleFunctions.hpp b/src/phasicFlow/triSurface/triangleFunctions.hpp
new file mode 100644
index 00000000..7345c07f
--- /dev/null
+++ b/src/phasicFlow/triSurface/triangleFunctions.hpp
@@ -0,0 +1,62 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef __triangleFunctions_hpp__
+#define __triangleFunctions_hpp__
+
+#include "types.hpp"
+
+namespace pFlow::triangle
+{
+
+INLINE_FUNCTION_HD
+real surface( const realx3& p1, const realx3& p2, const realx3& p3)
+{
+	realx3 V1 = p2 - p1;
+	realx3 V2 = p3 - p1;
+	return abs((cross(V1,V2)).length()/(real)2.0);	
+}
+
+INLINE_FUNCTION_HD
+realx3 normal(const realx3& p1, const realx3& p2, const realx3& p3)
+{
+	auto n = cross(p2-p1, p3-p1);
+	if( equal(n.length(), 0.0) )
+    	return zero3;
+	else
+		return normalize(n);
+}
+
+INLINE_FUNCTION_HD
+bool valid
+(
+	const realx3& p1, 
+	const realx3& p2, 
+	const realx3& p3
+)
+{
+  	return !equal(cross(p2-p1, p3-p1).length(), 0.0);
+}
+
+
+
+}
+
+#endif 
diff --git a/src/phasicFlow/typeSelection/typeInfo.hpp b/src/phasicFlow/typeSelection/typeInfo.hpp
index 31614d9a..44f0bb0a 100644
--- a/src/phasicFlow/typeSelection/typeInfo.hpp
+++ b/src/phasicFlow/typeSelection/typeInfo.hpp
@@ -44,78 +44,20 @@ Licence:
 };
 
 
-
-#define TypeInfo(tName)  \
-	inline static word TYPENAME() {return tName; } \
-	virtual word typeName() const {return TYPENAME();} 
-
-#define TypeInfoNV(tName)  \
-	inline static word TYPENAME() {return tName; } \
-	word typeName() const {return TYPENAME();} 
-
-
-#define TypeInfoTemplate(tName, Type)										\
-	has_static_member(TYPENAME);											\
-	inline static word TYPENAME()											\
-	{ 																		\
-	if constexpr( has_static_member_TYPENAME<Type,word(void)>::value) 		\
-		{ return word(tName)+"<"+Type::TYPENAME()+">";} 						\
-	else																	\
-		return word(tName)+"<"+basicTypeName<Type>()+">";						\
-	return "noTYPE"; 														\
-	}																		\
-	virtual word typeName() const { return TYPENAME();}
-
-#define TypeInfoTemplate2(tName, Type1, Type2)								\
-	has_static_member(TYPENAME);											\
-	inline static word TYPENAME()											\
-	{ 																		\
-	if constexpr( has_static_member_TYPENAME<Type1,word(void)>::value) 		\
-		{ return word(tName)+"<"+Type1::TYPENAME()+","+Type2::TYPENAME()+">";}	\
-	else																	\
-		return word(tName)+"<"+basicTypeName<Type1>()+","+Type2::TYPENAME()+">";\
-	return "noTYPE"; 														\
-	}																		\
-	virtual word typeName() const { return TYPENAME();}
-
-#define TypeInfoTemplate3(tName, Type1, Type2, Type3)						\
-	inline static word TYPENAME()											\
-	{ 																		\
-		return word(tName)+"<"+Type1::TYPENAME()+","+Type2::TYPENAME()+","+Type3::TYPENAME()+">";\
-	}																		\
-	virtual word typeName() const { return TYPENAME();}
-
-// this is the non-virtual version
-#define TypeInfoTemplateNV(tName, Type)										\
-	has_static_member(TYPENAME);											\
-	inline static word TYPENAME()											\
-	{ 																		\
-	if constexpr( has_static_member_TYPENAME<Type,word(void)>::value) 		\
-		{ return word(tName)+"<"+Type::TYPENAME()+">";} 					\
-	else																	\
-		return word(tName)+"<"+basicTypeName<Type>()+">";					\
-	return "noTYPE"; 														\
-	}																		\
-	inline word typeName() const { return TYPENAME();}
-
-
-#define TypeInfoTemplateNV2(tName, Type, tName2)							\
-	has_static_member(TYPENAME);											\
-	inline static word TYPENAME()											\
-	{ 																		\
-	if constexpr ( has_static_member_TYPENAME<Type,word(void)>::value) 		\
-		{ return word(tName)+"<"+Type::TYPENAME()+","+word(tName2)+">";} 	\
-	else																	\
-		return word(tName)+"<"+basicTypeName<Type>()+","+word(tName2)+">";	\
-	return "noTYPE"; 														\
-	}																		\
-	inline word typeName() const { return TYPENAME();}
-
-
-
-
 namespace pFlow
 {
+	//
+	template<typename T>
+	struct checkStatic
+	{
+		has_static_member(TYPENAME);	
+		
+		static constexpr
+		bool hasMember()
+		{
+			return has_static_member_TYPENAME<T,word(void)>::value;
+		}
+	};
 
 	template <typename T>
 	inline word basicTypeName()
@@ -137,35 +79,194 @@ namespace pFlow
 	template<>
 	inline word basicTypeName<int32>(){ return "int32"; }
 
-	template<>
-	inline word basicTypeName<int16>(){ return "int16"; }
-
-	template<>
+		template<>
 	inline word basicTypeName<int8>(){ return "int8"; }
 
 	template<>
-	inline word basicTypeName<label>(){ return "label"; }
+	inline word basicTypeName<uint64>(){ return "uint64"; }
 
 	template<>
 	inline word basicTypeName<uint32>(){ return "uint32"; }
 
+	template<>
+	inline word basicTypeName<uint8>(){ return "uint8"; }
+
 	template<>
 	inline word basicTypeName<real>(){ return "real"; }
 
+	
+	template<typename T>
+	word constexpr getTypeName()
+	{
 		
+		if constexpr ( checkStatic<T>::hasMember() )
+		{
+			return T::TYPENAME();
+		}else
+		{
+			return basicTypeName<T>();
+		}
+	}
+	template<typename T>
+	word constexpr getTypeName(const T&)
+	{
+		if constexpr ( checkStatic<T>::hasMember() )
+		{
+			return T::TYPENAME();
+		}else
+		{
+			return basicTypeName<T>();
+		}
+	}
+
 	// compare the overriden typeName of object with concrete TYPENAME 
 	// of Type1
 	template <typename Type1, typename Type2>
 	bool checkType(Type2* object)
 	{
-		return word(Type1::TYPENAME()) == object->typeName();
+		return getTypeName<Type1>() == object->typeName();
 	}
 
 	template <typename Type1, typename Type2>
 	bool checkType(Type2& object)
 	{
-		return word(Type1::TYPENAME()) == object.typeName();
+		return getTypeName<Type1>() == object.typeName();
 	}
+}
+
+
+#define TypeInfo(tName)  \
+	inline static word TYPENAME() {return tName; } \
+	virtual word typeName() const {return TYPENAME();} 
+
+#define TypeInfoNV(tName)  \
+	inline static word TYPENAME() {return tName; } \
+	word typeName() const {return TYPENAME();} 
+
+
+#define TypeInfoTemplate11(tName, Type)										\
+	inline static word TYPENAME()											\
+	{ 																		\
+		return word(tName)+"<"+getTypeName<Type>()+">";						\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}
+
+#define TypeInfoTemplate12(tName, Type1, Type2)								\
+	inline static word TYPENAME()											\
+	{ 																		\
+		return word(tName)+"<"+getTypeName<Type1>()+","+getTypeName<Type2>()+">";	\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}
+
+#define TypeInfoTemplate13(tName, Type1, Type2, Type3)						\
+	inline static word TYPENAME()											\
+	{ 																		\
+		return word(tName)+"<"+getTypeName<Type1>()+","+getTypeName<Type2>()+","+getTypeName<Type3>()+">";\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}
+
+// this is the non-virtual version
+#define TypeInfoTemplateNV11(tName, Type)									\
+	inline static word TYPENAME()											\
+	{ 																		\
+		return word(tName)+"<"+getTypeName<Type>()+">"; 					\
+	}																		\
+	inline word typeName() const { return TYPENAME();}
+
+
+#define TypeInfoTemplateNV111(tName, Type, tName2)							\
+	inline static word TYPENAME()											\
+	{ 																		\
+		return word(tName)+"<"+getTypeName<Type>()+","+word(tName2)+">";	\
+	}																		\
+	inline word typeName() const { return TYPENAME();}
+
+#define TypeInfoTemplate111(tName, Type, tName2)							\
+	inline static word TYPENAME()											\
+	{ 																		\
+		return word(tName)+"<"+getTypeName<Type>()+","+word(tName2)+">"; 	\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}
+
+
+/*#define TypeInfoTemplate11(tName, Type)										\
+	has_static_member(TYPENAME);											\
+	inline static word TYPENAME()											\
+	{ 																		\
+	if constexpr( has_static_member_TYPENAME<Type,word(void)>::value) 		\
+		{ return word(tName)+"<"+Type::TYPENAME()+">";} 						\
+	else																	\
+		return word(tName)+"<"+basicTypeName<Type>()+">";						\
+	return "noTYPE"; 														\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}
+
+#define TypeInfoTemplate12(tName, Type1, Type2)								\
+	has_static_member(TYPENAME);											\
+	inline static word TYPENAME()											\
+	{ 																		\
+	if constexpr( has_static_member_TYPENAME<Type1,word(void)>::value) 		\
+		{ return word(tName)+"<"+Type1::TYPENAME()+","+Type2::TYPENAME()+">";}	\
+	else																	\
+		return word(tName)+"<"+basicTypeName<Type1>()+","+Type2::TYPENAME()+">";\
+	return "noTYPE"; 														\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}
+
+#define TypeInfoTemplate13(tName, Type1, Type2, Type3)						\
+	inline static word TYPENAME()											\
+	{ 																		\
+		return word(tName)+"<"+Type1::TYPENAME()+","+Type2::TYPENAME()+","+Type3::TYPENAME()+">";\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}
+
+// this is the non-virtual version
+#define TypeInfoTemplateNV11(tName, Type)										\
+	has_static_member(TYPENAME);											\
+	inline static word TYPENAME()											\
+	{ 																		\
+	if constexpr( has_static_member_TYPENAME<Type,word(void)>::value) 		\
+		{ return word(tName)+"<"+Type::TYPENAME()+">";} 					\
+	else																	\
+		return word(tName)+"<"+basicTypeName<Type>()+">";					\
+	return "noTYPE"; 														\
+	}																		\
+	inline word typeName() const { return TYPENAME();}
+
+
+#define TypeInfoTemplateNV111(tName, Type, tName2)							\
+	has_static_member(TYPENAME);											\
+	inline static word TYPENAME()											\
+	{ 																		\
+	if constexpr ( has_static_member_TYPENAME<Type,word(void)>::value) 		\
+		{ return word(tName)+"<"+Type::TYPENAME()+","+word(tName2)+">";} 	\
+	else																	\
+		return word(tName)+"<"+basicTypeName<Type>()+","+word(tName2)+">";	\
+	return "noTYPE"; 														\
+	}																		\
+	inline word typeName() const { return TYPENAME();}
+
+#define TypeInfoTemplate111(tName, Type, tName2)							\
+	has_static_member(TYPENAME);											\
+	inline static word TYPENAME()											\
+	{ 																		\
+	if constexpr ( has_static_member_TYPENAME<Type,word(void)>::value) 		\
+		{ return word(tName)+"<"+Type::TYPENAME()+","+word(tName2)+">";} 	\
+	else																	\
+		return word(tName)+"<"+basicTypeName<Type>()+","+word(tName2)+">";	\
+	return "noTYPE"; 														\
+	}																		\
+	virtual word typeName() const { return TYPENAME();}*/
+
+
+
+
+
+
+namespace pFlow
+{
+
+	
 
 
 
diff --git a/src/phasicFlow/typeSelection/virtualConstructor.hpp b/src/phasicFlow/typeSelection/virtualConstructor.hpp
index 573f7d31..0d7f64ff 100644
--- a/src/phasicFlow/typeSelection/virtualConstructor.hpp
+++ b/src/phasicFlow/typeSelection/virtualConstructor.hpp
@@ -75,7 +75,7 @@ public: 																				\
 
 #define add_vCtor(baseClass, derivedClass, selectorName) 	\
 															\
-inline static baseClass::create##selectorName##Callback<derivedClass> baseClass##derivedClass##selectorName##_;
+inline static typename baseClass::template create##selectorName##Callback<derivedClass> baseClass##derivedClass##selectorName##_;
 
 
 
diff --git a/src/phasicFlow/types/basicTypes/Logical.hpp b/src/phasicFlow/types/basicTypes/Logical.hpp
index 69770936..35183963 100755
--- a/src/phasicFlow/types/basicTypes/Logical.hpp
+++ b/src/phasicFlow/types/basicTypes/Logical.hpp
@@ -17,7 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
 #ifndef __Logical_hpp__
 #define __Logical_hpp__
 
@@ -25,22 +24,32 @@ Licence:
 #include "bTypesFunctions.hpp"
 #include "typeInfo.hpp"
 
+
 namespace pFlow
 {
 
+//- Forward 
 class iIstream;
 class iOstream;
 
-// allias for bool
+/**
+ *  Holds a bool value and converts strings to bool 
+ * 
+ */
 class Logical
 {
 protected:
+
+	/// bool value 
 	bool s_ = false;
 
+	/// Set numbe of of Yes or No
 	int  yesNoSet_ = 0;
 
+	/// Set of Yes or Nos
 	inline static const word YesNo__[4][2] = {{"Yes", "No"},{"on","off"},{"true","false"}, {"Ok","No"}};
 
+	/// Construct from bool and set number 
 	inline explicit Logical(bool s, int yns)
 	:	
 		s_(s),
@@ -49,58 +58,75 @@ protected:
 
 public:
 
+	/// Type info
 	TypeInfoNV("Logical");
 	
+	//// Constructors 
 
-	inline Logical(){}
+		/// Default constructor 
+		inline Logical(){}
+			
+		/// Construct from bool 
+		inline explicit Logical(bool s)
+		:
+		 	s_(s)
+		{}
+
+		/// Construct from word 
+		Logical(const word& l);
 		
+		/// Construct from char string 
+		Logical(const char* ch);
 
-	inline explicit Logical(bool s)
-	:
-	 	s_(s),
-	 	yesNoSet_(0)
-	{}
+		/// Copy 
+		Logical(const Logical&) = default;
 
-	Logical(const word& l);
+		/// Move 
+		Logical(Logical&&) = default;
+
+		/// Copy assignment 
+		Logical& operator=(const Logical&) = default;
+
+		/// Move assignment 
+		Logical& operator=(Logical&&) = default;
+
+		/// Assignment with bool
+		inline Logical& operator=(const bool& b)
+		{ 
+			s_ = b;
+			yesNoSet_ = 0;
+			return *this;
+		}
 	
-	Logical(const char* ch);
-
-	Logical(const Logical&) = default;
-
-	Logical(Logical&&) = default;
-
-	Logical& operator=(const Logical&) = default;
-
-	Logical& operator=(Logical&&) = default;
-
-	inline Logical& operator=(const bool& b)
-	{ 
-		s_ = b;
-		yesNoSet_ = 0;
-		return *this;
-	}
+	//// Methods 
 	
-	inline bool operator()() const
-	{
-		return s_;
-	}
-	
-	inline explicit operator bool() const
-	{
-		return s_;
-	}
+		/// () operator, return bool value 
+		inline bool operator()() const
+		{
+			return s_;
+		}
+		
+		/// Return bool value 
+		inline explicit operator bool() const
+		{
+			return s_;
+		}
 
-	inline Logical operator!()const
-	{
-		return Logical(!s_, yesNoSet_);
-	}
+		/// Not operator 
+		inline Logical operator!()const
+		{
+			return Logical(!s_, yesNoSet_);
+		}
 
 	//// IO operations
-	bool read(iIstream& is);
+	
+		bool read(iIstream& is);
 
-	bool write(iOstream& os)const; 
+		bool write(iOstream& os)const; 
 
-	bool static evaluteWord(const word& l, bool& b, int& yesNoSet );
+	//// Static members 
+
+		bool static evaluteWord(const word& l, bool& b, int& yesNoSet );
 	
 
 };
diff --git a/src/phasicFlow/types/basicTypes/bTypesFunctions.cpp b/src/phasicFlow/types/basicTypes/bTypesFunctions.cpp
index 50dcafb3..6db66184 100755
--- a/src/phasicFlow/types/basicTypes/bTypesFunctions.cpp
+++ b/src/phasicFlow/types/basicTypes/bTypesFunctions.cpp
@@ -41,6 +41,36 @@ pFlow::int32 pFlow::countChar( const char* s, const char c)
     );
 }
 
+pFlow::word pFlow::toUpper(const word & inStr)
+{
+    word oStr(inStr);
+    std::transform(inStr.begin(), inStr.end(), oStr.begin(), ::toupper);
+    return oStr;
+}
+
+pFlow::word pFlow::firstCapital(const word& inStr)
+{
+    word oStr(inStr);
+    oStr[0] = std::toupper(oStr[0]);
+    return oStr;
+}
+
+bool pFlow::isYes(const word & str)
+{
+    word s = toUpper(str);
+
+    if( s == "YES" || s=="Y" || s == "OK" || s == "TRUE" || s == "ON" || s=="T") return true;
+    return false;
+}
+
+bool pFlow::isNo(const word & str)
+{
+    word s = toUpper(str);
+
+    if( s == "NO" || s == "N" || "FALSE" || s == "OFF" || s == "F") return true;
+    return false;
+}
+
 pFlow::word pFlow::real2Fixed(const real & v, int32 numPrecision)
 {
     std::stringstream ss;
@@ -104,29 +134,6 @@ pFlow::word pFlow::real2FixedStripZeros(const real & v, int32 numPrecision)
     return removeDecimalZeros(strVal);
 }
 
-pFlow::word pFlow::toUpper(const word & inStr)
-{
-    word oStr(inStr);
-    transform(inStr.begin(), inStr.end(), oStr.begin(), ::toupper);
-    return oStr;
-}
-
-bool pFlow::isYes(const word & str)
-{
-    word s = toUpper(str);
-
-    if( s == "YES" || s == "OK" || s == "TRUE" || s == "ON" || s=="T") return true;
-    return false;
-}
-
-bool pFlow::isNo(const word & str)
-{
-    word s = toUpper(str);
-
-    if( s == "NO" || s == "N" || "FALSE" || s == "OFF" || s == "F") return true;
-    return false;
-}
-
 
 pFlow::word pFlow::angleBracketsNames(const word& w1, const word& w2)
 {
@@ -222,25 +229,6 @@ bool pFlow::validWordWithQuote(const word& w)
     return true;
 }
 
-
-bool pFlow::readLabel( const word& w, label & val)
-{
-    try{
-        val = std::stoull(w);
-    }
-    catch (...)
-    {
-        return false;
-    }
-    return true;
-}
-
-bool pFlow::readLabel( const char* buf, label & val)
-{
-    word w(buf);
-    return readLabel(w, val);
-}
-
 bool pFlow::readUint32( const word& w, uint32 & val)
 {
     try{
@@ -295,35 +283,16 @@ bool pFlow::readInt32( const char* buf, int32 & val)
     return readInt32(w, val);
 }
 
-
-bool pFlow::readInt16( const word& w, int16 & val)
-{
-    try{
-        val = static_cast<int16>(std::stoi(w));
-    }
-    catch (...)
-    {
-        return false;
-    }
-    return true;
-}
-
-bool pFlow::readInt16( const char* buf, int16 & val)
-{
-    word w(buf);
-    return readInt16(w, val);
-}
-
 bool pFlow::readInt8( const word& w, int8 & val)
 {
     try{
-        val = static_cast<int8>(std::stoi(w));
+        val = std::stoi(w);
     }
     catch (...)
     {
         return false;
     }
-    return true;
+    return true;   
 }
 
 bool pFlow::readInt8( const char* buf, int8 & val)
@@ -331,7 +300,8 @@ bool pFlow::readInt8( const char* buf, int8 & val)
     word w(buf);
     return readInt8(w, val);
 }
-#include <iostream>
+
+//#include <iostream>
 bool pFlow::readReal( const word& w, real & val)
 {
     try{
@@ -364,7 +334,6 @@ bool pFlow::readReal( const char* buf, real & val )
         return false;
     }
     
-    
     return true;
 }
 
diff --git a/src/phasicFlow/types/basicTypes/bTypesFunctions.hpp b/src/phasicFlow/types/basicTypes/bTypesFunctions.hpp
index de3e746e..8c9ce820 100755
--- a/src/phasicFlow/types/basicTypes/bTypesFunctions.hpp
+++ b/src/phasicFlow/types/basicTypes/bTypesFunctions.hpp
@@ -17,6 +17,10 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
+/*! \file bTypeFunctions.hpp
+   
+    \brief Helper functions for built-in types.  
+ */ 
 
 #ifndef __bTypesFunctions_hpp__
 #define __bTypesFunctions_hpp__
@@ -27,127 +31,134 @@ Licence:
 #include "math.hpp"
 
 
-// helper functions and constants for basic types 
+
 namespace pFlow
 {
 
-
+/// Zero real variable 
 inline const real  zero = 0.0;
+
+/// one real variable 
 inline const real  one  = 1.0;
 
+/// zero int32 variable 
 inline const int32  zero32 = 0;
+
+/// one int32 variable 
 inline const int32  one32  = 1;
 
+/// null/empty word 
 inline const word nullWord;
 
+/// white space 
 inline const word whiteSpace(" \t\n\v\f\r");
 
-
+/// Count numer of chars c in a word
 int32 countChar (const word& s, const char c);
 
+/// Count numer of chars c in a char string
 int32 countChar(const char* s, const char c);
 
+/// convert a word to all caps
 word toUpper(const word & inStr);
 
+word firstCapital(const word& inStr);
+
+/// Check if str equals "Yes", "Y", "True", "Ok", "ON", or "T"
 bool isYes(const word & str);
 
+/// Check if str equals "No", "N", "False", or "Off"
 bool isNo(const word & str);
 
+/// Convert floating point variable to string with fixed number of precisions 
 word real2Fixed(const real & v, int32 numPrecision = 6);
 
+/// Convert floating point variable to string with general format  
 word real2Word(const real & v, int32 numPrecision = 6);
 
-word removeDecimalZeros(const word& str);
-
-word real2FixedStripZeros(const real & v, int32 numPrecision = 6);
-
+/// Convert int32 to word 
 word int322Word(const int32 & v);
 
+/// Remove zeros from decimal part of a string number 
+word removeDecimalZeros(const word& str);
+
+/// Convert to fixed point variable and remove zeros 
+word real2FixedStripZeros(const real & v, int32 numPrecision = 6);
  
+/// Output <w1,w2> 
 word angleBracketsNames(const word& w1, const word& w2);
 
- 
+/// Output base<w1,w2>
 word angleBracketsNames2(const word& base, const word& w1, const word& w2);
 
+/// Output base<w1,sw2,w3>
 word angleBracketsNames3(const word& base, const word& w1, const word& w2, const word& w3);
 
+/// Group words and output bw.tw
 word groupNames(const word& bw, const word& tw, char sep = '.');
 
+/// Find the base in a group separated by "." and return it. 
 word baseName(const word& w, char sep = '.');
 
+/// Find tail name in a group separated by "." and return it. 
 word tailName(const word& w, char sep = '.');
 
-
-// is the character valid for a word name  
+/// Is the character valid for a word name?
 bool validWord(char c);
 
+/// Is c a valid character including quote?
 bool validWordWithQuote(char c);
 
-
+/// Is a valid word?
 bool validWord(const word& w);
 
+/// Is a valid word with qoute?
 bool validWordWithQuote(const word& c);
 
-
-bool readLabel( const word& w, label & val);
-
-
-bool readLabel( const char* buf, label & val);
-
-
+/// Convert word to uint32
 bool readUint32( const word& w, uint32 & val);
 
-
+/// Convert char string to uint32
 bool readUint32( const char* buf, uint32 & val);
 
-
+/// Convert word to int64
 bool readInt64( const word& w, int64 & val);
 
-
+/// Convert char string to int64
 bool readInt64( const char* buf, int64 & val);
 
-
+/// Convert word to int32
 bool readInt32( const word& w, int32 & val);
 
-
+/// Convert char string to int32
 bool readInt32( const char* buf, int32 & val);
 
 
-bool readInt16( const word& w, int16 & val);
-
-
-bool readInt16( const char* buf, int16 & val);
-
-
+/// Convert word to int8
 bool readInt8( const word& w, int8 & val);
 
-
+/// Convert char string to int8
 bool readInt8( const char* buf, int8 & val);
 
-
+/// Convert word to real 
 bool readReal( const word& w, real & val);
 
-
+/// Convert char string to real 
 bool readReal( const char* buf, real & val );
 
-
+/// Convert word to bool
 bool readBoolian_Str( const word& w, bool & val);
 
-
+/// Convert char string to bool 
 bool readBoolian_Str( const char* buf, bool & val);
 
+
 inline
 bool readValue(const word& w, real& val)
 {
     return readReal(w,val);
 }
 
-inline
-bool readValue(const word& w, label& val)
-{
-    return readLabel(w,val);
-}
-
 inline
 bool readValue(const word& w, uint32& val)
 {
@@ -166,11 +177,6 @@ bool readValue(const word& w, int32& val)
     return readInt32(w,val);
 }
 
-inline
-bool readValue(const word& w, int16& val)
-{
-    return readInt16(w,val);
-}
 
 inline
 bool readValue(const word& w, int8& val)
@@ -185,53 +191,53 @@ bool readValue(const word& w, bool& val)
 }
 
 
-INLINE_FUNCTION_HD bool equal(const real& s1, const real& s2)
+INLINE_FUNCTION_HD 
+bool equal(const real& s1, const real& s2, real tol = smallValue)
 {
-    return abs(s1 - s2) <= smallValue;
+    return abs(s1 - s2) <= tol;
 }
 
-INLINE_FUNCTION_HD bool equal(const int64& s1, const int64& s2)
+INLINE_FUNCTION_HD 
+bool equal(const int64& s1, const int64& s2)
 {
     return s1 == s2;
 }
 
-INLINE_FUNCTION_HD bool equal(const int32& s1, const int32& s2)
+INLINE_FUNCTION_HD 
+bool equal(const int32& s1, const int32& s2)
 {
 	return s1 == s2;
 }
 
-INLINE_FUNCTION_HD bool equal(const int16& s1, const int16& s2)
+INLINE_FUNCTION_HD 
+bool equal(const int8& s1, const int8& s2)
 {
     return s1 == s2;
 }
 
-INLINE_FUNCTION_HD bool equal(const int8& s1, const int8& s2)
+INLINE_FUNCTION_HD 
+bool equal(const uint32& s1, const uint32& s2)
 {
     return s1 == s2;
 }
 
-INLINE_FUNCTION_HD bool equal(const uint32& s1, const uint32& s2)
-{
-    return s1 == s2;
-}
-
-INLINE_FUNCTION_HD bool equal(const label& s1, const label& s2)
-{
-    return s1 == s2;
-}
-
-// host only
-INLINE_FUNCTION bool equal(const word& s1, const word& s2)
+/// Are two words equal (host only)?
+INLINE_FUNCTION 
+bool equal(const word& s1, const word& s2)
 {
 	return s1==s2;
 }
 
-INLINE_FUNCTION_HD real degree2Radian(const real &theta)
+/// Convert degree to radians
+INLINE_FUNCTION_HD 
+real degree2Radian(const real &theta)
 {
     return theta / 180.0 * Pi;
 }
 
-INLINE_FUNCTION_HD real radian2Degree(const real &phi)
+/// Convert radians to degree
+INLINE_FUNCTION_HD 
+real radian2Degree(const real &phi)
 {
     return phi / Pi * 180.0;
 }
diff --git a/src/phasicFlow/types/basicTypes/builtinTypes.hpp b/src/phasicFlow/types/basicTypes/builtinTypes.hpp
index 52adf430..d87a0a73 100755
--- a/src/phasicFlow/types/basicTypes/builtinTypes.hpp
+++ b/src/phasicFlow/types/basicTypes/builtinTypes.hpp
@@ -48,22 +48,26 @@ inline const bool usingDouble__ = false;
 
 using int8    = signed char;
 
-using int16   = short int;
-
 using int32   = int;
 
 using int64   = long long int;
 
-using uint16  = unsigned short int  ;
+using uint8  = unsigned char  ;
 
 using uint32  = unsigned int;
 
-using label   = std::size_t;
+using uint64  = unsigned long long int;
+
+using id_t    = uint32;
+
+using size_t  = std::size_t;
 
 using word    = std::string;
 
+inline const int  numBytesForReal__ = sizeof(real);
+
 inline 
-auto floatingPointDescription()
+word floatingPointDescription()
 {
   return word("In this build, ") + word(floatingPointType__) +
          word(" is used for floating point operations.");
diff --git a/src/phasicFlow/types/basicTypes/math.hpp b/src/phasicFlow/types/basicTypes/math.hpp
index 6c2b0f64..29482eae 100755
--- a/src/phasicFlow/types/basicTypes/math.hpp
+++ b/src/phasicFlow/types/basicTypes/math.hpp
@@ -21,14 +21,18 @@ Licence:
 #ifndef __math_hpp__
 #define __math_hpp__
 
-#include <cmath>
 
 #ifdef __CUDACC__
 #include "math.h"
+#else
+#include <cmath>
 #endif
 
+#include "pFlowMacros.hpp"
 #include "builtinTypes.hpp"
 
+
+
 //* * * * * * * * * * *  List of functinos * * * * * * * * //
 // abs, mod, exp, log, log10, pow, sqrt, cbrt
 // sin, cos, tan, asin, acos, atan, atan2
@@ -40,7 +44,8 @@ namespace pFlow
 {
 
 
-INLINE_FUNCTION_HD real abs(real x)
+INLINE_FUNCTION_HD 
+real abs(real x)
 {
 #ifdef __CUDACC__
 	return ::fabs(x);
@@ -49,24 +54,20 @@ INLINE_FUNCTION_HD real abs(real x)
 #endif
 }
 
-
-INLINE_FUNCTION_HD int64 abs(int64 x)
-{
-#ifdef __CUDACC__
-	return ::abs(x);
-#else
-	return std::abs(x);
+#ifndef __CUDACC__
+	INLINE_FUNCTION_HD 
+	int64 abs(int64 x)
+	{
+		return std::abs(x);
+	}
 #endif
-}
 
+#ifndef __CUDACC__
 INLINE_FUNCTION_HD int32 abs(int32 x)
 {
-#ifdef __CUDACC__
-	return ::abs(x);
-#else
 	return std::abs(x);
-#endif
 }
+#endif
 
 
 INLINE_FUNCTION_HD real mod(real x, real y)
@@ -88,173 +89,142 @@ INLINE_FUNCTION_HD int32 mod(int32 x, int32 y)
 	return x%y;
 }
 
-INLINE_FUNCTION_HD int64 mod(label x, label y)
+INLINE_FUNCTION_HD int64 mod(uint64 x, uint64 y)
 {
 	return x%y;
 }
 
-INLINE_FUNCTION_HD int32 mod(uint32 x, uint32 y)
+INLINE_FUNCTION_HD auto mod(uint32 x, uint32 y)
 {
 	return x%y;
 }
 
+#ifndef __CUDACC__
 INLINE_FUNCTION_HD real remainder(real x, real y)
 {
-#ifdef __CUDACC__
-	return ::remainder(x,y);
-#else
 	return std::remainder(x,y);
-#endif
 }
+#endif
 
-INLINE_FUNCTION_HD real exp(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_H 
+real exp(real x)
 {
-#ifdef __CUDACC__
-	return ::exp(x);
-#else
 	return std::exp(x);
-#endif
 }
+#endif
 
-INLINE_FUNCTION_HD real log(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real log(real x)
 {
-#ifdef __CUDACC__
-	return ::log(x);
-#else
 	return std::log(x);
-#endif
 }
+#endif
 
-INLINE_FUNCTION_HD real log10(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real log10(real x)
 {
-#ifdef __CUDACC__
-	return ::log10(x);
-#else
 	return std::log10(x);
-#endif
 }
+#endif
 
-INLINE_FUNCTION_HD real pow(real x, real y)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real pow(real x, real y)
 {
-#ifdef __CUDACC__
-	return ::pow(x, y);
-#else
 	return std::pow(x, y);
+}
 #endif
 
-}
-
-
-INLINE_FUNCTION_HD real sqrt(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real sqrt(real x)
 {
-#ifdef __CUDACC__
-	return ::sqrt(x);
-#else
 	return std::sqrt(x);
-#endif
 }
+#endif
 
-
-INLINE_FUNCTION_HD real cbrt (real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real cbrt (real x)
 {
-#ifdef __CUDACC__
-	return ::cbrt (x);
-#else
 	return std::cbrt (x);
-#endif
 }
+#endif
 
-
-INLINE_FUNCTION_HD real sin(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real sin(real x)
 {
-#ifdef __CUDACC__
-	return ::sin(x);
-#else
 	return std::sin(x);
-#endif
 }
+#endif
 
-
-INLINE_FUNCTION_HD real cos(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real cos(real x)
 {
-#ifdef __CUDACC__
-	return ::cos(x);
-#else
 	return std::cos(x);
-#endif
 }
+#endif
 
-
-INLINE_FUNCTION_HD real tan(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real tan(real x)
 {
-#ifdef __CUDACC__
-	return ::tan(x);
-#else
 	return std::tan(x);
-#endif
 }
+#endif
 
-INLINE_FUNCTION_HD real asin(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real asin(real x)
 {
-#ifdef __CUDACC__
-	return ::asin(x);
-#else
 	return std::asin(x);
-#endif
-	
 }
+#endif
 
-
-INLINE_FUNCTION_HD real acos(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real acos(real x)
 {
-#ifdef __CUDACC__
-	return ::acos(x);
-#else
 	return std::acos(x);
-#endif
 }
+#endif
 
-
-INLINE_FUNCTION_HD real atan(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real atan(real x)
 {
-#ifdef __CUDACC__
-	return ::atan(x);
-#else
 	return std::atan(x);
+}
 #endif
 
-}
-
-
-INLINE_FUNCTION_HD real atan2(real y, real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD real 
+atan2(real y, real x)
 {
-#ifdef __CUDACC__
-	return ::atan2(y, x);
-#else
 	return std::atan2(y, x);
-#endif
 }
+#endif
 
-
-INLINE_FUNCTION_HD real sinh(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real sinh(real x)
 {
-#ifdef __CUDACC__
-	return ::sinh(x);
-#else
 	return std::sinh(x);
-#endif
 }
+#endif
 
-
-INLINE_FUNCTION_HD real cosh(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real cosh(real x)
 {
-#ifdef __CUDACC__
-	return ::cosh(x);
-#else
 	return std::cosh(x);
-#endif
 }
-
+#endif
 
 INLINE_FUNCTION_HD real tanh(real x)
 {
@@ -283,14 +253,14 @@ INLINE_FUNCTION_HD real acosh(real x)
 #endif
 }
 
-INLINE_FUNCTION_HD real atanh(real x)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+real atanh(real x)
 {
-#ifdef __CUDACC__
-	return ::atanh(x);
-#else
 	return std::atanh(x);
-#endif
 }
+#endif
+
 
 INLINE_FUNCTION_HD real min(real x, real y)
 {
@@ -301,51 +271,37 @@ INLINE_FUNCTION_HD real min(real x, real y)
 #endif
 }
 
-INLINE_FUNCTION_HD int64 min(int32 x, int32 y)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+int64 min(int32 x, int32 y)
 {
-#ifdef __CUDACC__
-	return ::min(x, y);
-#else
 	return std::min(x, y);
-#endif
 }
-
-INLINE_FUNCTION_HD int64 min(int64 x, int64 y)
-{
-#ifdef __CUDACC__
-	return ::min(x, y);
-#else
-	return std::min(x, y);
-#endif
-}
-
-INLINE_FUNCTION_HD label min(label x, label y)
-{
-#ifdef __CUDACC__
-	return ::min(x, y);
-#else
-	return std::min(x, y);
 #endif
 
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+int64 min(int64 x, int64 y)
+{
+	return std::min(x, y);
 }
+#endif
 
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD 
+uint64 min(uint64 x, uint64 y)
+{
+	return std::min(x, y);
+}
+#endif
+
+#ifndef __CUDACC__
 INLINE_FUNCTION_HD uint32 min(uint32 x, uint32 y)
 {
-#ifdef __CUDACC__
-	return ::min(x, y);
-#else
 	return std::min(x, y);
-#endif
 }
+#endif
 
-INLINE_FUNCTION_HD uint32 min(uint16 x, uint16 y)
-{
-#ifdef __CUDACC__
-	return ::min(x, y);
-#else
-	return std::min(x, y);
-#endif
-}
 
 INLINE_FUNCTION_HD real max(real x, real y)
 {
@@ -356,52 +312,35 @@ INLINE_FUNCTION_HD real max(real x, real y)
 #endif
 }
 
+
+#ifndef __CUDACC__
 INLINE_FUNCTION_HD int64 max(int64 x, int64 y)
 {
-#ifdef __CUDACC__
-	return ::max(x, y);
-#else
 	return std::max(x, y);
-#endif
 }
+#endif
 
+#ifndef __CUDACC__
 INLINE_FUNCTION_HD int32 max(int32 x, int32 y)
 {
-#ifdef __CUDACC__
-	return ::max(x, y);
-#else
 	return std::max(x, y);
-#endif
 }
+#endif
 
-INLINE_FUNCTION_HD label max(label x, label y)
+#ifndef __CUDACC__
+INLINE_FUNCTION_HD uint64 max(uint64 x, uint64 y)
 {
-#ifdef __CUDACC__
-	return ::max(x, y);
-#else
 	return std::max(x, y);
-#endif
 }
+#endif
 
-
+#ifndef __CUDACC__
 INLINE_FUNCTION_HD uint32 max(uint32 x, uint32 y)
 {
-#ifdef __CUDACC__
-	return ::max(x, y);
-#else
 	return std::max(x, y);
-#endif
 }
-
-INLINE_FUNCTION_HD uint32 max(uint16 x, uint16 y)
-{
-#ifdef __CUDACC__
-	return ::max(x, y);
-#else
-	return std::max(x, y);
 #endif
 
-}
 
 } // pFlow
 
diff --git a/src/phasicFlow/types/triple/triple.hpp b/src/phasicFlow/types/triple/triple.hpp
index 50c6e83b..c11154a0 100644
--- a/src/phasicFlow/types/triple/triple.hpp
+++ b/src/phasicFlow/types/triple/triple.hpp
@@ -17,7 +17,6 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-
 #ifndef __triple_hpp__
 #define __triple_hpp__
 
@@ -33,201 +32,237 @@ Licence:
 namespace pFlow
 {
 
-
+/// - Forward
 template<typename T> class triple;
 
 
 #include "tripleFwd.hpp"
 
-
-// for 3D vectors
-// it should be used only for numeric types, real, unit 
+/**
+ * A set of 3 variables that can be used for vector variables.
+ * The template parameter should be numeric type only.
+ *  
+ */
 template <typename T>
 struct triple
 {
-	// data members
+	/// data members
 	T x_;
 	T y_;
 	T z_;
 
-	// initilizes to zero
-	INLINE_FUNCTION_HD triple():
-	x_(0),
-	y_(0),
-	z_(0)
-	{}
+	//// Constructors
 
-	// Constructors
-	INLINE_FUNCTION_HD triple(const T &x, const T &y, const T &z):
-	x_(x),
-	y_(y),
-	z_(z)
-	{}
+		/// Initilize to zero
+		INLINE_FUNCTION_HD 
+		triple():
+		x_(0),
+		y_(0),
+		z_(0)
+		{}
 
-	INLINE_FUNCTION_HD triple(const T &v):
-	triple(v, v, v)
-	{}
+		
+		/// Construct from x, y, z
+		INLINE_FUNCTION_HD 
+		triple(const T &x, const T &y, const T &z):
+		x_(x),
+		y_(y),
+		z_(z)
+		{}
 
-	// type conversion trough assignment  
-	template <typename T2>
-	INLINE_FUNCTION_HD triple<T> & operator = (const triple<T2> & rhs)
-	{
-		this->x_ = static_cast<T>(rhs.x_);
-		this->y_ = static_cast<T>(rhs.y_);
-		this->z_ = static_cast<T>(rhs.z_);
-		return *this;
-	}
+		/// Construct from v
+		INLINE_FUNCTION_HD 
+		triple(const T &v):
+		triple(v, v, v)
+		{}
 
-	// type casting through copy constructor 
-	template<typename T2>
-	INLINE_FUNCTION_HD triple(const triple<T2> &src):
-	x_(static_cast<T>(src.x_)),
-	y_(static_cast<T>(src.y_)),
-	z_(static_cast<T>(src.z_))
-	{
-	}
+		/// Type conversion trough assignment  
+		template <typename T2>
+		INLINE_FUNCTION_HD triple<T> & operator = (const triple<T2> & rhs)
+		{
+			this->x_ = static_cast<T>(rhs.x_);
+			this->y_ = static_cast<T>(rhs.y_);
+			this->z_ = static_cast<T>(rhs.z_);
+			return *this;
+		}
+
+		/// Type casting through copy constructor 
+		template<typename T2>
+		INLINE_FUNCTION_HD triple(const triple<T2> &src)
+		:
+			x_(static_cast<T>(src.x_)),
+			y_(static_cast<T>(src.y_)),
+			z_(static_cast<T>(src.z_))
+		{}
 	
-	// copy construct
-	INLINE_FUNCTION_HD
-	triple(const triple<T>& src) = default;
+		/// Copy construct
+		INLINE_FUNCTION_HD
+		triple(const triple<T>& src) = default;
 
-	// volatile copy construct
-	/*INLINE_FUNCTION_HD
-	triple(volatile triple<T>& src):
-		x_(src.x_),
-		y_(src.y_),
-		z_(src.z_)
-	{}*/
-
-	/*INLINE_FUNCTION_HD
-	triple& operator=(volatile triple<T>& src)	
-	{
-		x_ = src.x_;
-		y_ = src.y_;
-		z_ = src.z_;
-	}*/
-
-	// move construct
-	INLINE_FUNCTION_HD
-	triple(triple<T>&& src) = default;
-
-	// copy assignment
-	INLINE_FUNCTION_HD
-	triple<T>& operator=(const triple<T>& src) = default;
-
-	// move assignment
-	INLINE_FUNCTION_HD
-	triple<T>& operator=(triple<T>&& src) = default;
-
-	// clone 
-	INLINE_FUNCTION 
-	uniquePtr<triple<T>> clone() const
-	{
-		return makeUnique<triple<T>>(*this);
-	}
-
-	INLINE_FUNCTION
-	triple<T>* clonePtr()const
-	{
-		return new triple<T>(*this);
-	}
-
-	//// member methods
-
-	// access
-	INLINE_FUNCTION_HD T & x(){ return x_; }
-	INLINE_FUNCTION_HD const T & x()const { return x_; }
 	
-	INLINE_FUNCTION_HD T & y(){ return y_; }
-	INLINE_FUNCTION_HD const T & y()const { return y_; }
 
-	INLINE_FUNCTION_HD T & z(){ return z_; }
-	INLINE_FUNCTION_HD const T & z()const { return z_; }
+		/// Move construct
+		INLINE_FUNCTION_HD
+		triple(triple<T>&& src) = default;
 
-	// methods
-	friend FUNCTION_HD T dot <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
-	
-	friend FUNCTION_HD triple<T> cross <T>(const triple<T> & v1, const triple<T> & v2);
-	
-	INLINE_FUNCTION_HD T length() const; 
+		/// copy assignment
+		INLINE_FUNCTION_HD
+		triple<T>& operator=(const triple<T>& src) = default;
 
-	INLINE_FUNCTION_HD void normalize(); 
+		/// move assignment
+		INLINE_FUNCTION_HD
+		triple<T>& operator=(triple<T>&& src) = default;
 
+		/// clone 
+		INLINE_FUNCTION 
+		uniquePtr<triple<T>> clone() const
+		{
+			return makeUnique<triple<T>>(*this);
+		}
 
+		INLINE_FUNCTION
+		triple<T>* clonePtr()const
+		{
+			return new triple<T>(*this);
+		}
+
+	////// member methods
+
+		/// access component
+		INLINE_FUNCTION_HD T & x(){ return x_; }
+
+		/// access component
+		INLINE_FUNCTION_HD const T & x()const { return x_; }
+		
+		/// access component
+		INLINE_FUNCTION_HD T & y(){ return y_; }
+		
+		/// access component
+		INLINE_FUNCTION_HD const T & y()const { return y_; }
+
+		/// access component
+		INLINE_FUNCTION_HD T & z(){ return z_; }
+		
+		/// access component
+		INLINE_FUNCTION_HD const T & z()const { return z_; }
+
+        /// access component
+		INLINE_FUNCTION_HD T & comp1(){ return x_; }
+
+		/// access component
+		INLINE_FUNCTION_HD const T & comp1()const { return x_; }
+		
+		/// access component
+		INLINE_FUNCTION_HD T & comp2(){ return y_; }
+		
+		/// access component
+		INLINE_FUNCTION_HD const T & comp2()const { return y_; }
+
+		/// access component
+		INLINE_FUNCTION_HD T & comp3(){ return z_; }
+		
+		/// access component
+		INLINE_FUNCTION_HD const T & comp3()const { return z_; }
+
+	//// methods
+
+		/// Dot product of two vectors
+		friend FUNCTION_HD T dot <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
+		
+		/// Cross product of two vectors
+		friend FUNCTION_HD triple<T> cross <T>(const triple<T> & v1, const triple<T> & v2);
+		
+		/// Length of the vector 
+		INLINE_FUNCTION_HD T length() const; 
+
+		/// Normalize the vector 
+		INLINE_FUNCTION_HD void normalize(); 
 
 	//// operators 
 	
-	// + operator
-	friend FUNCTION_HD triple<T> operator+ <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
+		/// + operator
+		friend FUNCTION_HD triple<T> operator+ <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
 
-	friend FUNCTION_HD triple<T> operator+ <T> (const triple<T> & oprnd1, const T & oprnd2);
-	
-	friend FUNCTION_HD triple<T> operator+ <T> (const T & oprnd1, const triple<T> & oprnd2);	
-	
-	// - operator 
-	friend FUNCTION_HD triple<T> operator - <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
-	
-	friend FUNCTION_HD triple<T> operator - <T> (const triple<T> & oprnd1, const T & oprnd2);
-	
-	friend FUNCTION_HD triple<T> operator - <T> (const T & oprnd1, const triple<T> & oprnd2);
-	
-	// * operators
-	friend FUNCTION_HD triple<T> operator * <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
-	
-	friend FUNCTION_HD triple<T> operator * <T> (const triple<T> & oprnd1, const T & oprnd2);
-	
-	friend FUNCTION_HD triple<T> operator * <T> (const T & oprnd1, const triple<T> & oprnd2);
+		friend FUNCTION_HD triple<T> operator+ <T> (const triple<T> & oprnd1, const T & oprnd2);
+		
+		friend FUNCTION_HD triple<T> operator+ <T> (const T & oprnd1, const triple<T> & oprnd2);	
+		
+		/// - operator 
+		friend FUNCTION_HD triple<T> operator - <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
+		
+		friend FUNCTION_HD triple<T> operator - <T> (const triple<T> & oprnd1, const T & oprnd2);
+		
+		friend FUNCTION_HD triple<T> operator - <T> (const T & oprnd1, const triple<T> & oprnd2);
+		
+		/// * operators
+		friend FUNCTION_HD triple<T> operator * <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
+		
+		friend FUNCTION_HD triple<T> operator * <T> (const triple<T> & oprnd1, const T & oprnd2);
+		
+		friend FUNCTION_HD triple<T> operator * <T> (const T & oprnd1, const triple<T> & oprnd2);
 
-	// / operators
-	friend FUNCTION_HD triple<T> operator / <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
-	
-	friend FUNCTION_HD triple<T> operator / <T> (const triple<T> & oprnd1, const T & oprnd2);
-	
-	friend FUNCTION_HD triple<T> operator / <T> (const T & oprnd1, const triple<T> & oprnd2);
+		/// / operators
+		friend FUNCTION_HD triple<T> operator / <T> (const triple<T> & oprnd1, const triple<T> & oprnd2);
+		
+		friend FUNCTION_HD triple<T> operator / <T> (const triple<T> & oprnd1, const T & oprnd2);
+		
+		friend FUNCTION_HD triple<T> operator / <T> (const T & oprnd1, const triple<T> & oprnd2);
 
 
-	INLINE_FUNCTION_HD void operator+= (const triple & oprnd2);
+		INLINE_FUNCTION_HD void operator+= (const triple & oprnd2);
 
-	INLINE_FUNCTION_HD void operator-= (const triple & oprnd2);
+		INLINE_FUNCTION_HD void operator-= (const triple & oprnd2);
 
-	INLINE_FUNCTION_HD void operator*= (const triple & oprnd2);
+		INLINE_FUNCTION_HD void operator*= (const triple & oprnd2);
 
-	INLINE_FUNCTION_HD void operator/= (const triple & oprnd2);
+		INLINE_FUNCTION_HD void operator/= (const triple & oprnd2);
 	
 	
-	// unary negate operator 
-	INLINE_FUNCTION_HD triple operator- ()const;
-	
-	// unary plus operator 
-	INLINE_FUNCTION_HD triple operator+ ()const;
+		/// unary negate operator 
+		INLINE_FUNCTION_HD triple operator- ()const;
+		
+		/// unary plus operator 
+		INLINE_FUNCTION_HD triple operator+ ()const;
+		
+
+		friend FUNCTION_HD bool operator == <T> (const triple<T> &opr1, const triple<T> &opr2);
+
+		friend FUNCTION_HD bool operator < <T> (const triple<T> &opr1, const triple<T> &opr2);
+
+		friend FUNCTION_HD bool operator > <T> (const triple<T> &opr1, const triple<T> &opr2);
+
+		friend FUNCTION_HD bool operator >= <T> (const triple<T> &opr1, const triple<T> &opr2);
+
+		friend FUNCTION_HD bool operator <= <T> (const triple<T> &opr1, const triple<T> &opr2);
 	
+	//// IO operators
 
-	friend FUNCTION_HD bool operator == <T> (const triple<T> &opr1, const triple<T> &opr2);
+		/// << operator 	
+		friend iOstream& operator<< <T> (iOstream& str, const triple<T> & ov);
+		
+		/// >> operator 
+		friend iIstream& operator >> <T> (iIstream & str, triple<T> & iv);
 
-	friend FUNCTION_HD bool operator < <T> (const triple<T> &opr1, const triple<T> &opr2);
-
-	friend FUNCTION_HD bool operator > <T> (const triple<T> &opr1, const triple<T> &opr2);
-
-	friend FUNCTION_HD bool operator >= <T> (const triple<T> &opr1, const triple<T> &opr2);
-
-	friend FUNCTION_HD bool operator <= <T> (const triple<T> &opr1, const triple<T> &opr2);
-	
-	// << operator 	
-	friend iOstream& operator<< <T> (iOstream& str, const triple<T> & ov);
-	
-	// >> operator 
-	friend iIstream& operator >> <T> (iIstream & str, triple<T> & iv);
-
-	// same as >> operator, but faster, good for mass read
-	friend void readIstream <T>( iIstream& str, triple<T> &iv);
+		/// same as >> operator, but faster, good for mass read
+		friend void readIstream <T>( iIstream& str, triple<T> &iv);
 
 };
 
 template<typename T>
-bool INLINE_FUNCTION_HD equal( const triple<T>& opr1, const triple<T>& opr2 );
+bool INLINE_FUNCTION_HD equal( const triple<T>& opr1, const triple<T>& opr2);
 
 
-} // end of pFlow
+bool
+INLINE_FUNCTION_HD
+equal(const triple<real>& opr1, const triple<real>& opr2, real tol)
+{
+	return 	equal( opr1.x(), opr2.x(), tol ) && 
+			equal( opr1.y(), opr2.y(), tol ) && 
+			equal( opr1.z(), opr2.z(), tol );
+}
+
+
+} /// end of pFlow
 
 #include "tripleI.hpp"
 #include "tripleMath.hpp"
diff --git a/src/phasicFlow/types/triple/tripleMath.hpp b/src/phasicFlow/types/triple/tripleMath.hpp
index 00566ed3..dc016739 100644
--- a/src/phasicFlow/types/triple/tripleMath.hpp
+++ b/src/phasicFlow/types/triple/tripleMath.hpp
@@ -18,18 +18,22 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
+namespace pFlow
+
+{
+
 #define T3Func(fnName) 									\
 template<typename T> 									\
-INLINE_FUNCTION_HD pFlow::triple<T> pFlow::fnName(const pFlow::triple<T>& v) 			\
+INLINE_FUNCTION_HD triple<T> fnName(const triple<T>& v) 			\
 {																\
-	return pFlow::triple<T>(fnName(v.x_), fnName(v.y_), fnName(v.z_));	\
+	return triple<T>(fnName(v.x_), fnName(v.y_), fnName(v.z_));	\
 }
 
 #define T3Func2(fnName)  															\
 template<typename T>																\
-INLINE_FUNCTION_HD pFlow::triple<T> pFlow::fnName(const pFlow::triple<T>& arg1, const pFlow::triple<T>& arg2)	\
+INLINE_FUNCTION_HD triple<T> fnName(const triple<T>& arg1, const triple<T>& arg2)	\
 {																					\
-	return pFlow::triple<T>(fnName(arg1.x_, arg2.x_), fnName(arg1.y_,arg2.y_), fnName(arg1.z_, arg2.z_)); \
+	return triple<T>(fnName(arg1.x_, arg2.x_), fnName(arg1.y_,arg2.y_), fnName(arg1.z_, arg2.z_)); \
 }
 
 //* * * * * * * * * * *  List of functinos * * * * * * * * //
@@ -68,21 +72,21 @@ T3Func2(max);
 
 // elements of t3 raised by e
 template<typename T>
-INLINE_FUNCTION_HD pFlow::triple<T> pFlow::pow(const pFlow::triple<T>& t3, T e)
+INLINE_FUNCTION_HD triple<T> pow(const triple<T>& t3, T e)
 {
-	return pFlow::triple<T>( pow(t3.x_, e), pow(t3.y_,e), pow(t3.z_,e));
+	return triple<T>( pow(t3.x_, e), pow(t3.y_,e), pow(t3.z_,e));
 }
 
 // return the min of 3 elements x, y, z
 template<typename T>
-INLINE_FUNCTION_HD T pFlow::min(const pFlow::triple<T>& t3)
+INLINE_FUNCTION_HD T min(const triple<T>& t3)
 {
 	return min( min(t3.x_, t3.y_), t3.z_);
 }
 
 // return the max of 3 elements x, y, z
 template<typename T>
-INLINE_FUNCTION_HD T pFlow::max(const pFlow::triple<T>& t3)
+INLINE_FUNCTION_HD T max(const triple<T>& t3)
 {
 	return max( max(t3.x_, t3.y_), t3.z_);
 }
@@ -90,4 +94,6 @@ INLINE_FUNCTION_HD T pFlow::max(const pFlow::triple<T>& t3)
 
 
 #undef T3Func
-#undef T3Func2
\ No newline at end of file
+#undef T3Func2
+
+}
diff --git a/src/phasicFlow/types/types.cpp b/src/phasicFlow/types/types.cpp
index d5d77bbc..a9b58805 100644
--- a/src/phasicFlow/types/types.cpp
+++ b/src/phasicFlow/types/types.cpp
@@ -25,15 +25,11 @@ namespace pFlow
 		
 	const realx3 zero3(0.0);
 	const realx3 one3(1.0);
-	const uint32x3 zeroU3(0);
-	const uint32x3 oneU3(1);
-
+	
 	const realx3x3   zero33(zero3);
 	const realx3x3   one33(one3);
-	const uint32x3x3 zeroU33(zeroU3);
-	const uint32x3x3 oneU33(oneU3);
-
-	const real4 zero4(zero);
+	
+	const realx4 zero4(zero);
 	
 
 } // pFlow
\ No newline at end of file
diff --git a/src/phasicFlow/types/types.hpp b/src/phasicFlow/types/types.hpp
index e4523725..924e41cc 100644
--- a/src/phasicFlow/types/types.hpp
+++ b/src/phasicFlow/types/types.hpp
@@ -37,31 +37,25 @@ namespace pFlow
 {
 
 using int8x3 	= triple<int8>;
-using int16x3 	= triple<int16>;
 using int32x3 	= triple<int32>;
 using int64x3	= triple<int64>;
-using uint16x3 	= triple<uint16>;
+using uint8x3   = triple<uint8>;
 using uint32x3 	= triple<uint32>;
-using int32x3 	= triple<int32>;
-using int64x3 	= triple<int64>;
-using labelx3 	= triple<label>;
+using uint64x3 	= triple<uint64>;
 using realx3 	= triple<real>;
 
-using uint16x3x3= triple<uint16x3>;
-using uint32x3x3= triple<uint32x3>;
 using int32x3x3 = triple<int32x3>;
-using labelx3x3 = triple<labelx3>;
+using uint32x3x3= triple<uint32x3>;
 using realx3x3 	= triple<realx3>;
 
-using real4 	= quadruple<real>;
+using realx4 	= quadruple<real>;
+
+using realx4x3 = quadruple<realx3>;
 
 
 template<>
 inline word basicTypeName<int8x3>(){	return "int8x3"; }
 
-template<>
-inline word basicTypeName<int16x3>(){	return "int16x3"; }
-
 template<>
 inline word basicTypeName<int32x3>(){	return "int32x3"; }
 
@@ -69,19 +63,19 @@ template<>
 inline word basicTypeName<int64x3>(){	return "int64x3"; }
 
 template<>
-inline word basicTypeName<uint16x3>(){	return "uint16x3"; }
+inline word basicTypeName<uint8x3>(){	return "uint8x3"; }
 
 template<>
 inline word basicTypeName<uint32x3>(){	return "uint32x3"; }
 
 template<>
-inline word basicTypeName<labelx3>(){	return "labelx3"; }
+inline word basicTypeName<uint64x3>(){	return "unit64x3"; }
 
 template<>
 inline word basicTypeName<realx3>(){	return "realx3";	}
 
 template<>
-inline word basicTypeName<uint16x3x3>(){ return "uint16x3x3"; }
+inline word basicTypeName<int32x3x3>(){ return "int32x3x3"; }
 
 template<>
 inline word basicTypeName<uint32x3x3>(){ return "uint32x3x3"; }
@@ -91,20 +85,19 @@ inline word basicTypeName<realx3x3>(){ return "realx3x3"; }
 
 
 template<>
-inline word basicTypeName<real4>(){	return "real4";	}
+inline word basicTypeName<realx4>(){	return "realx4";	}
 
+template<>
+inline word basicTypeName<realx4x3>(){  return "realx4x3";  }
 
 extern const realx3 zero3;
 extern const realx3 one3;
-extern const uint32x3 zeroU3;
-extern const uint32x3 oneU3;
+
 
 extern const realx3x3 zero33;
 extern const realx3x3 one33;
-extern const uint32x3x3 zeroU33;
-extern const uint32x3x3 oneU33;
-
 
+extern const realx4 zero4; 
 
 } // pFlow
 
diff --git a/src/setHelpers/finalize.hpp b/src/setHelpers/finalize.hpp
index f98c8069..cd4b1990 100644
--- a/src/setHelpers/finalize.hpp
+++ b/src/setHelpers/finalize.hpp
@@ -23,7 +23,7 @@ Licence:
 
 // initilized and finalize should be placed in onc scope 
 }
-pFlow::output<< "\nFinalizing host/device execution space ...."<<pFlow::endl;
+REPORT(0)<< "\nFinalizing host/device execution space ...."<<END_REPORT;
 Kokkos::finalize();
 
 
diff --git a/src/setHelpers/initialize.hpp b/src/setHelpers/initialize.hpp
index 8ee05c99..2bdd041b 100644
--- a/src/setHelpers/initialize.hpp
+++ b/src/setHelpers/initialize.hpp
@@ -23,8 +23,8 @@ Licence:
 
 // initilized and finalize should be placed in onc scope 
 REPORT(0)<<"Initializing host/device execution spaces . . . \n";
-REPORT(1)<<"Host execution space is "<< greenText(pFlow::DefaultHostExecutionSpace::name())<<endREPORT;
-REPORT(1)<<"Device execution space is "<<greenText(pFlow::DefaultExecutionSpace::name())<<endREPORT;
+REPORT(1)<<"Host execution space is "<< Green_Text(pFlow::DefaultHostExecutionSpace::name())<<END_REPORT;
+REPORT(1)<<"Device execution space is "<<Green_Text(pFlow::DefaultExecutionSpace::name())<<END_REPORT;
 
 Kokkos::initialize( argc, argv );
 {
diff --git a/src/setHelpers/initialize_Control.hpp b/src/setHelpers/initialize_Control.hpp
index b488a6b7..dfaa5ce7 100644
--- a/src/setHelpers/initialize_Control.hpp
+++ b/src/setHelpers/initialize_Control.hpp
@@ -24,10 +24,10 @@ Licence:
 // initilized and finalize should be placed in onc scope 
 #include "initialize.hpp"
 
-REPORT(0)<<"\nCreating Control repository . . ."<<endREPORT;
+REPORT(0)<<"\nCreating Control repository . . ."<<END_REPORT;
 pFlow::uniquePtr<pFlow::systemControl> ControlPtr = nullptr;
 
-if(isCoupling)
+/*if(isCoupling)
 {
 	pFlow::readControlDict controlDict;
 	
@@ -36,13 +36,13 @@ if(isCoupling)
 		controlDict.startTime(),
 		controlDict.endTime(),
 		controlDict.saveInterval(),
-		controlDict.startTimeName()
+		controlDict.startTimeNreseame()
 	);	
-}
-else
-{
+}*/
+/*else
+{*/
   	ControlPtr = pFlow::makeUnique<pFlow::systemControl>();
-}
+//}
 
 auto& Control = ControlPtr();
 
diff --git a/src/setHelpers/setProperty.hpp b/src/setHelpers/setProperty.hpp
index 1d09d6aa..43ec5ef2 100644
--- a/src/setHelpers/setProperty.hpp
+++ b/src/setHelpers/setProperty.hpp
@@ -18,12 +18,11 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
 #ifndef __setProperty_hpp__
 #define __setProperty_hpp__
 
-REPORT(0)<<"\nReading proprties . . . "<<endREPORT;
+REPORT(0)<<"\nReading proprties . . . "<<END_REPORT;
 
-auto proprties = pFlow::property(Control.caseSetup().path()+pFlow::propertyFile__);
+auto proprties = property(propertyFile__, Control.caseSetup().path());
 
-#endif
+#endif // __setProperty_hpp__
diff --git a/src/setHelpers/setSurfaceGeometry.hpp b/src/setHelpers/setSurfaceGeometry.hpp
index db6a0143..67e0f123 100644
--- a/src/setHelpers/setSurfaceGeometry.hpp
+++ b/src/setHelpers/setSurfaceGeometry.hpp
@@ -21,7 +21,7 @@ Licence:
 #ifndef __setSurfaceGeometry_hpp__
 #define __setSurfaceGeometry_hpp__
 
-REPORT(0)<< "\nCreating surface geometry . . . "<<endREPORT;
+REPORT(0)<< "\nCreating surface geometry . . . "<<END_REPORT;
 auto surfGeometryPtr = pFlow::geometry::create(Control, proprties);
 auto& surfGeometry = surfGeometryPtr();
 
diff --git a/utilities/CMakeLists.txt b/utilities/CMakeLists.txt
index 3a7e766f..db9fee8b 100644
--- a/utilities/CMakeLists.txt
+++ b/utilities/CMakeLists.txt
@@ -1,13 +1,13 @@
 
-add_subdirectory(checkPhasicFlow)
+#add_subdirectory(checkPhasicFlow)
 
 add_subdirectory(particlesPhasicFlow)
 
 add_subdirectory(geometryPhasicFlow)
 
-add_subdirectory(pFlowToVTK)
+#add_subdirectory(pFlowToVTK)
 
 add_subdirectory(Utilities)
 
-add_subdirectory(postprocessPhasicFlow)
+#add_subdirectory(postprocessPhasicFlow)
 
diff --git a/utilities/Utilities/CMakeLists.txt b/utilities/Utilities/CMakeLists.txt
index 8c5d4ff5..47124ab0 100644
--- a/utilities/Utilities/CMakeLists.txt
+++ b/utilities/Utilities/CMakeLists.txt
@@ -2,15 +2,17 @@
 set(SourceFiles 
 readFromTimeFolder.cpp
 readControlDict.cpp
-vtkFile/vtkFile.cpp
+#vtkFile/vtkFile.cpp
 geometryPhasicFlow/Wall/Wall.cpp 
 geometryPhasicFlow/planeWall/planeWall.cpp 
-geometryPhasicFlow/stlWall/stlWall.cpp
+#geometryPhasicFlow/stlWall/stlWall.cpp
 geometryPhasicFlow/cylinderWall/cylinderWall.cpp
 geometryPhasicFlow/cuboidWall/cuboidWall.cpp
 )
 
-set(link_libs Kokkos::kokkos phasicFlow Particles Geometry)
+#set(link_libs Kokkos::kokkos phasicFlow Particles Geometry)
+
+set(link_libs Kokkos::kokkos phasicFlow)
 
 pFlow_add_library_install(Utilities SourceFiles link_libs)
 
diff --git a/utilities/Utilities/geometryPhasicFlow/cylinderWall/cylinderWall.cpp b/utilities/Utilities/geometryPhasicFlow/cylinderWall/cylinderWall.cpp
index db0b7987..2ea0a3c1 100644
--- a/utilities/Utilities/geometryPhasicFlow/cylinderWall/cylinderWall.cpp
+++ b/utilities/Utilities/geometryPhasicFlow/cylinderWall/cylinderWall.cpp
@@ -49,7 +49,7 @@ bool pFlow::cylinderWall::createCylinder(
 	real L = zAx.length();
 
 	
-	realx3Vector r1P(numDiv + 1), r2P(numDiv + 1);
+	realx3Vector r1P("r1P",numDiv + 1), r2P("r1P",numDiv + 1);
 	real dTheta = 2 * Pi / numDiv;
 	real theta = 0;
 
diff --git a/utilities/Utilities/geometryPhasicFlow/stlWall/stlWall.cpp b/utilities/Utilities/geometryPhasicFlow/stlWall/stlWall.cpp
index f54cfc67..cc561f3f 100755
--- a/utilities/Utilities/geometryPhasicFlow/stlWall/stlWall.cpp
+++ b/utilities/Utilities/geometryPhasicFlow/stlWall/stlWall.cpp
@@ -42,7 +42,7 @@ bool pFlow::stlWall::readSTLWall
 		return false;
 	}
 
-	for(label i=0; i<stl.size(); i++)
+	for(uint64 i=0; i<stl.size(); i++)
 	{
 		auto it = triangles_.end();
 		triangles_.insert(it, stl.solid(i).begin(), stl.solid(i).end());
diff --git a/utilities/Utilities/readFromTimeFolder.hpp b/utilities/Utilities/readFromTimeFolder.hpp
index 9294929f..a0d3b93d 100644
--- a/utilities/Utilities/readFromTimeFolder.hpp
+++ b/utilities/Utilities/readFromTimeFolder.hpp
@@ -20,7 +20,7 @@ Licence:
 #ifndef __readFromTimeFolder_hpp__
 #define __readFromTimeFolder_hpp__
 
-
+#include "vocabs.hpp"
 #include "repository.hpp"
 #include "pointFields.hpp"
 #include "utilityFunctions.hpp"
@@ -42,7 +42,7 @@ protected:
 public:
 
 
-	readFromTimeFolder(repository& rep);
+	explicit readFromTimeFolder(repository& rep);
 
 	auto path()const
 	{
@@ -65,9 +65,9 @@ public:
 	bool pointFieldGetType(word& typeName)const
 	{
 		word fieldTYPENAME = pointField_H<T>::TYPENAME();
-		word fldType{}, space{};
+		word fldType{};
 		
-		if( !pFlow::utilities::pointFieldGetType(
+		if(word space{};  !pFlow::utilities::pointFieldGetType(
 			fieldTYPENAME, fldType, space) )
 		{
 			fatalErrorInFunction<<
@@ -81,18 +81,19 @@ public:
 	}
 
 	template<typename T>
-	bool pointFieldGetCheckType(word fieldName, word& typeName) const
+	bool pointFieldGetCheckType(word const& fieldName, word& typeName) const
 	{
 		
 		word fieldTYPENAME = pointField_H<T>::TYPENAME();
-		word flType{},fldType{};
-
+		
+		word flType{};
 		if(!pointFieldFileGetType( fieldName, flType))
 		{
 			fatalExit;
 			return false;
 		}
-		
+
+		word fldType{};
 		if( !pointFieldGetType<T>(fldType) )
 		{
 			fatalExit;
@@ -112,7 +113,7 @@ public:
 	}
 
 	template<typename T>
-	pointField_H<T>&  createUniformPointField_H(word name, T value)
+	uniquePtr<pointField_H<T>>  createUniformPointField_H(word const& name, T value)
 	{
 		if( !checkForPointStructure() )
 		{
@@ -120,29 +121,28 @@ public:
 			"cannot find " << pointStructureFile__ << " in repository "<< repository_.name()<<endl;
 			fatalExit;
 		}
+
 		auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
 
-		word fType;
-		pointFieldGetType<T>(fType);
-		word newName = name + fType;
 
-		auto& field = repository_.emplaceReplaceObject<pointField_H<T>>(
-			objectFile(
+		auto Ptr = makeUnique<pointField_H<T>>
+		(
+			objectFile
+			(
 				name,
 				"",
 				objectFile::READ_NEVER,
 				objectFile::WRITE_NEVER
-				),
+			),
 			pStruct,
+			T{},
 			value
-			);
-
-		return field;
-
+		);
+		return Ptr;
 	}
 
 	template<typename T>
-	pointField_H<T>& readPointField_H(word name) 
+	uniquePtr<pointField_H<T>> readPointField_H(word const& name) 
 	{
 		if( !checkForPointStructure() )
 		{
@@ -152,23 +152,25 @@ public:
 		}
 		auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
 
-		auto& field = repository_.emplaceObjectOrGet<pointField_H<T>>(
-			objectFile(
+		auto Ptr = makeUnique<pointField_H<T>>
+		(
+			objectFile
+			(
 				name,
 				"",
 				objectFile::READ_IF_PRESENT,
 				objectFile::WRITE_ALWAYS
-				),
+			),
 			pStruct,
 			T{}
-			);
+		);
 
-		return field;
+		return Ptr;
 
 	}
 
 	template<typename T>
-	pointField_D<T>& readPointField_D(word name) 
+	uniquePtr<pointField_D<T>> readPointField_D(word const& name) 
 	{
 		if( !checkForPointStructure() )
 		{
@@ -178,18 +180,20 @@ public:
 		}
 		auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
 
-		auto& field = repository_.emplaceObjectOrGet<pointField_H<T>>(
-			objectFile(
+		auto Ptr = makeUnique<pointField_D<T>> 
+		(
+			objectFile
+			(
 				name,
 				"",
 				objectFile::READ_IF_PRESENT,
 				objectFile::WRITE_ALWAYS
-				),
+			),
 			pStruct,
 			T{}
-			);
+		);
 
-		return field;
+		return Ptr;
 	}
 
 };
diff --git a/utilities/geometryPhasicFlow/CMakeLists.txt b/utilities/geometryPhasicFlow/CMakeLists.txt
index 6fe0358e..0700a50b 100644
--- a/utilities/geometryPhasicFlow/CMakeLists.txt
+++ b/utilities/geometryPhasicFlow/CMakeLists.txt
@@ -2,6 +2,6 @@
 set(source_files 
 geometryPhasicFlow.cpp
 )
-set(link_lib phasicFlow Geometry Kokkos::kokkos Utilities)
+set(link_lib phasicFlow Kokkos::kokkos Geometry Utilities)
 
 pFlow_make_executable_install(geometryPhasicFlow source_files link_lib)
diff --git a/utilities/geometryPhasicFlow/geometryPhasicFlow.cpp b/utilities/geometryPhasicFlow/geometryPhasicFlow.cpp
index f6967f92..4fa51770 100755
--- a/utilities/geometryPhasicFlow/geometryPhasicFlow.cpp
+++ b/utilities/geometryPhasicFlow/geometryPhasicFlow.cpp
@@ -18,26 +18,15 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-
+#include "vocabs.hpp"
 #include "systemControl.hpp"
 #include "Wall.hpp"
-#include "Vectors.hpp"
-#include "multiTriSurface.hpp"
-#include "geometryMotion.hpp"
+#include "geometry.hpp"
 #include "commandLine.hpp"
-#include "readControlDict.hpp"
+//#include "readControlDict.hpp"
 
-using pFlow::output;
-using pFlow::endl;
-using pFlow::IOobject;
-using pFlow::dictionary;
-using pFlow::objectFile;
-using pFlow::wordVector;
-using pFlow::Wall;
-using pFlow::geometry;
-using pFlow::realx3x3Vector;
-using pFlow::multiTriSurface;
-using pFlow::commandLine;
+
+using namespace pFlow;
 
 int main( int argc, char* argv[] )
 {
@@ -61,9 +50,8 @@ int main( int argc, char* argv[] )
 
 	#include "setProperty.hpp"
 
-	REPORT(0)<<"\nReading "<<"createGeometryDict"<<" . . ."<<endREPORT;
-	auto objDict = IOobject::make<dictionary>
-	(
+	REPORT(0)<<"\nReading "<<"geometryDict"<<" . . ."<<END_REPORT;
+	auto geometryDict = fileDictionary(
 		objectFile
 		(
 			"geometryDict",
@@ -71,46 +59,68 @@ int main( int argc, char* argv[] )
 			objectFile::READ_ALWAYS,
 			objectFile::WRITE_NEVER
 		),
-		"geometryDict",
-		true
+		nullptr
 	);
-
-	auto& geometryDict = objDict().getObject<dictionary>();
-
+	
 	auto& surfacesDict = geometryDict.subDict("surfaces");
 
 	auto wallsDictName = surfacesDict.dictionaryKeywords();
 
 	
-
-	multiTriSurface surface;
-	wordVector materials;
-	wordVector motion;
+	word mSurfaceName = word("geometryPhasicFlow_")+word(triSurfaceFile__);
+	multiTriSurface surface
+	(
+		objectFile
+		(
+			mSurfaceName,
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_ALWAYS
+		),
+		nullptr
+	);
 	
+	wordVector materials;
+	wordList materialsList;
+
+	wordVector motion;
+	wordList motionList;
+
 	for(auto& name:wallsDictName)
 	{
-		REPORT(1)<<"Creating wall "<<greenText(name)<<" from file dictionary . . . "<<endREPORT;
+		REPORT(1)<<"Creating wall "<<Green_Text(name)<<" from dictionary "<<surfacesDict.globalName() <<END_REPORT;
 		auto wallPtr = Wall::create( surfacesDict.subDict(name));
 		auto& wall = wallPtr();
-		REPORT(1)<<"wall type is "<<greenText(wall.typeName())<<'\n'<<endREPORT;		
+		REPORT(1)<<"wall type is "<<Green_Text(wall.typeName())<<'\n'<<END_REPORT;		
 
-		realx3x3Vector trinalges(wall.name());
-		trinalges = wall.triangles();
-		surface.addTriSurface(wall.name(), trinalges);
+		realx3x3Vector trinalges(wall.name(), wall.triangles());
+		
+		surface.appendSurface(wall.name(), trinalges);
 		materials.push_back(wall.materialName());
+		materialsList.push_back(wall.materialName());
+
 		motion.push_back(wall.motionName());
+		motionList.push_back(wall.motionName());
 	}
 
-	REPORT(1)<<"Selected wall materials are "<<cyanText(materials)<<'\n'<<endREPORT;
-		
-	REPORT(0)<< "\nCreating geometry . . ."<<endREPORT;
-	auto geomPtr = geometry::create(Control, proprties, geometryDict, surface, motion, materials);
-	REPORT(1)<< "geometry type is "<< greenText(geomPtr().typeName())<<endREPORT;
 	
-	REPORT(1)<< "Writing geometry to folder "<< geomPtr().path()<<endREPORT;
-	geomPtr().write();
+	REPORT(1)<<"Selected wall materials are "<<Cyan_Text(materialsList)<<'\n'<<END_REPORT;
+	REPORT(1)<<"Selected wall motion components are "<<Cyan_Text(motionList)<<'\n'<<END_REPORT;
+		
+	REPORT(0)<< "\nCreating geometry . . ."<<END_REPORT;
+	auto geomPtr = geometry::create(
+		Control, 
+		proprties, 
+		surface, 
+		motion, 
+		materials, 
+		geometryDict);
+	
+	REPORT(1)<< "geometry type is "<< Green_Text(geomPtr().typeName())<<END_REPORT;
 
-	REPORT(0)<< greenText("\nFinished successfully.\n");
+	Control.time().write(true);
+
+	REPORT(0)<< Green_Text("\nFinished successfully.\n")<<END_REPORT;
 
 // this should be palced in each main 
 #include "finalize.hpp"
diff --git a/utilities/particlesPhasicFlow/CMakeLists.txt b/utilities/particlesPhasicFlow/CMakeLists.txt
index 4a46570a..649d9ba0 100644
--- a/utilities/particlesPhasicFlow/CMakeLists.txt
+++ b/utilities/particlesPhasicFlow/CMakeLists.txt
@@ -3,9 +3,11 @@ set(source_files
 particlesPhasicFlow.cpp
 positionParticles/positionParticles.cpp 
 positionOrdered/positionOrdered.cpp 
-positionRandom/positionRandom.cpp
+#positionRandom/positionRandom.cpp
 empty/empty.cpp
 )
-set(link_lib phasicFlow Kokkos::kokkos Interaction Utilities)
+#set(link_lib phasicFlow Kokkos::kokkos Interaction Utilities)
+
+set(link_lib phasicFlow Kokkos::kokkos Particles Utilities)
 
 pFlow_make_executable_install(particlesPhasicFlow source_files link_lib)
diff --git a/utilities/particlesPhasicFlow/empty/empty.cpp b/utilities/particlesPhasicFlow/empty/empty.cpp
index 1b938c00..5ed799a2 100755
--- a/utilities/particlesPhasicFlow/empty/empty.cpp
+++ b/utilities/particlesPhasicFlow/empty/empty.cpp
@@ -23,13 +23,14 @@ Licence:
 
 
 pFlow::empty::empty(
+  systemControl& control,
 	const dictionary& dict
 )
 :
-	positionParticles(dict),
+	positionParticles(control, dict),
 	position_
 	(
-		maxNumberOfParticles_, 0, RESERVE()
+		"empty",maxNumberOfParticles_, 0, RESERVE()
 	)
 {
 }
\ No newline at end of file
diff --git a/utilities/particlesPhasicFlow/empty/empty.hpp b/utilities/particlesPhasicFlow/empty/empty.hpp
index fc3bada1..a4583b7c 100755
--- a/utilities/particlesPhasicFlow/empty/empty.hpp
+++ b/utilities/particlesPhasicFlow/empty/empty.hpp
@@ -44,7 +44,9 @@ public:
 	// - type Info
 	TypeInfo("empty");
 
-	empty(const dictionary& dict);
+	empty(
+		systemControl& control,
+		const dictionary& dict);
 
 	// - add this class to vCtor selection table 
 	add_vCtor(
@@ -56,12 +58,12 @@ public:
 
 	//// - Methods 
 
-	virtual label numPoints()const
+	virtual uint64 numPoints()const
 	{
 		return 0;
 	}
 
-	virtual label size()const
+	virtual uint64 size()const
 	{
 		return 0;
 	}
diff --git a/utilities/particlesPhasicFlow/particlesPhasicFlow.cpp b/utilities/particlesPhasicFlow/particlesPhasicFlow.cpp
index 683d33e4..5cdced7c 100755
--- a/utilities/particlesPhasicFlow/particlesPhasicFlow.cpp
+++ b/utilities/particlesPhasicFlow/particlesPhasicFlow.cpp
@@ -19,25 +19,17 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
+#include "vocabs.hpp"
+#include "commandLine.hpp"
 #include "positionParticles.hpp"
 #include "pointStructure.hpp"
 #include "setFields.hpp"
 #include "systemControl.hpp"
-#include "commandLine.hpp"
-#include "readControlDict.hpp"
+#include "baseShapeNames.hpp"
 
-using pFlow::output;
-using pFlow::endl;
-using pFlow::dictionary;
-using pFlow::uniquePtr;
-using pFlow::IOobject;
-using pFlow::objectFile;
-using pFlow::fileSystem;
-using pFlow::pointStructure;
-using pFlow::pointStructureFile__;
-using pFlow::positionParticles;
-using pFlow::commandLine;
-using pFlow::setFieldList;
+//#include "readControlDict.hpp"
+
+using namespace pFlow;
 
 int main( int argc, char* argv[] )
 {
@@ -74,93 +66,50 @@ int main( int argc, char* argv[] )
 	if(setOnly && positionOnly)
 	{
 		ERR<<
-		"Options --positionParticles-only and --setFields-only cannot be used simeltanuously. \n"<<endERR;
+		"Options --positionParticles-only and --setFields-only cannot be used simeltanuously. \n"<<END_ERR;
 		return 1;
 	}	
 
 // this should be palced in each main 
 #include "initialize_Control.hpp"
 
-	auto objCPDict = IOobject::make<dictionary>
-	(
-		objectFile
-		(
-			"particlesDict",
-			Control.settings().path(),
-			objectFile::READ_ALWAYS,
-			objectFile::WRITE_ALWAYS
-		),
-		"particlesDict",
-		true
-	);
+	fileDictionary cpDict("particlesDict", Control.settings().path());
+	
 
-	auto& cpDict = objCPDict().getObject<dictionary>();
-
-	pointStructure* pStructPtr = nullptr;
+	uniquePtr<pointStructure> pStructPtr = nullptr;
 
 
 	if(!setOnly)
 	{
 
 		// position particles based on the dict content 
-		REPORT(0)<< "Positioning points . . . \n"<<endREPORT;
-		auto pointPosition = positionParticles::create(cpDict.subDict("positionParticles"));
+		REPORT(0)<< "Positioning points . . . \n"<<END_REPORT;
+		auto pointPosition = positionParticles::create(Control, cpDict.subDict("positionParticles"));
 
 		fileSystem pStructPath = Control.time().path()+pointStructureFile__;
 
 		auto finalPos = pointPosition().getFinalPosition();
 
-		
-		auto& pStruct = Control.time().emplaceObject<pointStructure>
-		(
-			objectFile
-			(
-				pointStructureFile__,
-				Control.time().path(),
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS			
-			),
-			finalPos
-		);
-
-		pStructPtr = &pStruct;
+		pStructPtr = makeUnique<pointStructure>(Control, finalPos);
 
 
-		REPORT(1)<< "Created pStruct with "<< pStruct.size() << " points and capacity "<<
-		pStruct.capacity()<<" . . ."<< endREPORT;
+		REPORT(1)<< "Created pStruct with "<< pStructPtr().size() << " points and capacity "<<
+		pStructPtr().capacity()<<" . . ."<< END_REPORT;
 
-		REPORT(1)<< "Writing pStruct to " << Control.time().path()+ pointStructureFile__<< endREPORT<<endl<<endl;
-
-		if( !Control.time().write())
-		{
-			fatalErrorInFunction<<
-			"ERRor in writing to file. \n ";
-			return 1; 
-		}
-	}else
+	}
+    else
 	{
-
-		auto& pStruct = Control.time().emplaceObject<pointStructure>
-		(
-			objectFile
-			(
-				pointStructureFile__,
-				Control.time().path(),
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS			
-			)
-		);
-
-		pStructPtr = &pStruct;
+		// read the content of pStruct from 0/pStructure
+		pStructPtr = makeUnique<pointStructure>(Control);
 
 	}
 
-	
+	List<uniquePtr<IOobject>> allObjects;
 
 	if(!positionOnly)
 	{
-
-		auto& pStruct = *pStructPtr;
+        
+		auto& pStruct = pStructPtr();
 
 		auto& sfDict = cpDict.subDict("setFields");
 
@@ -168,9 +117,13 @@ int main( int argc, char* argv[] )
 
 		for(auto& sfEntry: defValueList)
 		{
-			if( !sfEntry.setPointFieldDefaultValueNewAll(Control.time(), pStruct, true))
+			if( auto Ptr = sfEntry.setPointFieldDefaultValueNewAll( pStruct, true); Ptr)
 			{
-				ERR<< "\n error occured in setting default value fields.\n"<<endERR;
+				allObjects.push_back(std::move(Ptr));
+			}
+			else
+			{
+				ERR<< "\n error occured in setting default value fields.\n"<<END_ERR;
 				return 1;
 			}
 		}
@@ -183,123 +136,91 @@ int main( int argc, char* argv[] )
 
 		for(auto name: selNames)
 		{
-			REPORT(1)<< "Applying selector " << greenText(name) <<endREPORT;
+			REPORT(1)<< "Applying selector " << Green_Text(name) <<END_REPORT;
 			
 			if(
 				!applySelector(Control, pStruct, selectorsDict.subDict(name))
 			 )
 			{
-				ERR<<"\n error occured in setting selector. \n"<<endERR;
+				ERR<<"\n error occured in setting selector. \n"<<END_ERR;
 				return 1;
 			}
 			output<<endl;
 		}
 	}
 
-	Control.time().write(true);
-	REPORT(0)<< greenText("\nFinished successfully.\n")<<endREPORT;
+	Control.clearIncludeExclude();
+	Control.addExclude("shapeName");
 
+	uint64PointField_H shapeHash
+	(
+		objectFile
+		(
+			"shapeHash",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_ALWAYS
+		),
+		pStructPtr(),
+		0u
+	);
 
+	uint32PointField_H shapeIndex
+	(
+		objectFile
+		(
+			"shapeIndex",
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_ALWAYS
+		),
+		pStructPtr(),
+		0u
+	);
+
+	baseShapeNames shapes(
+		shapeFile__,
+		&Control.caseSetup()
+	);
+	
+	auto& shapeName = Control.time().template lookupObject<wordPointField_H>("shapeName");
+
+	REPORT(0)<< "Converting shapeName field to shapeIndex field"<<END_REPORT;
+
+	auto shapeName_D = shapeName.deviceView();
+	auto shapeHash_D = shapeHash.deviceView();
+	auto shapeIndex_D = shapeIndex.deviceView();
+	
+	REPORT(1)<<"List of shape names in "<<shapes.globalName()<<
+	" is: "<<Green_Text(shapes.shapeNameList())<<END_REPORT;
+
+	ForAll(i, shapeHash)
+	{
+		if(uint32 index; shapes.shapeNameToIndex(shapeName_D[i], index))
+		{
+			shapeHash_D[i] = shapes.hashes()[index];
+			shapeIndex_D[i] = index;
+		}
+		else
+		{
+			fatalErrorInFunction<<"Found shape name "<< Yellow_Text(shapeName_D[i])<<
+			"in shapeName field. But the list of shape names in file "<< 
+			shapes.globalName()<<" is : \n"<<
+			shapes.shapeNames()<<endl;
+		}
+	}
+
+    if( !Control.time().write(true))
+    {
+        fatalErrorInFunction<<
+        "ERRor in writing to file. \n ";
+        return 1; 
+    }
+	REPORT(0)<< Green_Text("\nFinished successfully.\n")<<END_REPORT;
+
+	
 // this should be palced in each main 
 #include "finalize.hpp"
 
 	return 0;
 } 
-
-
-
-/*
-uniquePtr<IOobject> pStructObj{nullptr};
-
-	if(!setOnly)
-	{
-
-		// position particles based on the dict content 
-		REPORT(0)<< "Positioning points . . . \n"<<endREPORT;
-		auto pointPosition = positionParticles::create(cpDict.subDict("positionParticles"));
-
-		fileSystem pStructPath = Control.time().path()+pointStructureFile__;
-
-		auto finalPos = pointPosition().getFinalPosition();
-
-		
-		pStructObj = IOobject::make<pointStructure>
-		(
-			objectFile
-			(
-				pointStructureFile__,
-				Control.time().path(),
-				objectFile::READ_NEVER,
-				objectFile::WRITE_ALWAYS			
-			),
-			finalPos
-		);
-
-		auto& pSruct = pStructObj().getObject<pointStructure>();
-
-		REPORT(1)<< "Created pStruct with "<< pSruct.size() << " points and capacity "<<
-		pSruct.capacity()<<" . . ."<< endREPORT;
-
-		REPORT(1)<< "Writing pStruct to " << pStructObj().path() << endREPORT<<endl<<endl;
-
-		if( !pStructObj().write())
-		{
-			fatalErrorInFunction<<
-			"ERRor in writing to file. \n ";
-			return 1; 
-		}
-	}else
-	{
-		pStructObj = IOobject::make<pointStructure>
-		(
-			objectFile
-			(
-				pointStructureFile__,
-				Control.time().path(),
-				objectFile::READ_ALWAYS,
-				objectFile::WRITE_NEVER			
-			)
-		);
-	}
-
-	
-
-	if(!positionOnly)
-	{
-
-		auto& pStruct = pStructObj().getObject<pointStructure>();
-
-		auto& sfDict = cpDict.subDict("setFields");
-
-		setFieldList defValueList(sfDict.subDict("defaultValue"));
-
-		for(auto& sfEntry: defValueList)
-		{
-			if( !sfEntry.setPointFieldDefaultValueNewAll(Control.time(), pStruct, true))
-			{
-				ERR<< "\n error occured in setting default value fields.\n"<<endERR;
-				return 1;
-			}
-		}
-		
-		output<<endl;
-
-		auto& selectorsDict = sfDict.subDict("selectors");
-
-		auto selNames = selectorsDict.dictionaryKeywords();
-
-		for(auto name: selNames)
-		{
-			REPORT(1)<< "Applying selector " << greenText(name) <<endREPORT;
-			
-			if(
-				!applySelector(Control, pStruct, selectorsDict.subDict(name))
-			 )
-			{
-				ERR<<"\n error occured in setting selector. \n"<<endERR;
-				return 1;
-			}
-			output<<endl;
-		}
-	}
-	*/
\ No newline at end of file
diff --git a/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.cpp b/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.cpp
index dc4d69e7..77d624b4 100755
--- a/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.cpp
+++ b/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.cpp
@@ -123,10 +123,11 @@ bool pFlow::positionOrdered::positionPointsOrdered()
 
 pFlow::positionOrdered::positionOrdered
 (
+	systemControl& control,
 	const dictionary& dict
 )
 :
-	positionParticles(dict),
+	positionParticles(control, dict),
 	poDict_
 	(  
 		dict.subDict("positionOrderedInfo")
@@ -137,7 +138,7 @@ pFlow::positionOrdered::positionOrdered
 	),
 	numPoints_
 	(
-		poDict_.getVal<size_t>("numPoints")
+		poDict_.getVal<uint64>("numPoints")
 	),
 	axisOrder_
 	(
@@ -145,7 +146,7 @@ pFlow::positionOrdered::positionOrdered
 	),
 	position_
 	(
-		maxNumberOfParticles_, RESERVE()
+		"positionOrdered", maxNumberOfParticles_, numPoints_ ,RESERVE()
 	)
 {
 	
diff --git a/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.hpp b/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.hpp
index 66452ab0..5d18ae57 100755
--- a/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.hpp
+++ b/utilities/particlesPhasicFlow/positionOrdered/positionOrdered.hpp
@@ -62,7 +62,9 @@ public:
 	// - type Info
 	TypeInfo("positionOrdered");
 
-	positionOrdered(const dictionary& dict);
+	positionOrdered(
+		systemControl& control,
+		const dictionary& dict);
 
 	// - add this class to vCtor selection table 
 	add_vCtor(
@@ -74,12 +76,12 @@ public:
 
 	//// - Methods 
 
-	virtual label numPoints()const
+	virtual uint64 numPoints()const
 	{
 		return position_.size();
 	}
 
-	virtual label size()const
+	virtual uint64 size()const
 	{
 		return position_.size();
 	}
diff --git a/utilities/particlesPhasicFlow/positionParticles/positionParticles.cpp b/utilities/particlesPhasicFlow/positionParticles/positionParticles.cpp
index fcfb4616..a7d3879a 100755
--- a/utilities/particlesPhasicFlow/positionParticles/positionParticles.cpp
+++ b/utilities/particlesPhasicFlow/positionParticles/positionParticles.cpp
@@ -19,11 +19,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "positionParticles.hpp"
+#include "vocabs.hpp"
 #include "box.hpp"
 #include "cylinder.hpp"
 #include "sphere.hpp"
 #include "cells.hpp"
-#include "contactSearchFunctions.hpp"
+//#include "contactSearchFunctions.hpp"
 
 #include "streams.hpp"
 
@@ -32,20 +33,20 @@ pFlow::realx3Vector pFlow::positionParticles::sortByMortonCode(realx3Vector& pos
 {
 	struct indexMorton
 	{
-		size_t morton;
-		size_t index;
+		uint64 morton;
+		uint64 index;
 	};
 
-	realx3 minP = min(position);
+	/*realx3 minP = min(position);
 	realx3 maxP = max(position);
 	real cellsize = maxDiameter();
-	cells<size_t> allCells( box(minP, maxP), cellsize);
+	cells<uint64> allCells( box(minP, maxP), cellsize);
 
 	Vector<indexMorton> indMor(position.size(),RESERVE());
 
 	indMor.clear();
 
-	size_t ind=0;
+	uint64 ind=0;
 	for(const auto& p:position)
 	{
 		auto cellInd = allCells.pointIndex(p);
@@ -54,7 +55,7 @@ pFlow::realx3Vector pFlow::positionParticles::sortByMortonCode(realx3Vector& pos
 			ind++});
 	}
 
-	INFORMATION<<"Performing morton sorting."<<endINFO;
+	INFORMATION<<"Performing morton sorting."<<END_INFO;
 	std::sort(
 		indMor.begin(),
 		indMor.end(),
@@ -68,18 +69,20 @@ pFlow::realx3Vector pFlow::positionParticles::sortByMortonCode(realx3Vector& pos
 	for(auto& ind:indMor)
 	{
 		sortedPos.push_back( position[ind.index] );
-	}
+	}*/
 
-	return sortedPos;
+    WARNING<<"Morton sorting is inactive!"<<END_WARNING;
+	return position;
 }
 
 
 pFlow::positionParticles::positionParticles
 (
+	systemControl& control,
 	const dictionary& dict
 )
 {
-	maxNumberOfParticles_ = dict.getValOrSet("maxNumberOfParticles", static_cast<size_t>(10000));
+	maxNumberOfParticles_ = dict.getValOrSet("maxNumberOfParticles", static_cast<uint64>(10000));
 	
 	mortonSorting_ = dict.getValOrSet("mortonSorting", Logical("Yes"));
 
@@ -89,12 +92,30 @@ pFlow::positionParticles::positionParticles
 	}
 	else if(dict.containsDictionay("cylinder"))
 	{
-		region_ = makeUnique<region<cylinder>>(dict.subDict("cylinder"));
+        WARNING<<"cylinder region is not set!"<<END_WARNING;
+		//region_ = makeUnique<region<cylinder>>(dict.subDict("cylinder"));
 	}
 	else if(dict.containsDictionay("sphere"))
 	{
-		region_ = makeUnique<region<sphere>>(dict.subDict("sphere"));
+        WARNING<<"sphere region is not set!"<<END_WARNING;
+		//region_ = makeUnique<region<sphere>>(dict.subDict("sphere"));
 	}
+	else
+	{
+		fileDictionary domainDict
+		(
+			objectFile
+			{
+				domainFile__,
+				"",
+				objectFile::READ_ALWAYS,
+				objectFile::WRITE_NEVER
+			},
+			&control.settings()
+		);
+		region_ = makeUnique<region<box>>( domainDict.subDict("globalBox"));
+	}
+	
 }
 
 
@@ -106,7 +127,7 @@ pFlow::realx3Vector pFlow::positionParticles::getFinalPosition()
 	}
 	else
 	{
-		realx3Vector vec(position().capacity(), RESERVE());
+		realx3Vector vec("final position",position().capacity(), 0 , RESERVE());
 		vec.assign( position().begin(), position().end());
 		
 		return std::move(vec);
@@ -114,7 +135,11 @@ pFlow::realx3Vector pFlow::positionParticles::getFinalPosition()
 }
 
 pFlow::uniquePtr<pFlow::positionParticles> 
-	pFlow::positionParticles::create(const dictionary & dict)
+	pFlow::positionParticles::create
+(
+    systemControl& control,
+    const dictionary & dict
+)
 {
 
 	word method = dict.getVal<word>("method");
@@ -122,7 +147,7 @@ pFlow::uniquePtr<pFlow::positionParticles>
 
 	if( dictionaryvCtorSelector_.search(method) )
 	{
-		return dictionaryvCtorSelector_[method] (dict);
+		return dictionaryvCtorSelector_[method] (control, dict);
 	}
 	else
 	{
diff --git a/utilities/particlesPhasicFlow/positionParticles/positionParticles.hpp b/utilities/particlesPhasicFlow/positionParticles/positionParticles.hpp
index 48fc222b..ddd12455 100755
--- a/utilities/particlesPhasicFlow/positionParticles/positionParticles.hpp
+++ b/utilities/particlesPhasicFlow/positionParticles/positionParticles.hpp
@@ -24,6 +24,7 @@ Licence:
 #include "virtualConstructor.hpp"
 #include "Vectors.hpp"
 #include "dictionary.hpp"
+#include "systemControl.hpp"
 
 namespace pFlow
 {
@@ -118,23 +119,25 @@ public:
 	// - type Info
 	TypeInfo("positionParticles");
 
-	positionParticles(const dictionary& dict);
+	positionParticles(
+		systemControl& control, 
+		const dictionary& dict);
 
 	create_vCtor
 	(
 		positionParticles,
 		dictionary,
-		(const dictionary& dict),
-		(dict)
+		(systemControl& control, const dictionary& dict),
+		(control, dict)
 	);
 
 	virtual ~positionParticles() = default;
 
 	//// - Methods 
 
-	virtual label numPoints()const = 0;
+	virtual uint64 numPoints()const = 0;
 
-	virtual label size()const = 0;
+	virtual uint64 size()const = 0;
 
 	virtual real maxDiameter() const = 0;
 
@@ -148,7 +151,8 @@ public:
 	virtual realx3Vector getFinalPosition();
 
 	static
-	uniquePtr<positionParticles> create(const dictionary & dict);
+	uniquePtr<positionParticles> 
+		create(systemControl& control, const dictionary & dict);
 	
 };	
 
diff --git a/utilities/particlesPhasicFlow/positionRandom/positionRandom.cpp b/utilities/particlesPhasicFlow/positionRandom/positionRandom.cpp
index 616dbbca..750509f3 100755
--- a/utilities/particlesPhasicFlow/positionRandom/positionRandom.cpp
+++ b/utilities/particlesPhasicFlow/positionRandom/positionRandom.cpp
@@ -69,8 +69,8 @@ bool pFlow::positionRandom::positionOnePass(int32 pass, int32 startNum)
 	SearchType search(
 					box(minP, maxP),
 					diameter_,
-					positionHD.deviceVectorAll(),
-					diameter.deviceVectorAll());
+					positionHD.deviceViewAll(),
+					diameter.deviceViewAll());
 
 	ContainerType pairs(3*startNum);
 		
@@ -158,10 +158,11 @@ bool pFlow::positionRandom::inCollision
 
 pFlow::positionRandom::positionRandom
 (
+	systemControl& control,
 	const dictionary& dict
 )
 :
-	positionParticles(dict),
+	positionParticles(control, dict),
 	prDict_
 	(  
 		dict.subDict("positionRandomInfo")
@@ -249,7 +250,7 @@ pFlow::int32 pFlow::findCollisions(
 {
 	auto allPairs = pairs.getPairs();
 	auto num = pairs.capacity();
-	auto dFlags = flags.deviceVector();
+	auto dFlags = flags.deviceView();
 	
 
 	int32 numCollisions = 0;
diff --git a/utilities/particlesPhasicFlow/positionRandom/positionRandom.hpp b/utilities/particlesPhasicFlow/positionRandom/positionRandom.hpp
index 33bc9899..ff301c54 100755
--- a/utilities/particlesPhasicFlow/positionRandom/positionRandom.hpp
+++ b/utilities/particlesPhasicFlow/positionRandom/positionRandom.hpp
@@ -66,7 +66,9 @@ public:
 	// - type Info
 	TypeInfo("positionRandom");
 
-	positionRandom(const dictionary& dict);
+	positionRandom(
+		systemControl& control,
+		const dictionary& dict);
 
 	// - add this class to vCtor selection table 
 	add_vCtor(
@@ -78,12 +80,12 @@ public:
 
 	//// - Methods 
 
-	virtual label numPoints()const
+	virtual uint64 numPoints()const
 	{
 		return position_.size();
 	}
 
-	virtual label size()const
+	virtual uint64 size()const
 	{
 		return position_.size();
 	}
diff --git a/utilities/particlesPhasicFlow/setFields.hpp b/utilities/particlesPhasicFlow/setFields.hpp
index 0315c1b2..0eb56745 100755
--- a/utilities/particlesPhasicFlow/setFields.hpp
+++ b/utilities/particlesPhasicFlow/setFields.hpp
@@ -39,7 +39,7 @@ bool applySelector(systemControl& control, const pointStructure& pStruct, const
 
 	auto& selected = selector().selectedPoinsts();
 
-	int32IndexContainer selIndex(selected.data(), selected.size());
+	uint32IndexContainer selIndex(selected.data(), selected.size());
 
 	setFieldList sfList(selDict.subDict("fieldValue"));