diff --git a/src/phasicFlow/Kokkos/KokkosTypes.H b/src/phasicFlow/Kokkos/KokkosTypes.H
new file mode 100644
index 00000000..63ff7d40
--- /dev/null
+++ b/src/phasicFlow/Kokkos/KokkosTypes.H
@@ -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 __KokkosTypes_H__
+#define __KokkosTypes_H__
+
+
+#include <Kokkos_Core.hpp>
+#include <Kokkos_DualView.hpp>
+#include <Kokkos_UnorderedMap.hpp>
+
+
+namespace pFlow
+{
+
+class DeviceSide{};
+class HostSide{};
+
+template<typename side>
+struct selectSide{};
+
+using HostSpace 					= Kokkos::HostSpace;
+using Serial 						= Kokkos::Serial;
+
+#ifdef _OPENMP
+using OpenMP 						= Kokkos::OpenMP;
+#endif
+
+using DefaultHostExecutionSpace 	= Kokkos::DefaultHostExecutionSpace;
+using DefaultExecutionSpace 		= Kokkos::DefaultExecutionSpace;
+
+
+
+template<typename T1, typename T2>
+	using kPair = Kokkos::pair<T1,T2>;
+
+using range = kPair<int,int>;
+
+using range64 = kPair<int long,int long>;
+
+template<typename T, typename... properties>
+	using ViewTypeScalar = Kokkos::View<T,properties...>;
+
+template<typename T, typename... properties>
+	using ViewType1D = Kokkos::View<T*,properties...>;
+
+template<typename T, typename... properties>
+	using ViewType3D = Kokkos::View<T***,properties...>;
+
+template<typename Key, typename Value, typename... properties>
+	using unorderedMap = Kokkos::UnorderedMap<Key, Value, properties...>;
+
+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)
+template<typename T>
+	using deviceViewTypeScalar = Kokkos::View<T>;
+
+template<typename T>
+	using deviceViewType1D = Kokkos::View<T*>;
+
+template<typename T, typename Layout=void>
+	using deviceViewType2D = Kokkos::View<T**,Layout, void>;
+
+
+// a 1D array (vector with host memeory space)
+template<typename T>
+	using hostViewTypeScalar = Kokkos::View<T, Kokkos::HostSpace>;
+
+template<typename T>
+	using hostViewType1D = Kokkos::View<T*, Kokkos::HostSpace>;
+
+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>;
+
+template<typename T, typename Layout=void>
+	using cudaViewType2D = Kokkos::View<T*,Layout, Kokkos::CudaSpace>;
+#endif
+
+
+template<typename T>
+using deviceAtomicViewType1D = 
+    Kokkos::View<
+		T*,
+		Kokkos::MemoryTraits<std::is_same<DefaultExecutionSpace,Serial>::value?0:Kokkos::Atomic>>;
+
+template<typename T>
+using deviceAtomicViewType3D =
+	Kokkos::View<
+	T***,
+	Kokkos::MemoryTraits<std::is_same<DefaultExecutionSpace,Serial>::value?0:Kokkos::Atomic>>;
+
+
+} // pFlow
+
+#endif  //__KokkosTypes_H__
diff --git a/src/phasicFlow/Kokkos/KokkosUtilities.H b/src/phasicFlow/Kokkos/KokkosUtilities.H
new file mode 100644
index 00000000..972565f5
--- /dev/null
+++ b/src/phasicFlow/Kokkos/KokkosUtilities.H
@@ -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 __KokkosUtilities_H__
+#define __KokkosUtilities_H__
+
+
+#include "KokkosTypes.H"
+
+
+namespace pFlow
+{
+
+template<typename ExecutionSpace>
+INLINE_FUNCTION_H
+bool constexpr isHostAccessible()
+{
+	return Kokkos::SpaceAccessibility<ExecutionSpace,HostSpace>::accessible;
+}
+
+template<typename ExecutionSpace, typename MemoerySpace>
+INLINE_FUNCTION_H
+bool constexpr areAccessible()
+{
+	return Kokkos::SpaceAccessibility<ExecutionSpace,MemoerySpace>::accessible;
+}
+
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void realloc( ViewType1D<Type,Properties...>& view, int32 len)
+{
+	Kokkos::realloc(view, len);
+}
+
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void reallocNoInit(ViewType1D<Type,Properties...>& view, int32 len)
+{
+	using ViewType = ViewType1D<Type,Properties...>;
+	word vl = view.label();
+	view = ViewType();  // Deallocate first
+  	view = ViewType( 
+  		Kokkos::view_alloc(
+  			Kokkos::WithoutInitializing,
+  			vl), 
+  		len);
+}
+
+template <
+	typename Type,
+	typename... Properties>
+INLINE_FUNCTION_H
+void reallocFill( ViewType1D<Type,Properties...>& view, int32 len, Type val)
+{
+	reallocNoInit(view, len);
+	Kokkos::deep_copy(view, val);
+}
+
+
+template<typename ViewType>
+INLINE_FUNCTION_H
+void swapViews(ViewType& v1, ViewType &v2)
+{
+	auto tmp = v1;
+	v1 = v2;
+	v2 = tmp;
+}
+
+} // pFlow
+
+#endif  //__KokkosUtilities_H__
diff --git a/src/phasicFlow/Kokkos/ViewAlgorithms.H b/src/phasicFlow/Kokkos/ViewAlgorithms.H
new file mode 100644
index 00000000..4d944a87
--- /dev/null
+++ b/src/phasicFlow/Kokkos/ViewAlgorithms.H
@@ -0,0 +1,593 @@
+/*------------------------------- 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 __ViewAlgorithms_H__
+#define __ViewAlgorithms_H__
+
+
+#include "numericConstants.H"
+#include "KokkosUtilities.H"
+#include "kokkosAlgorithms.H"
+#include "stdAlgorithms.H"
+#include "cudaAlgorithms.H"
+
+
+namespace pFlow
+{ 	
+
+inline const size_t maxSizeToSerial__ = 64;
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+int32 count(
+	const ViewType1D<T, properties...>& view,
+	int32 start,
+	int32 end,
+	const T& val)
+{
+	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
+	
+	int32 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);
+}	
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+void fill
+(
+	ViewType1D<T, properties...>& view,
+	range span,
+	T val
+)
+{
+	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
+
+
+	if constexpr( isHostAccessible<ExecutionSpace>())
+	{
+		int32 numElems = span.second-span.first;
+		if( numElems<maxSizeToSerial__)
+		{
+			pFlow::algorithms::STD::fill<T,false>(
+				view.data()+span.first,
+				numElems,
+				val);
+			return;
+		}
+	}
+
+	auto subV = Kokkos::subview(view, span);
+	Kokkos::deep_copy(subV, val);
+}
+
+template<typename T, typename... properties>
+void fill
+(
+	ViewType1D<T, properties...>& view,
+	int32 start,
+	int32 end,
+	T val
+)
+{
+	fill(view, range(start,end),val);
+}
+
+template<
+	typename Type,
+	typename... properties>
+void fillSequence(
+	ViewType1D<Type, properties...>& view,
+	int32 start,
+	int32 end,
+	const Type startVal
+	)
+{
+
+	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 ;
+		}
+	}
+
+	pFlow::algorithms::KOKKOS::fillSequence<Type, ExecutionSpace>(
+			view.data()+start,
+			numElems,
+			startVal);
+
+	return ;
+}
+
+
+template<
+	typename Type,
+	typename... properties,
+	typename indexType,
+	typename... indexProperties>
+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 )
+{
+
+	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;
+		}
+	}
+
+	pFlow::algorithms::KOKKOS::fillSelected<Type, indexType, ExecutionSpace>(
+			view.data(),
+			indices.data(),
+			numElems,
+			val);
+
+	return true;
+}
+
+template<
+	typename Type,
+	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<
+			typename ViewType1D<Type, properties...>::execution_space,
+			typename ViewType1D<indexType, indexProperties...>::memory_space>(),
+		bool> = true )
+{
+
+	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(),
+			vals.data(),
+			numElems
+			);
+
+	return true;
+}
+
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T min( 
+	const ViewType1D<T, properties...>& view,
+	int32 start,
+	int32 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  
+	pFlow::algorithms::KOKKOS::min<T, ExecutionSpace>(
+		view.data()+start,
+		numElems);
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T max( 
+	const ViewType1D<T, properties...>& view,
+	int32 start,
+	int32 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);
+		}
+	}
+
+	return  
+	pFlow::algorithms::KOKKOS::max<T, ExecutionSpace>(
+		view.data()+start,
+		numElems);
+} 
+
+template <
+	typename dType,
+	typename... dProperties,
+	typename sType,
+	typename... sProperties>
+INLINE_FUNCTION_H
+void copy(
+	const ViewType1D<dType, dProperties...>& dst,
+	const ViewType1D<sType, sProperties...>& src
+	)
+{
+	Kokkos::deep_copy(dst,src);
+}
+
+template <
+	typename dType,
+	typename... dProperties,
+	typename sType,
+	typename... sProperties>
+INLINE_FUNCTION_H
+void copy(
+	const ViewType1D<dType, dProperties...>& dst,
+	int32 dStart,
+	const ViewType1D<sType, sProperties...>& src,
+	int32 sStart,
+	int32 sEnd
+	)
+{
+
+	range sSpan(sStart,sEnd);
+	range dSpan(dStart,dStart+(sEnd-sStart));
+	
+	auto srcSub = Kokkos::subview(src, sSpan);
+	auto dstSub = Kokkos::subview(dst, dSpan);
+
+	Kokkos::deep_copy(dstSub,srcSub);
+}
+
+template <
+	typename dType,
+	typename sType,
+	typename... sProperties>
+INLINE_FUNCTION_H
+void getNth(
+	dType& dst,
+	const ViewType1D<sType, sProperties...>& src,
+	const int32 n
+	)
+{
+	range span(n,n+1);
+	auto subV = Kokkos::subview(src, span);
+	hostViewType1D<dType> dstView("getNth",1);
+	Kokkos::deep_copy(dstView,subV);
+	dst = *dstView.data();
+}
+
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+void sort( 
+	ViewType1D<T, properties...>& view,
+	int32 start,
+	int32 end)
+{
+
+	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
+	
+	int32 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;
+		}
+	}
+
+#ifdef __CUDACC__
+	
+	pFlow::algorithms::CUDA::sort<T>(
+		view.data()+start,
+		numElems);
+#else
+	static_assert("sort on device is not defined!");
+
+#endif
+
+	return;
+}
+
+template<typename T, typename... properties, typename CompareFunc>
+INLINE_FUNCTION_H
+void sort( 
+	ViewType1D<T, properties...>& view,
+	int32 start,
+	int32 end,
+	CompareFunc compare)
+{
+
+	using ExecutionSpace = typename ViewType1D<T, properties...>::execution_space;
+	
+	int32 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;
+		}
+	}
+
+#ifdef __CUDACC__
+	
+	pFlow::algorithms::CUDA::sort<T, CompareFunc>(
+		view.data()+start,
+		numElems,
+		compare);
+#else
+	static_assert("sort on device is not defined!");
+
+#endif
+
+	return;
+}
+
+template<
+	typename Type,
+	typename... properties,
+	typename permType,
+	typename... permProperties>
+void permuteSort(
+	const ViewType1D<Type, properties...>& view,
+	int32 start,
+	int32 end,
+	ViewType1D<permType, permProperties...>& permuteView,
+	int32 permStart,
+	typename std::enable_if_t<
+		areAccessible<
+			typename ViewType1D<Type, properties...>::execution_space,
+			typename ViewType1D<permType, permProperties...>::memory_space>(),
+		bool> = true )
+{
+	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;
+		}
+	}
+
+#ifdef __CUDACC__
+	
+	pFlow::algorithms::CUDA::permuteSort(
+		view.data()+start,
+		permuteView.data()+permStart,
+		numElems);
+#else
+	static_assert("sort on device is not defined!");
+
+#endif
+
+}
+
+template<
+	typename Type,
+	typename... properties>
+INLINE_FUNCTION_HD
+int32 binarySearch(
+	const ViewType1D<Type, properties...>& view,
+	int32 start,
+	int32 end,
+	const Type& val)
+{
+	
+	if(end<=start)return -1;
+
+	if(auto res = 
+		pFlow::algorithms::binarySearch(view.data()+start,end-start,val); res>=0) {
+		return res+start;
+	}
+	else{
+		return res;
+	}
+}
+
+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<
+		areAccessible<
+			typename ViewType1D<Type, properties...>::execution_space,
+			typename ViewType1D<dType, dProperties...>::memory_space>(),
+		bool> = true )
+{
+	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>(
+		view.data()+start,
+		dView.data()+dStart,
+		numElems);
+}
+
+
+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 )
+{
+	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;
+		}
+	}
+
+	pFlow::algorithms::KOKKOS::inclusiveScan<Type,dType,ExecutionSpace>(
+		view.data()+start,
+		dView.data()+dStart,
+		numElems);
+}
+
+} // pFlow
+
+
+#endif // Viewalgorithms
diff --git a/src/phasicFlow/Kokkos/baseAlgorithms.H b/src/phasicFlow/Kokkos/baseAlgorithms.H
new file mode 100644
index 00000000..2446509c
--- /dev/null
+++ b/src/phasicFlow/Kokkos/baseAlgorithms.H
@@ -0,0 +1,245 @@
+/*------------------------------- 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 __baseAlgorithms_H__
+#define __baseAlgorithms_H__
+
+
+#include "numericConstants.H"
+
+inline const size_t sizeToSerial__ = 64;
+
+namespace pFlow
+{
+
+// counts the number of elements that matches val
+// the execution space is selected based on the View::execution_spcae 
+/*template<typename T, typename... properties>
+INLINE_FUNCTION_H
+size_t count(
+	const ViewType1D<T, properties...>& view,
+	size_t start,
+	size_t end,
+	const T& val
+	)
+{
+
+	auto RP = Kokkos::RangePolicy<
+		Kokkos::IndexType<size_t>,
+		typename ViewType1D<T, properties...>::execution_space >(start, end);
+
+	size_t totalNum=0;
+	Kokkos::parallel_reduce(
+		"baseAlgorithms-count",
+		RP,
+		LAMBDA_HD(label i, size_t & valueToUpdate){
+			if( equal(view[i], val) ) valueToUpdate += 1;
+		}, totalNum );
+
+	return totalNum;
+}*/
+
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T min( const ViewType1D<T, properties...>& view, size_t start, size_t end ) 
+{
+
+	T minValue = largestPositive<T>();
+
+	auto RP = Kokkos::RangePolicy<
+	Kokkos::IndexType<size_t>,
+	typename ViewType1D<T, properties...>::execution_space >(start, end);
+
+	Kokkos::parallel_reduce("baseAlgorithms-min",
+							RP, 
+							LAMBDA_HD(label i, T& valueToUpdate){
+								valueToUpdate = min(view[i],valueToUpdate);
+							},
+							Kokkos :: Min < T >( minValue )
+							);
+	return minValue;
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T max( const ViewType1D<T, properties...>& view, size_t start, size_t end ) 
+{
+
+	T maxValue = largestNegative<T>();
+
+	auto RP = Kokkos::RangePolicy<
+	Kokkos::IndexType<size_t>,
+	typename ViewType1D<T, properties...>::execution_space >(start, end);
+
+	Kokkos::parallel_reduce("baseAlgorithms-max",
+							RP, 
+							LAMBDA_HD(label i, T& valueToUpdate){
+								valueToUpdate = max(view[i],valueToUpdate);
+							},
+							Kokkos::Max<T>( maxValue )
+							);
+	return maxValue;
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T min_serial(const ViewType1D<T, properties...>& view, size_t start, size_t end)
+{
+	T minValue = largestPositive<T>();
+	for(label i=start; i<end; ++i)
+	{
+		minValue = min(minValue, view[i]);
+	}
+	return minValue;
+}
+
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T max_serial(const ViewType1D<T, properties...>& view, size_t start, size_t end)
+{
+	T maxValue = largestNegative<T>();
+	for(label i=start; i<end; ++i)
+	{
+		maxValue = max(maxValue, view[i]);
+	}
+	return maxValue;
+}
+
+
+template<typename UnaryFunction, typename T, typename... properties>
+void apply_to_each(const ViewType1D<T, properties...>& view, size_t start, size_t end, UnaryFunction func)
+{
+	auto RP = Kokkos::RangePolicy<
+	Kokkos::IndexType<size_t>,
+	typename ViewType1D<T, properties...>::execution_space >(start, end);
+
+	Kokkos::parallel_for("baseAlgorithms-for_each",
+							RP, 
+							LAMBDA_HD(label i){
+								view[i] = func(i);
+							}
+							);
+}
+
+
+template<typename T, typename... properties>
+void insertSetElementH
+(
+	ViewType1D<T, properties...>& view,
+	hostViewType1D<label>& selected,
+	T val
+)
+{
+	
+	for(auto i=0; i<selected.size();++i)
+	{
+		view[selected[i]] = val;
+	}
+
+}
+
+
+template<typename T, typename... properties>
+void insertSetElementH
+(
+	ViewType1D<T, properties...>& view,
+	hostViewType1D<label>& selected,
+	hostViewType1D<T>& vals
+)
+{
+	
+	for(auto i=0; i<selected.size(); ++i)
+	{
+		view[selected[i]] = static_cast<const T&>(vals[i]);
+	}
+}
+
+template<typename T, typename... properties>
+void insertSetElementD
+(
+	ViewType1D<T, properties...>& view,
+	deviceViewType1D<label>& selected,
+	T val
+)
+{
+	auto RP = Kokkos::RangePolicy<
+	Kokkos::IndexType<size_t>,
+	typename ViewType1D<T, properties...>::execution_space >(0, selected.size());
+
+	Kokkos::parallel_for(
+		"baseAlgorithms-insertSetElementD",
+		RP,
+		LAMBDA_D(size_t i) {
+			view[selected[i]] = val; } );
+
+}
+
+template<typename T, typename... properties>
+void insertSetElementD
+(
+	ViewType1D<T, properties...>& view,
+	deviceViewType1D<label>& selected,
+	deviceViewType1D<T>& vals
+)
+{
+	auto RP = Kokkos::RangePolicy<
+	Kokkos::IndexType<size_t>,
+	typename ViewType1D<T, properties...>::execution_space >(0, selected.size());
+
+	Kokkos::parallel_for(
+		"baseAlgorithms-insertSetElementD",
+		RP,
+		LAMBDA_D(size_t i) {
+			view[selected[i]] = vals[i]; } );
+
+}
+
+/*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>
+void fill
+(
+	ViewType3D<T, properties...>& view,
+	range range1,
+	range range2,
+	range range3,
+	T val
+)
+{
+	auto subV = Kokkos::subview(view, range1, range2, range3);
+	Kokkos::deep_copy(subV, val);
+}
+
+}
+
+
+#endif // __VectorSingleMath_H__
diff --git a/src/phasicFlow/Kokkos/baseAlgorithmsFwd.H b/src/phasicFlow/Kokkos/baseAlgorithmsFwd.H
new file mode 100644
index 00000000..c4fa96ad
--- /dev/null
+++ b/src/phasicFlow/Kokkos/baseAlgorithmsFwd.H
@@ -0,0 +1,51 @@
+/*------------------------------- 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... properties>
+void insertSetElementH
+(
+	ViewType1D<T, properties...>& view,
+	hostViewType1D<label>& selected,
+	T val
+);
+
+template<typename T, typename... properties>
+void insertSetElementH
+(
+	ViewType1D<T, properties...>& view,
+	hostViewType1D<label>& selected,
+	hostViewType1D<T>& vals
+);
+
+template<typename T, typename... properties>
+void insertSetElementD
+(
+	ViewType1D<T, properties...>& view,
+	deviceViewType1D<label>& selected,
+	T val
+);
+
+template<typename T, typename... properties>
+void insertSetElementD
+(
+	ViewType1D<T, properties...>& view,
+	deviceViewType1D<label>& selected,
+	deviceViewType1D<T>& vals
+);
\ No newline at end of file
diff --git a/src/phasicFlow/Timer/Timer.C b/src/phasicFlow/Timer/Timer.C
new file mode 100644
index 00000000..160fe163
--- /dev/null
+++ b/src/phasicFlow/Timer/Timer.C
@@ -0,0 +1,97 @@
+/*------------------------------- 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 "Timer.H"
+#include "Timers.H"
+#include "streams.H"
+
+pFlow::Timer::Timer(const word name, Timers* parrent)
+:
+	name_(name),
+	parrent_(parrent)
+{
+	if(parrent_)
+		parrent_->addToList(this);
+}
+
+
+pFlow::Timer::~Timer()
+{
+	if(parrent_)
+	{
+		parrent_->removeFromList(this);
+	}
+}
+
+pFlow::int32 pFlow::Timer::level()const
+{
+	if(parrent_)
+		return parrent_->level()+1;
+	else
+		return 0;
+}
+
+
+bool pFlow::Timer::write(iOstream& os, bool subTree)const
+{
+	
+	if(!timerActive() && !master())return true;
+	
+
+	int32 lvl = level();
+	for(int32 l=1; l<lvl; l++)
+	{	
+		os<<"┃   ";
+	}
+
+	if(lvl>0)
+	{
+
+		if(master())
+			os<<"┣━━ ";
+		else
+			if(lvl==1)
+				os<<"┃└─ ";
+			else
+				os<<" └─ ";
+	}
+	else
+		; //os<<"⊿ ";
+	
+	if(lvl==0)
+		os<<greenColor<<boldChar;
+
+	os<<name_;
+
+	if(timerActive())
+		if(master())
+			os<<" execution time (s): total ("<<
+				totalTime()<<"), av. ("<<
+				averageTime()<<").";
+		else
+			os<<" execution time (s): total ("<<
+				cyanText(totalTime())<<"), av. ("<<
+				cyanText(averageTime())<<").";
+
+	os<<defaultColor;
+	os<<'\n';
+
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/Timer/Timer.H b/src/phasicFlow/Timer/Timer.H
new file mode 100644
index 00000000..e0c805b4
--- /dev/null
+++ b/src/phasicFlow/Timer/Timer.H
@@ -0,0 +1,163 @@
+/*------------------------------- 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 __Timer_H__
+#define __Timer_H__
+
+
+#include <chrono>
+
+#include "types.H"
+
+
+
+namespace pFlow
+{
+
+// forward 
+class Timers;
+
+
+class Timer
+{
+protected:
+
+	using timer = std::chrono::high_resolution_clock;
+
+	// - name for the timer 
+	word name_ = "noNameTimer";
+
+	// start time
+	timer::time_point   start_;
+
+	// number of times start() and end() are called 
+	int32 				numIteration_ = 0;
+
+	// sum of time duratios (in seconds) between all start() and end() calls 
+	real 				accTime_  = 0.0;
+
+	// 
+	real 				lastTime_ = 0.0;
+
+	Timers* 			parrent_ = nullptr;
+
+public:
+
+	TypeName("Timer");
+
+	Timer(){}
+
+	Timer(const word name)
+	:
+		name_(name)
+	{}
+
+	
+	Timer(const word name, Timers* parrent);
+	
+
+	const word& name()const
+	{
+		return name_;
+	}
+
+	virtual ~Timer();
+	
+	virtual void removeParrent()
+	{
+		parrent_ = nullptr;
+	}
+
+	virtual int32 level()const;
+	
+
+	virtual bool master()const
+	{
+		return false;
+	}
+
+	void start()
+	{
+		start_ = timer::now();
+	}
+
+	void end()
+	{
+		auto end = timer::now();
+		lastTime_ =  std::chrono::duration_cast
+			< std::chrono::duration<real> >(end - start_).count();
+		
+		numIteration_++;
+		accTime_ += lastTime_;
+	}
+
+	bool timerActive()const
+	{
+		return numIteration_!=0;
+	}
+
+	real lastTime()const
+	{
+		return lastTime_;
+	}
+
+	real totalTime()const
+	{
+		return accTime_;
+	}
+
+	real averageTime()const
+	{
+
+		return accTime_/max(numIteration_, 1);
+	}
+
+	//// - IO operations
+
+	virtual bool write(iOstream& os, bool subTree)const;
+	
+
+	virtual bool read(iIstream& is)
+	{
+		return true;
+	}
+
+	
+
+
+};
+
+
+inline iOstream& operator<<(iOstream& os, const Timer& t)
+{
+	t.write(os, false);
+	return os;
+}
+
+inline iIstream& operator>>(iIstream& is, Timer& t)
+{
+	return is;
+}
+
+}
+
+
+#endif //__Timer_H__
diff --git a/src/phasicFlow/Timer/Timers.C b/src/phasicFlow/Timer/Timers.C
new file mode 100644
index 00000000..a30e3ead
--- /dev/null
+++ b/src/phasicFlow/Timer/Timers.C
@@ -0,0 +1,40 @@
+/*------------------------------- 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 "Timers.H"
+
+
+bool pFlow::Timers::write(iOstream& os, bool subTree)const
+{
+	if(level() == 0 )os<<"\n";
+	Timer::write(os, subTree);
+	if(subTree)
+	{
+
+		for(const auto& timer:timers_)
+		{
+			timer->write(os, subTree);
+		}
+
+	}
+	if(level() == 0 )os<<"\n";
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/Timer/Timers.H b/src/phasicFlow/Timer/Timers.H
new file mode 100644
index 00000000..f0ae3711
--- /dev/null
+++ b/src/phasicFlow/Timer/Timers.H
@@ -0,0 +1,120 @@
+/*------------------------------- 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 __Timers_H__ 
+#define __Timers_H__
+
+
+#include "Timer.H"
+#include "List.H"
+
+namespace pFlow
+{
+
+class Timers
+:
+	public Timer
+{
+protected:
+
+	List<Timer*> 	timers_;
+
+	int32 			level_ = 0;
+
+public:
+
+	TypeName("Timers");
+
+
+	Timers(const word& name)
+	:
+		Timer(name)
+	{}
+
+	Timers(const word& name, Timers* parrent)
+	:
+		Timer(name, parrent)
+	{
+		if(parrent_)
+		{
+			level_ = parrent_->level()+1;
+		}
+	}
+
+	virtual ~Timers()
+	{
+		for(auto& timer:timers_)
+		{
+			timer->removeParrent();
+		}
+	}
+
+	// add a timer to this node 
+	uniquePtr<Timer> addTimer(const word& name)
+	{
+		return makeUnique<Timer>(name, this);
+	}
+	
+
+	void addToList(Timer* timer)
+	{
+		timers_.push_back(timer);
+	}
+
+	void removeFromList(Timer* timer)
+	{
+		timers_.erase(timers_.find(timer));
+	}
+
+	virtual int32 level()const
+	{
+		return level_;
+	}
+
+	virtual bool master()const
+	{
+		return true;
+	}
+
+	virtual bool write(iOstream& os, bool subTree = true)const;
+	
+
+	virtual bool read(iIstream& is)
+	{
+		return true;
+	}
+
+};
+
+inline iOstream& operator<<(iOstream& os, const Timers& t)
+{
+	t.write(os, true);
+	return os;
+}
+
+inline iIstream& operator>>(iIstream& is, Timers& t)
+{
+	return is;
+}
+
+}
+
+
+#endif //__Timers_H__
diff --git a/src/phasicFlow/algorithms/algorithmFunctions.H b/src/phasicFlow/algorithms/algorithmFunctions.H
new file mode 100644
index 00000000..70ece7aa
--- /dev/null
+++ b/src/phasicFlow/algorithms/algorithmFunctions.H
@@ -0,0 +1,96 @@
+/*------------------------------- 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 __algorithmFunctions_H__
+#define __algorithmFunctions_H__
+
+#include "pFlowMacros.H"
+
+namespace pFlow::algorithms
+{
+
+template<typename T>
+ struct greater
+ {
+   INLINE_FUNCTION_HD
+   bool operator()(const T &lhs, const T &rhs) const {
+   	return lhs > rhs; }
+ };
+
+template<typename T>
+struct less
+{
+   INLINE_FUNCTION_HD
+   bool operator()(const T &lhs, const T &rhs) const {
+    return lhs < rhs; }
+};
+
+
+template<typename T>
+struct maximum
+{
+  INLINE_FUNCTION_HD
+  bool operator()(const T &lhs, const T &rhs) const {
+    return lhs < rhs ? rhs : lhs; }
+};
+
+template<typename T>
+struct minimum
+{
+  INLINE_FUNCTION_HD
+  bool operator()(const T &lhs, const T &rhs) const {
+      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_H__
\ No newline at end of file
diff --git a/src/phasicFlow/algorithms/cudaAlgorithms.H b/src/phasicFlow/algorithms/cudaAlgorithms.H
new file mode 100644
index 00000000..b6621980
--- /dev/null
+++ b/src/phasicFlow/algorithms/cudaAlgorithms.H
@@ -0,0 +1,182 @@
+/*------------------------------- 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 __cudaAlgorithms_H__ 
+#define __cudaAlgorithms_H__
+
+
+#ifdef __CUDACC__
+
+#include <thrust/fill.h>
+#include <thrust/count.h>
+#include <thrust/scan.h>
+#include <thrust/sort.h>
+#include <thrust/extrema.h>
+#include <thrust/execution_policy.h>
+
+
+#include "pFlowMacros.H"
+#include "algorithmFunctions.H"
+#include "types.H"
+
+namespace pFlow::algorithms::CUDA
+{
+
+template<typename Type>
+INLINE_FUNCTION_H
+int32 count(const Type* first, int32 numElems, const Type& val)
+{
+	return thrust::count_if(
+			thrust::device,
+			first, first+numElems,
+			LAMBDA_HD(const Type& check){ return equal(check,val);} );
+}
+
+
+template<typename Type>
+INLINE_FUNCTION_H
+void fill(Type* first, int32 numElems, const Type& val)
+{
+	thrust::fill(thrust::device, first, first+numElems, val);
+}
+
+template<typename Type>
+INLINE_FUNCTION_H
+void fillSequence(Type* first, int32 numElems, const Type& firstVal)
+{
+	
+	thrust::for_each_n(
+		thrust::device,
+		first,
+		numElems,
+		LAMBDA_HD(Type& ref){ ref = firstVal+(&ref - first);});
+}
+
+template<typename Type, typename indexType>
+INLINE_FUNCTION_H
+void fillSelected(Type* first, const indexType* indices, const int32 numElems, const Type val)
+{
+		
+	thrust::for_each_n(
+			thrust::device,
+			indices,
+			numElems,
+			LAMBDA_HD(indexType i){
+				first[i] = val;
+			});
+
+}
+
+template<typename Type>
+INLINE_FUNCTION_H
+Type max(const Type* first, int32 numElems)
+{
+	Type resH;
+	auto* resD = thrust::max_element(
+				thrust::device,
+				first,
+				first+numElems,
+				less<Type>());
+	
+	cudaMemcpy(&resH, resD, sizeof(Type),cudaMemcpyDeviceToHost);
+	return resH;
+}
+
+template<typename Type>
+INLINE_FUNCTION_H
+Type min(const Type* first, int32 numElems)
+{
+	Type resH;
+	auto* resD = thrust::min_element(
+				thrust::device,
+				first,
+				first+numElems,
+				less<Type>());
+	cudaMemcpy(&resH, resD, sizeof(Type),cudaMemcpyDeviceToHost);
+	return resH;
+}
+
+template<typename Type>
+INLINE_FUNCTION_H
+void sort(Type* first, int32 numElems)
+{
+	
+	thrust::sort(
+		thrust::device,
+		first,
+		first+numElems,
+		less<Type>());
+	
+}
+
+template<typename Type, typename CompareFunc>
+INLINE_FUNCTION_H
+void sort(Type* first, int32 numElems, CompareFunc compare)
+{
+	
+	thrust::sort(
+		thrust::device,
+		first,
+		first+numElems,
+		compare);
+	
+}
+
+template<typename Type, typename PermuteType>
+INLINE_FUNCTION_H
+void permuteSort(const Type* first, PermuteType* pFirst, int32 numElems)
+{
+	
+	fillSequence(pFirst, numElems, static_cast<PermuteType>(0));
+	thrust::sort(
+		thrust::device,
+		pFirst,
+		pFirst+numElems,
+		LAMBDA_HD(const PermuteType& lhs, const PermuteType& rhs){
+			return first[lhs]<first[rhs]; });
+}
+
+
+template<typename Type, typename DestType>
+void exclusiveScan(Type* first, DestType* dFirst, int32 numElems)
+{	
+	thrust::exclusive_scan(
+		thrust::device,
+		first, first+numElems,
+		dFirst, 0);	
+}
+
+template<typename Type, typename DestType>
+void inclusiveScan(Type* first, DestType* dFirst, int32 numElems)
+{
+	thrust::inclusive_scan(
+			thrust::device,
+			first, first+numElems,
+			dFirst);
+}
+
+} // end of namespace 
+
+
+#endif //__CUDA__
+
+
+#endif //__cudaAlgorithms_H__
\ No newline at end of file
diff --git a/src/phasicFlow/algorithms/kokkosAlgorithms.H b/src/phasicFlow/algorithms/kokkosAlgorithms.H
new file mode 100644
index 00000000..be5101cc
--- /dev/null
+++ b/src/phasicFlow/algorithms/kokkosAlgorithms.H
@@ -0,0 +1,188 @@
+/*------------------------------- 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 __kokkosAlgorithms_H__ 
+#define __kokkosAlgorithms_H__
+
+#include "KokkosTypes.H"
+
+
+namespace pFlow::algorithms::KOKKOS
+{
+
+template<typename Type, typename ExecutionSpace>
+INLINE_FUNCTION_H
+int32 count(const Type* first, int32 numElems, const Type& val)
+{
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+	int32 num = 0;
+	Kokkos::parallel_reduce("count",
+							policy(0, numElems),
+							LAMBDA_HD(int32 i, int32& updateVal){
+								if(equal(first[i],val)) updateVal++;
+							},
+							num);
+	return num;
+}
+
+// fill should be done using deep_copy by kokkos
+//void fill(Type* first, int32 numElems, const Type& val);
+
+template<typename Type, typename ExecutionSpace>
+INLINE_FUNCTION_H
+void fillSequence(Type* first, int32 numElems, const Type& firstVal)
+{
+	
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+
+	Kokkos::parallel_for(
+		"fillSequence",
+		policy(0, numElems),
+		LAMBDA_HD(int32 i){ 
+			first[i] = firstVal+i;
+		});
+	Kokkos::fence();
+}
+
+template<typename Type, typename indexType, typename ExecutionSpace>
+INLINE_FUNCTION_H
+void fillSelected(Type* first, const indexType* indices, const int32 numElems, const Type val)
+{
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+	Kokkos::parallel_for(
+		"fillSelected",
+		policy(0,numElems),
+		LAMBDA_HD(int32 i){
+			first[indices[i]]= val;
+		});
+	Kokkos::fence();
+}
+
+template<typename Type, typename indexType, typename ExecutionSpace>
+INLINE_FUNCTION_H
+void fillSelected(Type* first, const indexType* indices, const Type* vals, const int32 numElems)
+{
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+
+	Kokkos::parallel_for(
+		"fillSelected",
+		policy(0,numElems),
+		LAMBDA_HD(int32 i){
+			first[indices[i]]= vals[i];
+		});
+	Kokkos::fence();
+}
+
+template<typename Type, typename ExecutionSpace>
+INLINE_FUNCTION_H
+Type max(const Type* first, int32 numElems)
+{
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+	Type maxElement=0;
+
+	Kokkos::parallel_reduce(
+		"max",
+		policy(0, numElems),
+		LAMBDA_HD(int32 i, Type& maxUpdate){
+			if(maxUpdate<first[i]) maxUpdate = first[i];
+		},
+		Kokkos::Max<Type>(maxElement));
+
+	return maxElement;
+}
+
+template<typename Type, typename ExecutionSpace>
+INLINE_FUNCTION_H
+Type min(const Type* first, int32 numElems)
+{
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+	Type minElement;
+
+	Kokkos::parallel_reduce(
+		"min",
+		policy(0, numElems),
+		LAMBDA_HD(int32 i, Type& minUpdate){
+			if(first[i] < minUpdate) minUpdate = first[i];
+		},
+		Kokkos::Min<Type>(minElement));
+
+	return minElement;
+}
+
+// we either use CUDA or STD srots
+//void sort(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)
+{	
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+
+	Kokkos::parallel_scan(
+		"exclusiveScan",
+		policy(0, numElems),
+		LAMBDA_HD(const int32 i, DestType& valToUpdate, const bool final)
+		{
+			const int32 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)
+{
+	using policy = Kokkos::RangePolicy<
+			ExecutionSpace,
+			Kokkos::IndexType<int32> >;
+
+	Kokkos::parallel_scan(
+		"inclusiveScan",
+		policy(0, numElems),
+		LAMBDA_HD(const int32 i, int32& valToUpdate, const bool final)
+		{
+			const int32 val = first[i];
+			valToUpdate += val;
+			if(final)
+				dFirst[i] = valToUpdate;
+		});
+}
+
+} //pFlow::algorithms::KOKKOS
+
+
+#endif //__kokkosAlgorithms_H__
diff --git a/src/phasicFlow/algorithms/stdAlgorithms.H b/src/phasicFlow/algorithms/stdAlgorithms.H
new file mode 100644
index 00000000..2754eec1
--- /dev/null
+++ b/src/phasicFlow/algorithms/stdAlgorithms.H
@@ -0,0 +1,243 @@
+/*------------------------------- 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 __stdAlgorithms_H__ 
+#define __stdAlgorithms_H__
+
+#include <algorithm>
+#include <execution>
+
+#include "pFlowMacros.H"
+#include "algorithmFunctions.H"
+#include "types.H"
+
+namespace pFlow::algorithms::STD
+{
+
+template<typename Type, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+int32 count(const Type* first, int32 numElems, const Type& val)
+{
+	if constexpr (useParallel)
+		return std::count_if(
+			std::execution::par_unseq,
+			first, first+numElems,
+			[=](const Type& check){ return equal(check,val);} );
+	else
+		return std::count_if(
+			first, first+numElems,
+			[=](const Type& check){ return equal(check,val);} );
+	return 0; // for nvcc
+}
+
+
+template<typename Type, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+void fill(Type* first, int32 numElems, const Type& val)
+{
+	if constexpr (useParallel)
+		std::fill(std::execution::par_unseq, first, first+numElems, val);
+	else
+		std::fill(first, first+numElems, val);
+}
+
+template<typename Type, typename indexType, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+void fillSelected(Type* first, const indexType* indices, const int32 numElems, const Type val)
+{
+	if constexpr(useParallel)
+	{
+		std::for_each_n(
+			std::execution::par_unseq,
+			indices,
+			numElems,
+			[=](indexType i){
+				first[i] = val;
+			});
+	}
+	else
+	{
+		std::for_each_n(
+			indices,
+			numElems,
+			[=](indexType i){
+				first[i] = val;
+			});
+	}
+}
+
+template<typename Type, typename indexType, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+void fillSelected(Type* first, const indexType* indices, const Type* vals, const int32 numElems)
+{
+	for(indexType i=0; i<numElems; i++)
+	{
+		first[indices[i]]=vals[i]; 
+	}
+}
+
+template<typename Type, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+void fillSequence(Type* first, int32 numElems, const Type& firstVal)
+{
+	if constexpr (useParallel)
+		std::for_each_n(
+			std::execution::par_unseq,
+			first,
+			numElems,
+			[=](Type& ref){ ref = firstVal+std::distance(first,&ref);});
+	else
+		std::iota(first, first+numElems, firstVal);
+}
+
+template<typename Type, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+Type max(const Type* first, int32 numElems)
+{
+	if constexpr(useParallel)
+		return *std::max_element(
+				std::execution::par_unseq,
+				first,
+				first+numElems,
+				less<Type>());
+	else
+		return *std::max_element(
+				first,
+				first+numElems,
+				less<Type>());
+}
+
+template<typename Type, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+Type min(const Type* first, int32 numElems)
+{
+	if constexpr(useParallel)
+		return *(std::min_element(
+				std::execution::par_unseq,
+				first,
+				first+numElems,
+				less<Type>()));
+	else
+		return *(std::min_element(
+				first,
+				first+numElems,
+				less<Type>()));
+}
+
+template<typename Type, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+void sort(Type* first, int32 numElems)
+{
+	if constexpr(useParallel)
+	{
+		std::sort(
+			std::execution::par,
+			first,
+			first+numElems,
+			less<Type>());
+	}
+	else
+	{
+		std::sort(
+			first,
+			first+numElems,
+			less<Type>());
+	}
+}
+
+template<typename Type, typename CompareFunc, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+void sort(Type* first, int32 numElems, CompareFunc compare)
+{
+	if constexpr(useParallel)
+	{
+		std::sort(
+			std::execution::par_unseq,
+			first,
+			first+numElems,
+			compare);
+	}
+	else
+	{
+		std::sort(
+			first,
+			first+numElems,
+			compare);
+	}
+}
+
+template<typename Type, typename PermuteType, bool useParallel = useStdParallel__>
+INLINE_FUNCTION_H
+void permuteSort(const Type* first, PermuteType* pFirst, int32 numElems)
+{
+	struct compOperator
+	{
+		const Type* first_;
+		bool operator()(const PermuteType& lhs, const PermuteType& rhs)const {
+			return first_[lhs]<first_[rhs]; }
+	};
+
+	compOperator compare{first};
+	fillSequence<Type, useParallel>(pFirst, numElems, static_cast<PermuteType>(0));
+	sort<Type, compOperator, useParallel>(pFirst, numElems, compare);
+}
+
+
+template<typename Type, typename DestType, bool useParallel = useStdParallel__>
+void exclusiveScan(Type* first, DestType* dFirst, int32 numElems)
+{
+	if constexpr (useParallel)
+	{
+		//// - this does not work when first and dFirst point to the same location
+		std::exclusive_scan(
+			//std::execution::par_unseq,
+			first, first+numElems,
+			dFirst, 0);
+	}
+	else
+	{
+		std::exclusive_scan(
+			first, first+numElems,
+			dFirst,0);
+	}
+}
+
+template<typename Type, typename DestType, bool useParallel = useStdParallel__>
+void inclusiveScan(Type* first, DestType* dFirst, int32 numElems)
+{
+	if constexpr (useParallel)
+	{
+		std::inclusive_scan(
+			std::execution::par_unseq,
+			first, first+numElems,
+			dFirst);
+	}
+	else
+	{
+		std::inclusive_scan(
+			first, first+numElems,
+			dFirst);
+	}
+}
+
+}
+
+
+#endif //__stdAlgorithms_H__
\ No newline at end of file
diff --git a/src/phasicFlow/commandLine/CLI/App.hpp b/src/phasicFlow/commandLine/CLI/App.hpp
new file mode 100644
index 00000000..9d3b3c3e
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/App.hpp
@@ -0,0 +1,3201 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <algorithm>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <numeric>
+#include <set>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:end]
+
+// CLI Library includes
+#include "ConfigFwd.hpp"
+#include "Error.hpp"
+#include "FormatterFwd.hpp"
+#include "Macros.hpp"
+#include "Option.hpp"
+#include "Split.hpp"
+#include "StringTools.hpp"
+#include "TypeTools.hpp"
+
+namespace CLI {
+// [CLI11:app_hpp:verbatim]
+
+#ifndef CLI11_PARSE
+#define CLI11_PARSE(app, argc, argv)                                                                                   \
+    try {                                                                                                              \
+        (app).parse((argc), (argv));                                                                                   \
+    } catch(const CLI::ParseError &e) {                                                                                \
+        return (app).exit(e);                                                                                          \
+    }
+#endif
+
+namespace detail {
+enum class Classifier { NONE, POSITIONAL_MARK, SHORT, LONG, WINDOWS_STYLE, SUBCOMMAND, SUBCOMMAND_TERMINATOR };
+struct AppFriend;
+}  // namespace detail
+
+namespace FailureMessage {
+std::string simple(const App *app, const Error &e);
+std::string help(const App *app, const Error &e);
+}  // namespace FailureMessage
+
+/// enumeration of modes of how to deal with extras in config files
+
+enum class config_extras_mode : char { error = 0, ignore, ignore_all, capture };
+
+class App;
+
+using App_p = std::shared_ptr<App>;
+
+class Option_group;
+/// Creates a command line program, with very few defaults.
+/** To use, create a new `Program()` instance with `argc`, `argv`, and a help description. The templated
+ *  add_option methods make it easy to prepare options. Remember to call `.start` before starting your
+ * program, so that the options can be evaluated and the help option doesn't accidentally run your program. */
+class App {
+    friend Option;
+    friend detail::AppFriend;
+
+  protected:
+    // This library follows the Google style guide for member names ending in underscores
+
+    /// @name Basics
+    ///@{
+
+    /// Subcommand name or program name (from parser if name is empty)
+    std::string name_{};
+
+    /// Description of the current program/subcommand
+    std::string description_{};
+
+    /// If true, allow extra arguments (ie, don't throw an error). INHERITABLE
+    bool allow_extras_{false};
+
+    /// If ignore, allow extra arguments in the ini file (ie, don't throw an error). INHERITABLE
+    /// if error error on an extra argument, and if capture feed it to the app
+    config_extras_mode allow_config_extras_{config_extras_mode::ignore};
+
+    ///  If true, return immediately on an unrecognized option (implies allow_extras) INHERITABLE
+    bool prefix_command_{false};
+
+    /// If set to true the name was automatically generated from the command line vs a user set name
+    bool has_automatic_name_{false};
+
+    /// If set to true the subcommand is required to be processed and used, ignored for main app
+    bool required_{false};
+
+    /// If set to true the subcommand is disabled and cannot be used, ignored for main app
+    bool disabled_{false};
+
+    /// Flag indicating that the pre_parse_callback has been triggered
+    bool pre_parse_called_{false};
+
+    /// Flag indicating that the callback for the subcommand should be executed immediately on parse completion which is
+    /// before help or ini files are processed. INHERITABLE
+    bool immediate_callback_{false};
+
+    /// This is a function that runs prior to the start of parsing
+    std::function<void(std::size_t)> pre_parse_callback_{};
+
+    /// This is a function that runs when parsing has finished.
+    std::function<void()> parse_complete_callback_{};
+
+    /// This is a function that runs when all processing has completed
+    std::function<void()> final_callback_{};
+
+    ///@}
+    /// @name Options
+    ///@{
+
+    /// The default values for options, customizable and changeable INHERITABLE
+    OptionDefaults option_defaults_{};
+
+    /// The list of options, stored locally
+    std::vector<Option_p> options_{};
+
+    ///@}
+    /// @name Help
+    ///@{
+
+    /// Footer to put after all options in the help output INHERITABLE
+    std::string footer_{};
+
+    /// This is a function that generates a footer to put after all other options in help output
+    std::function<std::string()> footer_callback_{};
+
+    /// A pointer to the help flag if there is one INHERITABLE
+    Option *help_ptr_{nullptr};
+
+    /// A pointer to the help all flag if there is one INHERITABLE
+    Option *help_all_ptr_{nullptr};
+
+    /// A pointer to a version flag if there is one
+    Option *version_ptr_{nullptr};
+
+    /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
+    std::shared_ptr<FormatterBase> formatter_{new Formatter()};
+
+    /// The error message printing function INHERITABLE
+    std::function<std::string(const App *, const Error &e)> failure_message_{FailureMessage::simple};
+
+    ///@}
+    /// @name Parsing
+    ///@{
+
+    using missing_t = std::vector<std::pair<detail::Classifier, std::string>>;
+
+    /// Pair of classifier, string for missing options. (extra detail is removed on returning from parse)
+    ///
+    /// This is faster and cleaner than storing just a list of strings and reparsing. This may contain the -- separator.
+    missing_t missing_{};
+
+    /// This is a list of pointers to options with the original parse order
+    std::vector<Option *> parse_order_{};
+
+    /// This is a list of the subcommands collected, in order
+    std::vector<App *> parsed_subcommands_{};
+
+    /// this is a list of subcommands that are exclusionary to this one
+    std::set<App *> exclude_subcommands_{};
+
+    /// This is a list of options which are exclusionary to this App, if the options were used this subcommand should
+    /// not be
+    std::set<Option *> exclude_options_{};
+
+    /// this is a list of subcommands or option groups that are required by this one, the list is not mutual,  the
+    /// listed subcommands do not require this one
+    std::set<App *> need_subcommands_{};
+
+    /// This is a list of options which are required by this app, the list is not mutual, listed options do not need the
+    /// subcommand not be
+    std::set<Option *> need_options_{};
+
+    ///@}
+    /// @name Subcommands
+    ///@{
+
+    /// Storage for subcommand list
+    std::vector<App_p> subcommands_{};
+
+    /// If true, the program name is not case sensitive INHERITABLE
+    bool ignore_case_{false};
+
+    /// If true, the program should ignore underscores INHERITABLE
+    bool ignore_underscore_{false};
+
+    /// Allow subcommand fallthrough, so that parent commands can collect commands after subcommand.  INHERITABLE
+    bool fallthrough_{false};
+
+    /// Allow '/' for options for Windows like options. Defaults to true on Windows, false otherwise. INHERITABLE
+    bool allow_windows_style_options_{
+#ifdef _WIN32
+        true
+#else
+        false
+#endif
+    };
+    /// specify that positional arguments come at the end of the argument sequence not inheritable
+    bool positionals_at_end_{false};
+
+    enum class startup_mode : char { stable, enabled, disabled };
+    /// specify the startup mode for the app
+    /// stable=no change, enabled= startup enabled, disabled=startup disabled
+    startup_mode default_startup{startup_mode::stable};
+
+    /// if set to true the subcommand can be triggered via configuration files INHERITABLE
+    bool configurable_{false};
+
+    /// If set to true positional options are validated before assigning INHERITABLE
+    bool validate_positionals_{false};
+
+    /// indicator that the subcommand is silent and won't show up in subcommands list
+    /// This is potentially useful as a modifier subcommand
+    bool silent_{false};
+
+    /// Counts the number of times this command/subcommand was parsed
+    std::uint32_t parsed_{0U};
+
+    /// Minimum required subcommands (not inheritable!)
+    std::size_t require_subcommand_min_{0};
+
+    /// Max number of subcommands allowed (parsing stops after this number). 0 is unlimited INHERITABLE
+    std::size_t require_subcommand_max_{0};
+
+    /// Minimum required options (not inheritable!)
+    std::size_t require_option_min_{0};
+
+    /// Max number of options allowed. 0 is unlimited (not inheritable)
+    std::size_t require_option_max_{0};
+
+    /// A pointer to the parent if this is a subcommand
+    App *parent_{nullptr};
+
+    /// The group membership INHERITABLE
+    std::string group_{"Subcommands"};
+
+    /// Alias names for the subcommand
+    std::vector<std::string> aliases_{};
+
+    ///@}
+    /// @name Config
+    ///@{
+
+    /// Pointer to the config option
+    Option *config_ptr_{nullptr};
+
+    /// This is the formatter for help printing. Default provided. INHERITABLE (same pointer)
+    std::shared_ptr<Config> config_formatter_{new ConfigTOML()};
+
+    ///@}
+
+    /// Special private constructor for subcommand
+    App(std::string app_description, std::string app_name, App *parent)
+        : name_(std::move(app_name)), description_(std::move(app_description)), parent_(parent) {
+        // Inherit if not from a nullptr
+        if(parent_ != nullptr) {
+            if(parent_->help_ptr_ != nullptr)
+                set_help_flag(parent_->help_ptr_->get_name(false, true), parent_->help_ptr_->get_description());
+            if(parent_->help_all_ptr_ != nullptr)
+                set_help_all_flag(parent_->help_all_ptr_->get_name(false, true),
+                                  parent_->help_all_ptr_->get_description());
+
+            /// OptionDefaults
+            option_defaults_ = parent_->option_defaults_;
+
+            // INHERITABLE
+            failure_message_ = parent_->failure_message_;
+            allow_extras_ = parent_->allow_extras_;
+            allow_config_extras_ = parent_->allow_config_extras_;
+            prefix_command_ = parent_->prefix_command_;
+            immediate_callback_ = parent_->immediate_callback_;
+            ignore_case_ = parent_->ignore_case_;
+            ignore_underscore_ = parent_->ignore_underscore_;
+            fallthrough_ = parent_->fallthrough_;
+            validate_positionals_ = parent_->validate_positionals_;
+            configurable_ = parent_->configurable_;
+            allow_windows_style_options_ = parent_->allow_windows_style_options_;
+            group_ = parent_->group_;
+            footer_ = parent_->footer_;
+            formatter_ = parent_->formatter_;
+            config_formatter_ = parent_->config_formatter_;
+            require_subcommand_max_ = parent_->require_subcommand_max_;
+        }
+    }
+
+  public:
+    /// @name Basic
+    ///@{
+
+    /// Create a new program. Pass in the same arguments as main(), along with a help string.
+    explicit App(std::string app_description = "", std::string app_name = "")
+        : App(app_description, app_name, nullptr) {
+        set_help_flag("-h,--help", "Print this help message and exit");
+    }
+
+    App(const App &) = delete;
+    App &operator=(const App &) = delete;
+
+    /// virtual destructor
+    virtual ~App() = default;
+
+    /// Set a callback for execution when all parsing and processing has completed
+    ///
+    /// Due to a bug in c++11,
+    /// it is not possible to overload on std::function (fixed in c++14
+    /// and backported to c++11 on newer compilers). Use capture by reference
+    /// to get a pointer to App if needed.
+    App *callback(std::function<void()> app_callback) {
+        if(immediate_callback_) {
+            parse_complete_callback_ = std::move(app_callback);
+        } else {
+            final_callback_ = std::move(app_callback);
+        }
+        return this;
+    }
+
+    /// Set a callback for execution when all parsing and processing has completed
+    /// aliased as callback
+    App *final_callback(std::function<void()> app_callback) {
+        final_callback_ = std::move(app_callback);
+        return this;
+    }
+
+    /// Set a callback to execute when parsing has completed for the app
+    ///
+    App *parse_complete_callback(std::function<void()> pc_callback) {
+        parse_complete_callback_ = std::move(pc_callback);
+        return this;
+    }
+
+    /// Set a callback to execute prior to parsing.
+    ///
+    App *preparse_callback(std::function<void(std::size_t)> pp_callback) {
+        pre_parse_callback_ = std::move(pp_callback);
+        return this;
+    }
+
+    /// Set a name for the app (empty will use parser to set the name)
+    App *name(std::string app_name = "") {
+
+        if(parent_ != nullptr) {
+            auto oname = name_;
+            name_ = app_name;
+            auto &res = _compare_subcommand_names(*this, *_get_fallthrough_parent());
+            if(!res.empty()) {
+                name_ = oname;
+                throw(OptionAlreadyAdded(app_name + " conflicts with existing subcommand names"));
+            }
+        } else {
+            name_ = app_name;
+        }
+        has_automatic_name_ = false;
+        return this;
+    }
+
+    /// Set an alias for the app
+    App *alias(std::string app_name) {
+        if(app_name.empty() || !detail::valid_alias_name_string(app_name)) {
+            throw IncorrectConstruction("Aliases may not be empty or contain newlines or null characters");
+        }
+        if(parent_ != nullptr) {
+            aliases_.push_back(app_name);
+            auto &res = _compare_subcommand_names(*this, *_get_fallthrough_parent());
+            if(!res.empty()) {
+                aliases_.pop_back();
+                throw(OptionAlreadyAdded("alias already matches an existing subcommand: " + app_name));
+            }
+        } else {
+            aliases_.push_back(app_name);
+        }
+
+        return this;
+    }
+
+    /// Remove the error when extras are left over on the command line.
+    App *allow_extras(bool allow = true) {
+        allow_extras_ = allow;
+        return this;
+    }
+
+    /// Remove the error when extras are left over on the command line.
+    App *required(bool require = true) {
+        required_ = require;
+        return this;
+    }
+
+    /// Disable the subcommand or option group
+    App *disabled(bool disable = true) {
+        disabled_ = disable;
+        return this;
+    }
+
+    /// silence the subcommand from showing up in the processed list
+    App *silent(bool silence = true) {
+        silent_ = silence;
+        return this;
+    }
+
+    /// Set the subcommand to be disabled by default, so on clear(), at the start of each parse it is disabled
+    App *disabled_by_default(bool disable = true) {
+        if(disable) {
+            default_startup = startup_mode::disabled;
+        } else {
+            default_startup = (default_startup == startup_mode::enabled) ? startup_mode::enabled : startup_mode::stable;
+        }
+        return this;
+    }
+
+    /// Set the subcommand to be enabled by default, so on clear(), at the start of each parse it is enabled (not
+    /// disabled)
+    App *enabled_by_default(bool enable = true) {
+        if(enable) {
+            default_startup = startup_mode::enabled;
+        } else {
+            default_startup =
+                (default_startup == startup_mode::disabled) ? startup_mode::disabled : startup_mode::stable;
+        }
+        return this;
+    }
+
+    /// Set the subcommand callback to be executed immediately on subcommand completion
+    App *immediate_callback(bool immediate = true) {
+        immediate_callback_ = immediate;
+        if(immediate_callback_) {
+            if(final_callback_ && !(parse_complete_callback_)) {
+                std::swap(final_callback_, parse_complete_callback_);
+            }
+        } else if(!(final_callback_) && parse_complete_callback_) {
+            std::swap(final_callback_, parse_complete_callback_);
+        }
+        return this;
+    }
+
+    /// Set the subcommand to validate positional arguments before assigning
+    App *validate_positionals(bool validate = true) {
+        validate_positionals_ = validate;
+        return this;
+    }
+
+    /// ignore extras in config files
+    App *allow_config_extras(bool allow = true) {
+        if(allow) {
+            allow_config_extras_ = config_extras_mode::capture;
+            allow_extras_ = true;
+        } else {
+            allow_config_extras_ = config_extras_mode::error;
+        }
+        return this;
+    }
+
+    /// ignore extras in config files
+    App *allow_config_extras(config_extras_mode mode) {
+        allow_config_extras_ = mode;
+        return this;
+    }
+
+    /// Do not parse anything after the first unrecognized option and return
+    App *prefix_command(bool allow = true) {
+        prefix_command_ = allow;
+        return this;
+    }
+
+    /// Ignore case. Subcommands inherit value.
+    App *ignore_case(bool value = true) {
+        if(value && !ignore_case_) {
+            ignore_case_ = true;
+            auto *p = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
+            auto &match = _compare_subcommand_names(*this, *p);
+            if(!match.empty()) {
+                ignore_case_ = false;  // we are throwing so need to be exception invariant
+                throw OptionAlreadyAdded("ignore case would cause subcommand name conflicts: " + match);
+            }
+        }
+        ignore_case_ = value;
+        return this;
+    }
+
+    /// Allow windows style options, such as `/opt`. First matching short or long name used. Subcommands inherit
+    /// value.
+    App *allow_windows_style_options(bool value = true) {
+        allow_windows_style_options_ = value;
+        return this;
+    }
+
+    /// Specify that the positional arguments are only at the end of the sequence
+    App *positionals_at_end(bool value = true) {
+        positionals_at_end_ = value;
+        return this;
+    }
+
+    /// Specify that the subcommand can be triggered by a config file
+    App *configurable(bool value = true) {
+        configurable_ = value;
+        return this;
+    }
+
+    /// Ignore underscore. Subcommands inherit value.
+    App *ignore_underscore(bool value = true) {
+        if(value && !ignore_underscore_) {
+            ignore_underscore_ = true;
+            auto *p = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
+            auto &match = _compare_subcommand_names(*this, *p);
+            if(!match.empty()) {
+                ignore_underscore_ = false;
+                throw OptionAlreadyAdded("ignore underscore would cause subcommand name conflicts: " + match);
+            }
+        }
+        ignore_underscore_ = value;
+        return this;
+    }
+
+    /// Set the help formatter
+    App *formatter(std::shared_ptr<FormatterBase> fmt) {
+        formatter_ = fmt;
+        return this;
+    }
+
+    /// Set the help formatter
+    App *formatter_fn(std::function<std::string(const App *, std::string, AppFormatMode)> fmt) {
+        formatter_ = std::make_shared<FormatterLambda>(fmt);
+        return this;
+    }
+
+    /// Set the config formatter
+    App *config_formatter(std::shared_ptr<Config> fmt) {
+        config_formatter_ = fmt;
+        return this;
+    }
+
+    /// Check to see if this subcommand was parsed, true only if received on command line.
+    bool parsed() const { return parsed_ > 0; }
+
+    /// Get the OptionDefault object, to set option defaults
+    OptionDefaults *option_defaults() { return &option_defaults_; }
+
+    ///@}
+    /// @name Adding options
+    ///@{
+
+    /// Add an option, will automatically understand the type for common types.
+    ///
+    /// To use, create a variable with the expected type, and pass it in after the name.
+    /// After start is called, you can use count to see if the value was passed, and
+    /// the value will be initialized properly. Numbers, vectors, and strings are supported.
+    ///
+    /// ->required(), ->default, and the validators are options,
+    /// The positional options take an optional number of arguments.
+    ///
+    /// For example,
+    ///
+    ///     std::string filename;
+    ///     program.add_option("filename", filename, "description of filename");
+    ///
+    Option *add_option(std::string option_name,
+                       callback_t option_callback,
+                       std::string option_description = "",
+                       bool defaulted = false,
+                       std::function<std::string()> func = {}) {
+        Option myopt{option_name, option_description, option_callback, this};
+
+        if(std::find_if(std::begin(options_), std::end(options_), [&myopt](const Option_p &v) {
+               return *v == myopt;
+           }) == std::end(options_)) {
+            options_.emplace_back();
+            Option_p &option = options_.back();
+            option.reset(new Option(option_name, option_description, option_callback, this));
+
+            // Set the default string capture function
+            option->default_function(func);
+
+            // For compatibility with CLI11 1.7 and before, capture the default string here
+            if(defaulted)
+                option->capture_default_str();
+
+            // Transfer defaults to the new option
+            option_defaults_.copy_to(option.get());
+
+            // Don't bother to capture if we already did
+            if(!defaulted && option->get_always_capture_default())
+                option->capture_default_str();
+
+            return option.get();
+        }
+        // we know something matches now find what it is so we can produce more error information
+        for(auto &opt : options_) {
+            auto &matchname = opt->matching_name(myopt);
+            if(!matchname.empty()) {
+                throw(OptionAlreadyAdded("added option matched existing option name: " + matchname));
+            }
+        }
+        // this line should not be reached the above loop should trigger the throw
+        throw(OptionAlreadyAdded("added option matched existing option name"));  // LCOV_EXCL_LINE
+    }
+
+    /// Add option for assigning to a variable
+    template <typename AssignTo,
+              typename ConvertTo = AssignTo,
+              enable_if_t<!std::is_const<ConvertTo>::value, detail::enabler> = detail::dummy>
+    Option *add_option(std::string option_name,
+                       AssignTo &variable,  ///< The variable to set
+                       std::string option_description = "") {
+
+        auto fun = [&variable](const CLI::results_t &res) {  // comment for spacing
+            return detail::lexical_conversion<AssignTo, ConvertTo>(res, variable);
+        };
+
+        Option *opt = add_option(option_name, fun, option_description, false, [&variable]() {
+            return CLI::detail::checked_to_string<AssignTo, ConvertTo>(variable);
+        });
+        opt->type_name(detail::type_name<ConvertTo>());
+        // these must be actual lvalues since (std::max) sometimes is defined in terms of references and references
+        // to structs used in the evaluation can be temporary so that would cause issues.
+        auto Tcount = detail::type_count<AssignTo>::value;
+        auto XCcount = detail::type_count<ConvertTo>::value;
+        opt->type_size(detail::type_count_min<ConvertTo>::value, (std::max)(Tcount, XCcount));
+        opt->expected(detail::expected_count<ConvertTo>::value);
+        opt->run_callback_for_default();
+        return opt;
+    }
+
+    /// Add option for assigning to a variable
+    template <typename AssignTo, enable_if_t<!std::is_const<AssignTo>::value, detail::enabler> = detail::dummy>
+    Option *add_option_no_stream(std::string option_name,
+                                 AssignTo &variable,  ///< The variable to set
+                                 std::string option_description = "") {
+
+        auto fun = [&variable](const CLI::results_t &res) {  // comment for spacing
+            return detail::lexical_conversion<AssignTo, AssignTo>(res, variable);
+        };
+
+        Option *opt = add_option(option_name, fun, option_description, false, []() { return std::string{}; });
+        opt->type_name(detail::type_name<AssignTo>());
+        opt->type_size(detail::type_count_min<AssignTo>::value, detail::type_count<AssignTo>::value);
+        opt->expected(detail::expected_count<AssignTo>::value);
+        opt->run_callback_for_default();
+        return opt;
+    }
+
+    /// Add option for a callback of a specific type
+    template <typename ArgType>
+    Option *add_option_function(std::string option_name,
+                                const std::function<void(const ArgType &)> &func,  ///< the callback to execute
+                                std::string option_description = "") {
+
+        auto fun = [func](const CLI::results_t &res) {
+            ArgType variable;
+            bool result = detail::lexical_conversion<ArgType, ArgType>(res, variable);
+            if(result) {
+                func(variable);
+            }
+            return result;
+        };
+
+        Option *opt = add_option(option_name, std::move(fun), option_description, false);
+        opt->type_name(detail::type_name<ArgType>());
+        opt->type_size(detail::type_count_min<ArgType>::value, detail::type_count<ArgType>::value);
+        opt->expected(detail::expected_count<ArgType>::value);
+        return opt;
+    }
+
+    /// Add option with no description or variable assignment
+    Option *add_option(std::string option_name) {
+        return add_option(option_name, CLI::callback_t{}, std::string{}, false);
+    }
+
+    /// Add option with description but with no variable assignment or callback
+    template <typename T,
+              enable_if_t<std::is_const<T>::value && std::is_constructible<std::string, T>::value, detail::enabler> =
+                  detail::dummy>
+    Option *add_option(std::string option_name, T &option_description) {
+        return add_option(option_name, CLI::callback_t(), option_description, false);
+    }
+
+    /// Set a help flag, replace the existing one if present
+    Option *set_help_flag(std::string flag_name = "", const std::string &help_description = "") {
+        // take flag_description by const reference otherwise add_flag tries to assign to help_description
+        if(help_ptr_ != nullptr) {
+            remove_option(help_ptr_);
+            help_ptr_ = nullptr;
+        }
+
+        // Empty name will simply remove the help flag
+        if(!flag_name.empty()) {
+            help_ptr_ = add_flag(flag_name, help_description);
+            help_ptr_->configurable(false);
+        }
+
+        return help_ptr_;
+    }
+
+    /// Set a help all flag, replaced the existing one if present
+    Option *set_help_all_flag(std::string help_name = "", const std::string &help_description = "") {
+        // take flag_description by const reference otherwise add_flag tries to assign to flag_description
+        if(help_all_ptr_ != nullptr) {
+            remove_option(help_all_ptr_);
+            help_all_ptr_ = nullptr;
+        }
+
+        // Empty name will simply remove the help all flag
+        if(!help_name.empty()) {
+            help_all_ptr_ = add_flag(help_name, help_description);
+            help_all_ptr_->configurable(false);
+        }
+
+        return help_all_ptr_;
+    }
+
+    /// Set a version flag and version display string, replace the existing one if present
+    Option *set_version_flag(std::string flag_name = "",
+                             const std::string &versionString = "",
+                             const std::string &version_help = "Display program version information and exit") {
+        // take flag_description by const reference otherwise add_flag tries to assign to version_description
+        if(version_ptr_ != nullptr) {
+            remove_option(version_ptr_);
+            version_ptr_ = nullptr;
+        }
+
+        // Empty name will simply remove the version flag
+        if(!flag_name.empty()) {
+            version_ptr_ = add_flag_callback(
+                flag_name, [versionString]() { throw(CLI::CallForVersion(versionString, 0)); }, version_help);
+            version_ptr_->configurable(false);
+        }
+
+        return version_ptr_;
+    }
+    /// Generate the version string through a callback function
+    Option *set_version_flag(std::string flag_name,
+                             std::function<std::string()> vfunc,
+                             const std::string &version_help = "Display program version information and exit") {
+        if(version_ptr_ != nullptr) {
+            remove_option(version_ptr_);
+            version_ptr_ = nullptr;
+        }
+
+        // Empty name will simply remove the version flag
+        if(!flag_name.empty()) {
+            version_ptr_ = add_flag_callback(
+                flag_name, [vfunc]() { throw(CLI::CallForVersion(vfunc(), 0)); }, version_help);
+            version_ptr_->configurable(false);
+        }
+
+        return version_ptr_;
+    }
+
+  private:
+    /// Internal function for adding a flag
+    Option *_add_flag_internal(std::string flag_name, CLI::callback_t fun, std::string flag_description) {
+        Option *opt;
+        if(detail::has_default_flag_values(flag_name)) {
+            // check for default values and if it has them
+            auto flag_defaults = detail::get_default_flag_values(flag_name);
+            detail::remove_default_flag_values(flag_name);
+            opt = add_option(std::move(flag_name), std::move(fun), std::move(flag_description), false);
+            for(const auto &fname : flag_defaults)
+                opt->fnames_.push_back(fname.first);
+            opt->default_flag_values_ = std::move(flag_defaults);
+        } else {
+            opt = add_option(std::move(flag_name), std::move(fun), std::move(flag_description), false);
+        }
+        // flags cannot have positional values
+        if(opt->get_positional()) {
+            auto pos_name = opt->get_name(true);
+            remove_option(opt);
+            throw IncorrectConstruction::PositionalFlag(pos_name);
+        }
+        opt->multi_option_policy(MultiOptionPolicy::TakeLast);
+        opt->expected(0);
+        opt->required(false);
+        return opt;
+    }
+
+  public:
+    /// Add a flag with no description or variable assignment
+    Option *add_flag(std::string flag_name) { return _add_flag_internal(flag_name, CLI::callback_t(), std::string{}); }
+
+    /// Add flag with description but with no variable assignment or callback
+    /// takes a constant string,  if a variable string is passed that variable will be assigned the results from the
+    /// flag
+    template <typename T,
+              enable_if_t<std::is_const<T>::value && std::is_constructible<std::string, T>::value, detail::enabler> =
+                  detail::dummy>
+    Option *add_flag(std::string flag_name, T &flag_description) {
+        return _add_flag_internal(flag_name, CLI::callback_t(), flag_description);
+    }
+
+    /// Add option for flag with integer result - defaults to allowing multiple passings, but can be forced to one
+    /// if `multi_option_policy(CLI::MultiOptionPolicy::Throw)` is used.
+    template <typename T,
+              enable_if_t<std::is_constructible<T, std::int64_t>::value && !is_bool<T>::value, detail::enabler> =
+                  detail::dummy>
+    Option *add_flag(std::string flag_name,
+                     T &flag_count,  ///< A variable holding the count
+                     std::string flag_description = "") {
+        flag_count = 0;
+        CLI::callback_t fun = [&flag_count](const CLI::results_t &res) {
+            try {
+                detail::sum_flag_vector(res, flag_count);
+            } catch(const std::invalid_argument &) {
+                return false;
+            }
+            return true;
+        };
+        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
+            ->multi_option_policy(MultiOptionPolicy::TakeAll);
+    }
+
+    /// Other type version accepts all other types that are not vectors such as bool, enum, string or other classes
+    /// that can be converted from a string
+    template <typename T,
+              enable_if_t<!detail::is_mutable_container<T>::value && !std::is_const<T>::value &&
+                              (!std::is_constructible<T, std::int64_t>::value || is_bool<T>::value) &&
+                              !std::is_constructible<std::function<void(int)>, T>::value,
+                          detail::enabler> = detail::dummy>
+    Option *add_flag(std::string flag_name,
+                     T &flag_result,  ///< A variable holding true if passed
+                     std::string flag_description = "") {
+
+        CLI::callback_t fun = [&flag_result](const CLI::results_t &res) {
+            return CLI::detail::lexical_cast(res[0], flag_result);
+        };
+        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))->run_callback_for_default();
+    }
+
+    /// Vector version to capture multiple flags.
+    template <typename T,
+              enable_if_t<!std::is_assignable<std::function<void(std::int64_t)> &, T>::value, detail::enabler> =
+                  detail::dummy>
+    Option *add_flag(std::string flag_name,
+                     std::vector<T> &flag_results,  ///< A vector of values with the flag results
+                     std::string flag_description = "") {
+        CLI::callback_t fun = [&flag_results](const CLI::results_t &res) {
+            bool retval = true;
+            for(const auto &elem : res) {
+                flag_results.emplace_back();
+                retval &= detail::lexical_cast(elem, flag_results.back());
+            }
+            return retval;
+        };
+        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
+            ->multi_option_policy(MultiOptionPolicy::TakeAll)
+            ->run_callback_for_default();
+    }
+
+    /// Add option for callback that is triggered with a true flag and takes no arguments
+    Option *add_flag_callback(std::string flag_name,
+                              std::function<void(void)> function,  ///< A function to call, void(void)
+                              std::string flag_description = "") {
+
+        CLI::callback_t fun = [function](const CLI::results_t &res) {
+            bool trigger{false};
+            auto result = CLI::detail::lexical_cast(res[0], trigger);
+            if(result && trigger) {
+                function();
+            }
+            return result;
+        };
+        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description));
+    }
+
+    /// Add option for callback with an integer value
+    Option *add_flag_function(std::string flag_name,
+                              std::function<void(std::int64_t)> function,  ///< A function to call, void(int)
+                              std::string flag_description = "") {
+
+        CLI::callback_t fun = [function](const CLI::results_t &res) {
+            std::int64_t flag_count = 0;
+            detail::sum_flag_vector(res, flag_count);
+            function(flag_count);
+            return true;
+        };
+        return _add_flag_internal(flag_name, std::move(fun), std::move(flag_description))
+            ->multi_option_policy(MultiOptionPolicy::TakeAll);
+    }
+
+#ifdef CLI11_CPP14
+    /// Add option for callback (C++14 or better only)
+    Option *add_flag(std::string flag_name,
+                     std::function<void(std::int64_t)> function,  ///< A function to call, void(std::int64_t)
+                     std::string flag_description = "") {
+        return add_flag_function(std::move(flag_name), std::move(function), std::move(flag_description));
+    }
+#endif
+
+    /// Set a configuration ini file option, or clear it if no name passed
+    Option *set_config(std::string option_name = "",
+                       std::string default_filename = "",
+                       const std::string &help_message = "Read an ini file",
+                       bool config_required = false) {
+
+        // Remove existing config if present
+        if(config_ptr_ != nullptr) {
+            remove_option(config_ptr_);
+            config_ptr_ = nullptr;  // need to remove the config_ptr completely
+        }
+
+        // Only add config if option passed
+        if(!option_name.empty()) {
+            config_ptr_ = add_option(option_name, help_message);
+            if(config_required) {
+                config_ptr_->required();
+            }
+            if(!default_filename.empty()) {
+                config_ptr_->default_str(std::move(default_filename));
+            }
+            config_ptr_->configurable(false);
+        }
+
+        return config_ptr_;
+    }
+
+    /// Removes an option from the App. Takes an option pointer. Returns true if found and removed.
+    bool remove_option(Option *opt) {
+        // Make sure no links exist
+        for(Option_p &op : options_) {
+            op->remove_needs(opt);
+            op->remove_excludes(opt);
+        }
+
+        if(help_ptr_ == opt)
+            help_ptr_ = nullptr;
+        if(help_all_ptr_ == opt)
+            help_all_ptr_ = nullptr;
+
+        auto iterator =
+            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
+        if(iterator != std::end(options_)) {
+            options_.erase(iterator);
+            return true;
+        }
+        return false;
+    }
+
+    /// creates an option group as part of the given app
+    template <typename T = Option_group>
+    T *add_option_group(std::string group_name, std::string group_description = "") {
+        if(!detail::valid_alias_name_string(group_name)) {
+            throw IncorrectConstruction("option group names may not contain newlines or null characters");
+        }
+        auto option_group = std::make_shared<T>(std::move(group_description), group_name, this);
+        auto ptr = option_group.get();
+        // move to App_p for overload resolution on older gcc versions
+        App_p app_ptr = std::dynamic_pointer_cast<App>(option_group);
+        add_subcommand(std::move(app_ptr));
+        return ptr;
+    }
+
+    ///@}
+    /// @name Subcommands
+    ///@{
+
+    /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
+    App *add_subcommand(std::string subcommand_name = "", std::string subcommand_description = "") {
+        if(!subcommand_name.empty() && !detail::valid_name_string(subcommand_name)) {
+            if(!detail::valid_first_char(subcommand_name[0])) {
+                throw IncorrectConstruction(
+                    "Subcommand name starts with invalid character, '!' and '-' are not allowed");
+            }
+            for(auto c : subcommand_name) {
+                if(!detail::valid_later_char(c)) {
+                    throw IncorrectConstruction(std::string("Subcommand name contains invalid character ('") + c +
+                                                "'), all characters are allowed except"
+                                                "'=',':','{','}', and ' '");
+                }
+            }
+        }
+        CLI::App_p subcom = std::shared_ptr<App>(new App(std::move(subcommand_description), subcommand_name, this));
+        return add_subcommand(std::move(subcom));
+    }
+
+    /// Add a previously created app as a subcommand
+    App *add_subcommand(CLI::App_p subcom) {
+        if(!subcom)
+            throw IncorrectConstruction("passed App is not valid");
+        auto ckapp = (name_.empty() && parent_ != nullptr) ? _get_fallthrough_parent() : this;
+        auto &mstrg = _compare_subcommand_names(*subcom, *ckapp);
+        if(!mstrg.empty()) {
+            throw(OptionAlreadyAdded("subcommand name or alias matches existing subcommand: " + mstrg));
+        }
+        subcom->parent_ = this;
+        subcommands_.push_back(std::move(subcom));
+        return subcommands_.back().get();
+    }
+
+    /// Removes a subcommand from the App. Takes a subcommand pointer. Returns true if found and removed.
+    bool remove_subcommand(App *subcom) {
+        // Make sure no links exist
+        for(App_p &sub : subcommands_) {
+            sub->remove_excludes(subcom);
+            sub->remove_needs(subcom);
+        }
+
+        auto iterator = std::find_if(
+            std::begin(subcommands_), std::end(subcommands_), [subcom](const App_p &v) { return v.get() == subcom; });
+        if(iterator != std::end(subcommands_)) {
+            subcommands_.erase(iterator);
+            return true;
+        }
+        return false;
+    }
+    /// Check to see if a subcommand is part of this command (doesn't have to be in command line)
+    /// returns the first subcommand if passed a nullptr
+    App *get_subcommand(const App *subcom) const {
+        if(subcom == nullptr)
+            throw OptionNotFound("nullptr passed");
+        for(const App_p &subcomptr : subcommands_)
+            if(subcomptr.get() == subcom)
+                return subcomptr.get();
+        throw OptionNotFound(subcom->get_name());
+    }
+
+    /// Check to see if a subcommand is part of this command (text version)
+    App *get_subcommand(std::string subcom) const {
+        auto subc = _find_subcommand(subcom, false, false);
+        if(subc == nullptr)
+            throw OptionNotFound(subcom);
+        return subc;
+    }
+    /// Get a pointer to subcommand by index
+    App *get_subcommand(int index = 0) const {
+        if(index >= 0) {
+            auto uindex = static_cast<unsigned>(index);
+            if(uindex < subcommands_.size())
+                return subcommands_[uindex].get();
+        }
+        throw OptionNotFound(std::to_string(index));
+    }
+
+    /// Check to see if a subcommand is part of this command and get a shared_ptr to it
+    CLI::App_p get_subcommand_ptr(App *subcom) const {
+        if(subcom == nullptr)
+            throw OptionNotFound("nullptr passed");
+        for(const App_p &subcomptr : subcommands_)
+            if(subcomptr.get() == subcom)
+                return subcomptr;
+        throw OptionNotFound(subcom->get_name());
+    }
+
+    /// Check to see if a subcommand is part of this command (text version)
+    CLI::App_p get_subcommand_ptr(std::string subcom) const {
+        for(const App_p &subcomptr : subcommands_)
+            if(subcomptr->check_name(subcom))
+                return subcomptr;
+        throw OptionNotFound(subcom);
+    }
+
+    /// Get an owning pointer to subcommand by index
+    CLI::App_p get_subcommand_ptr(int index = 0) const {
+        if(index >= 0) {
+            auto uindex = static_cast<unsigned>(index);
+            if(uindex < subcommands_.size())
+                return subcommands_[uindex];
+        }
+        throw OptionNotFound(std::to_string(index));
+    }
+
+    /// Check to see if an option group is part of this App
+    App *get_option_group(std::string group_name) const {
+        for(const App_p &app : subcommands_) {
+            if(app->name_.empty() && app->group_ == group_name) {
+                return app.get();
+            }
+        }
+        throw OptionNotFound(group_name);
+    }
+
+    /// No argument version of count counts the number of times this subcommand was
+    /// passed in. The main app will return 1. Unnamed subcommands will also return 1 unless
+    /// otherwise modified in a callback
+    std::size_t count() const { return parsed_; }
+
+    /// Get a count of all the arguments processed in options and subcommands, this excludes arguments which were
+    /// treated as extras.
+    std::size_t count_all() const {
+        std::size_t cnt{0};
+        for(auto &opt : options_) {
+            cnt += opt->count();
+        }
+        for(auto &sub : subcommands_) {
+            cnt += sub->count_all();
+        }
+        if(!get_name().empty()) {  // for named subcommands add the number of times the subcommand was called
+            cnt += parsed_;
+        }
+        return cnt;
+    }
+
+    /// Changes the group membership
+    App *group(std::string group_name) {
+        group_ = group_name;
+        return this;
+    }
+
+    /// The argumentless form of require subcommand requires 1 or more subcommands
+    App *require_subcommand() {
+        require_subcommand_min_ = 1;
+        require_subcommand_max_ = 0;
+        return this;
+    }
+
+    /// Require a subcommand to be given (does not affect help call)
+    /// The number required can be given. Negative values indicate maximum
+    /// number allowed (0 for any number). Max number inheritable.
+    App *require_subcommand(int value) {
+        if(value < 0) {
+            require_subcommand_min_ = 0;
+            require_subcommand_max_ = static_cast<std::size_t>(-value);
+        } else {
+            require_subcommand_min_ = static_cast<std::size_t>(value);
+            require_subcommand_max_ = static_cast<std::size_t>(value);
+        }
+        return this;
+    }
+
+    /// Explicitly control the number of subcommands required. Setting 0
+    /// for the max means unlimited number allowed. Max number inheritable.
+    App *require_subcommand(std::size_t min, std::size_t max) {
+        require_subcommand_min_ = min;
+        require_subcommand_max_ = max;
+        return this;
+    }
+
+    /// The argumentless form of require option requires 1 or more options be used
+    App *require_option() {
+        require_option_min_ = 1;
+        require_option_max_ = 0;
+        return this;
+    }
+
+    /// Require an option to be given (does not affect help call)
+    /// The number required can be given. Negative values indicate maximum
+    /// number allowed (0 for any number).
+    App *require_option(int value) {
+        if(value < 0) {
+            require_option_min_ = 0;
+            require_option_max_ = static_cast<std::size_t>(-value);
+        } else {
+            require_option_min_ = static_cast<std::size_t>(value);
+            require_option_max_ = static_cast<std::size_t>(value);
+        }
+        return this;
+    }
+
+    /// Explicitly control the number of options required. Setting 0
+    /// for the max means unlimited number allowed. Max number inheritable.
+    App *require_option(std::size_t min, std::size_t max) {
+        require_option_min_ = min;
+        require_option_max_ = max;
+        return this;
+    }
+
+    /// Stop subcommand fallthrough, so that parent commands cannot collect commands after subcommand.
+    /// Default from parent, usually set on parent.
+    App *fallthrough(bool value = true) {
+        fallthrough_ = value;
+        return this;
+    }
+
+    /// Check to see if this subcommand was parsed, true only if received on command line.
+    /// This allows the subcommand to be directly checked.
+    explicit operator bool() const { return parsed_ > 0; }
+
+    ///@}
+    /// @name Extras for subclassing
+    ///@{
+
+    /// This allows subclasses to inject code before callbacks but after parse.
+    ///
+    /// This does not run if any errors or help is thrown.
+    virtual void pre_callback() {}
+
+    ///@}
+    /// @name Parsing
+    ///@{
+    //
+    /// Reset the parsed data
+    void clear() {
+
+        parsed_ = 0;
+        pre_parse_called_ = false;
+
+        missing_.clear();
+        parsed_subcommands_.clear();
+        for(const Option_p &opt : options_) {
+            opt->clear();
+        }
+        for(const App_p &subc : subcommands_) {
+            subc->clear();
+        }
+    }
+
+    /// Parses the command line - throws errors.
+    /// This must be called after the options are in but before the rest of the program.
+    void parse(int argc, const char *const *argv) {
+        // If the name is not set, read from command line
+        if(name_.empty() || has_automatic_name_) {
+            has_automatic_name_ = true;
+            name_ = argv[0];
+        }
+
+        std::vector<std::string> args;
+        args.reserve(static_cast<std::size_t>(argc) - 1);
+        for(int i = argc - 1; i > 0; i--)
+            args.emplace_back(argv[i]);
+        parse(std::move(args));
+    }
+
+    /// Parse a single string as if it contained command line arguments.
+    /// This function splits the string into arguments then calls parse(std::vector<std::string> &)
+    /// the function takes an optional boolean argument specifying if the programName is included in the string to
+    /// process
+    void parse(std::string commandline, bool program_name_included = false) {
+
+        if(program_name_included) {
+            auto nstr = detail::split_program_name(commandline);
+            if((name_.empty()) || (has_automatic_name_)) {
+                has_automatic_name_ = true;
+                name_ = nstr.first;
+            }
+            commandline = std::move(nstr.second);
+        } else {
+            detail::trim(commandline);
+        }
+        // the next section of code is to deal with quoted arguments after an '=' or ':' for windows like operations
+        if(!commandline.empty()) {
+            commandline = detail::find_and_modify(commandline, "=", detail::escape_detect);
+            if(allow_windows_style_options_)
+                commandline = detail::find_and_modify(commandline, ":", detail::escape_detect);
+        }
+
+        auto args = detail::split_up(std::move(commandline));
+        // remove all empty strings
+        args.erase(std::remove(args.begin(), args.end(), std::string{}), args.end());
+        std::reverse(args.begin(), args.end());
+
+        parse(std::move(args));
+    }
+
+    /// The real work is done here. Expects a reversed vector.
+    /// Changes the vector to the remaining options.
+    void parse(std::vector<std::string> &args) {
+        // Clear if parsed
+        if(parsed_ > 0)
+            clear();
+
+        // parsed_ is incremented in commands/subcommands,
+        // but placed here to make sure this is cleared when
+        // running parse after an error is thrown, even by _validate or _configure.
+        parsed_ = 1;
+        _validate();
+        _configure();
+        // set the parent as nullptr as this object should be the top now
+        parent_ = nullptr;
+        parsed_ = 0;
+
+        _parse(args);
+        run_callback();
+    }
+
+    /// The real work is done here. Expects a reversed vector.
+    void parse(std::vector<std::string> &&args) {
+        // Clear if parsed
+        if(parsed_ > 0)
+            clear();
+
+        // parsed_ is incremented in commands/subcommands,
+        // but placed here to make sure this is cleared when
+        // running parse after an error is thrown, even by _validate or _configure.
+        parsed_ = 1;
+        _validate();
+        _configure();
+        // set the parent as nullptr as this object should be the top now
+        parent_ = nullptr;
+        parsed_ = 0;
+
+        _parse(std::move(args));
+        run_callback();
+    }
+
+    void parse_from_stream(std::istream &input) {
+        if(parsed_ == 0) {
+            _validate();
+            _configure();
+            // set the parent as nullptr as this object should be the top now
+        }
+
+        _parse_stream(input);
+        run_callback();
+    }
+    /// Provide a function to print a help message. The function gets access to the App pointer and error.
+    void failure_message(std::function<std::string(const App *, const Error &e)> function) {
+        failure_message_ = function;
+    }
+
+    /// Print a nice error message and return the exit code
+    int exit(const Error &e, std::ostream &out = std::cout, std::ostream &err = std::cerr) const {
+
+        /// Avoid printing anything if this is a CLI::RuntimeError
+        if(e.get_name() == "RuntimeError")
+            return e.get_exit_code();
+
+        if(e.get_name() == "CallForHelp") {
+            out << help();
+            return e.get_exit_code();
+        }
+
+        if(e.get_name() == "CallForAllHelp") {
+            out << help("", AppFormatMode::All);
+            return e.get_exit_code();
+        }
+
+        if(e.get_name() == "CallForVersion") {
+            out << e.what() << std::endl;
+            return e.get_exit_code();
+        }
+
+        if(e.get_exit_code() != static_cast<int>(ExitCodes::Success)) {
+            if(failure_message_)
+                err << failure_message_(this, e) << std::flush;
+        }
+
+        return e.get_exit_code();
+    }
+
+    ///@}
+    /// @name Post parsing
+    ///@{
+
+    /// Counts the number of times the given option was passed.
+    std::size_t count(std::string option_name) const { return get_option(option_name)->count(); }
+
+    /// Get a subcommand pointer list to the currently selected subcommands (after parsing by default, in command
+    /// line order; use parsed = false to get the original definition list.)
+    std::vector<App *> get_subcommands() const { return parsed_subcommands_; }
+
+    /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
+    /// subcommands (const)
+    std::vector<const App *> get_subcommands(const std::function<bool(const App *)> &filter) const {
+        std::vector<const App *> subcomms(subcommands_.size());
+        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
+            return v.get();
+        });
+
+        if(filter) {
+            subcomms.erase(std::remove_if(std::begin(subcomms),
+                                          std::end(subcomms),
+                                          [&filter](const App *app) { return !filter(app); }),
+                           std::end(subcomms));
+        }
+
+        return subcomms;
+    }
+
+    /// Get a filtered subcommand pointer list from the original definition list. An empty function will provide all
+    /// subcommands
+    std::vector<App *> get_subcommands(const std::function<bool(App *)> &filter) {
+        std::vector<App *> subcomms(subcommands_.size());
+        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
+            return v.get();
+        });
+
+        if(filter) {
+            subcomms.erase(
+                std::remove_if(std::begin(subcomms), std::end(subcomms), [&filter](App *app) { return !filter(app); }),
+                std::end(subcomms));
+        }
+
+        return subcomms;
+    }
+
+    /// Check to see if given subcommand was selected
+    bool got_subcommand(const App *subcom) const {
+        // get subcom needed to verify that this was a real subcommand
+        return get_subcommand(subcom)->parsed_ > 0;
+    }
+
+    /// Check with name instead of pointer to see if subcommand was selected
+    bool got_subcommand(std::string subcommand_name) const { return get_subcommand(subcommand_name)->parsed_ > 0; }
+
+    /// Sets excluded options for the subcommand
+    App *excludes(Option *opt) {
+        if(opt == nullptr) {
+            throw OptionNotFound("nullptr passed");
+        }
+        exclude_options_.insert(opt);
+        return this;
+    }
+
+    /// Sets excluded subcommands for the subcommand
+    App *excludes(App *app) {
+        if(app == nullptr) {
+            throw OptionNotFound("nullptr passed");
+        }
+        if(app == this) {
+            throw OptionNotFound("cannot self reference in needs");
+        }
+        auto res = exclude_subcommands_.insert(app);
+        // subcommand exclusion should be symmetric
+        if(res.second) {
+            app->exclude_subcommands_.insert(this);
+        }
+        return this;
+    }
+
+    App *needs(Option *opt) {
+        if(opt == nullptr) {
+            throw OptionNotFound("nullptr passed");
+        }
+        need_options_.insert(opt);
+        return this;
+    }
+
+    App *needs(App *app) {
+        if(app == nullptr) {
+            throw OptionNotFound("nullptr passed");
+        }
+        if(app == this) {
+            throw OptionNotFound("cannot self reference in needs");
+        }
+        need_subcommands_.insert(app);
+        return this;
+    }
+
+    /// Removes an option from the excludes list of this subcommand
+    bool remove_excludes(Option *opt) {
+        auto iterator = std::find(std::begin(exclude_options_), std::end(exclude_options_), opt);
+        if(iterator == std::end(exclude_options_)) {
+            return false;
+        }
+        exclude_options_.erase(iterator);
+        return true;
+    }
+
+    /// Removes a subcommand from the excludes list of this subcommand
+    bool remove_excludes(App *app) {
+        auto iterator = std::find(std::begin(exclude_subcommands_), std::end(exclude_subcommands_), app);
+        if(iterator == std::end(exclude_subcommands_)) {
+            return false;
+        }
+        auto other_app = *iterator;
+        exclude_subcommands_.erase(iterator);
+        other_app->remove_excludes(this);
+        return true;
+    }
+
+    /// Removes an option from the needs list of this subcommand
+    bool remove_needs(Option *opt) {
+        auto iterator = std::find(std::begin(need_options_), std::end(need_options_), opt);
+        if(iterator == std::end(need_options_)) {
+            return false;
+        }
+        need_options_.erase(iterator);
+        return true;
+    }
+
+    /// Removes a subcommand from the needs list of this subcommand
+    bool remove_needs(App *app) {
+        auto iterator = std::find(std::begin(need_subcommands_), std::end(need_subcommands_), app);
+        if(iterator == std::end(need_subcommands_)) {
+            return false;
+        }
+        need_subcommands_.erase(iterator);
+        return true;
+    }
+
+    ///@}
+    /// @name Help
+    ///@{
+
+    /// Set footer.
+    App *footer(std::string footer_string) {
+        footer_ = std::move(footer_string);
+        return this;
+    }
+    /// Set footer.
+    App *footer(std::function<std::string()> footer_function) {
+        footer_callback_ = std::move(footer_function);
+        return this;
+    }
+    /// Produce a string that could be read in as a config of the current values of the App. Set default_also to
+    /// include default arguments. write_descriptions will print a description for the App and for each option.
+    std::string config_to_str(bool default_also = false, bool write_description = false) const {
+        return config_formatter_->to_config(this, default_also, write_description, "");
+    }
+
+    /// Makes a help message, using the currently configured formatter
+    /// Will only do one subcommand at a time
+    std::string help(std::string prev = "", AppFormatMode mode = AppFormatMode::Normal) const {
+        if(prev.empty())
+            prev = get_name();
+        else
+            prev += " " + get_name();
+
+        // Delegate to subcommand if needed
+        auto selected_subcommands = get_subcommands();
+        if(!selected_subcommands.empty()) {
+            return selected_subcommands.at(0)->help(prev, mode);
+        }
+        return formatter_->make_help(this, prev, mode);
+    }
+
+    /// Displays a version string
+    std::string version() const {
+        std::string val;
+        if(version_ptr_ != nullptr) {
+            auto rv = version_ptr_->results();
+            version_ptr_->clear();
+            version_ptr_->add_result("true");
+            try {
+                version_ptr_->run_callback();
+            } catch(const CLI::CallForVersion &cfv) {
+                val = cfv.what();
+            }
+            version_ptr_->clear();
+            version_ptr_->add_result(rv);
+        }
+        return val;
+    }
+    ///@}
+    /// @name Getters
+    ///@{
+
+    /// Access the formatter
+    std::shared_ptr<FormatterBase> get_formatter() const { return formatter_; }
+
+    /// Access the config formatter
+    std::shared_ptr<Config> get_config_formatter() const { return config_formatter_; }
+
+    /// Access the config formatter as a configBase pointer
+    std::shared_ptr<ConfigBase> get_config_formatter_base() const {
+        // This is safer as a dynamic_cast if we have RTTI, as Config -> ConfigBase
+#if defined(__cpp_rtti) || (defined(__GXX_RTTI) && __GXX_RTTI) || (defined(_HAS_STATIC_RTTI) && (_HAS_STATIC_RTTI == 0))
+        return std::dynamic_pointer_cast<ConfigBase>(config_formatter_);
+#else
+        return std::static_pointer_cast<ConfigBase>(config_formatter_);
+#endif
+    }
+
+    /// Get the app or subcommand description
+    std::string get_description() const { return description_; }
+
+    /// Set the description of the app
+    App *description(std::string app_description) {
+        description_ = std::move(app_description);
+        return this;
+    }
+
+    /// Get the list of options (user facing function, so returns raw pointers), has optional filter function
+    std::vector<const Option *> get_options(const std::function<bool(const Option *)> filter = {}) const {
+        std::vector<const Option *> options(options_.size());
+        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
+            return val.get();
+        });
+
+        if(filter) {
+            options.erase(std::remove_if(std::begin(options),
+                                         std::end(options),
+                                         [&filter](const Option *opt) { return !filter(opt); }),
+                          std::end(options));
+        }
+
+        return options;
+    }
+
+    /// Non-const version of the above
+    std::vector<Option *> get_options(const std::function<bool(Option *)> filter = {}) {
+        std::vector<Option *> options(options_.size());
+        std::transform(std::begin(options_), std::end(options_), std::begin(options), [](const Option_p &val) {
+            return val.get();
+        });
+
+        if(filter) {
+            options.erase(
+                std::remove_if(std::begin(options), std::end(options), [&filter](Option *opt) { return !filter(opt); }),
+                std::end(options));
+        }
+
+        return options;
+    }
+
+    /// Get an option by name (noexcept non-const version)
+    Option *get_option_no_throw(std::string option_name) noexcept {
+        for(Option_p &opt : options_) {
+            if(opt->check_name(option_name)) {
+                return opt.get();
+            }
+        }
+        for(auto &subc : subcommands_) {
+            // also check down into nameless subcommands
+            if(subc->get_name().empty()) {
+                auto opt = subc->get_option_no_throw(option_name);
+                if(opt != nullptr) {
+                    return opt;
+                }
+            }
+        }
+        return nullptr;
+    }
+
+    /// Get an option by name (noexcept const version)
+    const Option *get_option_no_throw(std::string option_name) const noexcept {
+        for(const Option_p &opt : options_) {
+            if(opt->check_name(option_name)) {
+                return opt.get();
+            }
+        }
+        for(const auto &subc : subcommands_) {
+            // also check down into nameless subcommands
+            if(subc->get_name().empty()) {
+                auto opt = subc->get_option_no_throw(option_name);
+                if(opt != nullptr) {
+                    return opt;
+                }
+            }
+        }
+        return nullptr;
+    }
+
+    /// Get an option by name
+    const Option *get_option(std::string option_name) const {
+        auto opt = get_option_no_throw(option_name);
+        if(opt == nullptr) {
+            throw OptionNotFound(option_name);
+        }
+        return opt;
+    }
+
+    /// Get an option by name (non-const version)
+    Option *get_option(std::string option_name) {
+        auto opt = get_option_no_throw(option_name);
+        if(opt == nullptr) {
+            throw OptionNotFound(option_name);
+        }
+        return opt;
+    }
+
+    /// Shortcut bracket operator for getting a pointer to an option
+    const Option *operator[](const std::string &option_name) const { return get_option(option_name); }
+
+    /// Shortcut bracket operator for getting a pointer to an option
+    const Option *operator[](const char *option_name) const { return get_option(option_name); }
+
+    /// Check the status of ignore_case
+    bool get_ignore_case() const { return ignore_case_; }
+
+    /// Check the status of ignore_underscore
+    bool get_ignore_underscore() const { return ignore_underscore_; }
+
+    /// Check the status of fallthrough
+    bool get_fallthrough() const { return fallthrough_; }
+
+    /// Check the status of the allow windows style options
+    bool get_allow_windows_style_options() const { return allow_windows_style_options_; }
+
+    /// Check the status of the allow windows style options
+    bool get_positionals_at_end() const { return positionals_at_end_; }
+
+    /// Check the status of the allow windows style options
+    bool get_configurable() const { return configurable_; }
+
+    /// Get the group of this subcommand
+    const std::string &get_group() const { return group_; }
+
+    /// Generate and return the footer.
+    std::string get_footer() const { return (footer_callback_) ? footer_callback_() + '\n' + footer_ : footer_; }
+
+    /// Get the required min subcommand value
+    std::size_t get_require_subcommand_min() const { return require_subcommand_min_; }
+
+    /// Get the required max subcommand value
+    std::size_t get_require_subcommand_max() const { return require_subcommand_max_; }
+
+    /// Get the required min option value
+    std::size_t get_require_option_min() const { return require_option_min_; }
+
+    /// Get the required max option value
+    std::size_t get_require_option_max() const { return require_option_max_; }
+
+    /// Get the prefix command status
+    bool get_prefix_command() const { return prefix_command_; }
+
+    /// Get the status of allow extras
+    bool get_allow_extras() const { return allow_extras_; }
+
+    /// Get the status of required
+    bool get_required() const { return required_; }
+
+    /// Get the status of disabled
+    bool get_disabled() const { return disabled_; }
+
+    /// Get the status of silence
+    bool get_silent() const { return silent_; }
+
+    /// Get the status of disabled
+    bool get_immediate_callback() const { return immediate_callback_; }
+
+    /// Get the status of disabled by default
+    bool get_disabled_by_default() const { return (default_startup == startup_mode::disabled); }
+
+    /// Get the status of disabled by default
+    bool get_enabled_by_default() const { return (default_startup == startup_mode::enabled); }
+    /// Get the status of validating positionals
+    bool get_validate_positionals() const { return validate_positionals_; }
+
+    /// Get the status of allow extras
+    config_extras_mode get_allow_config_extras() const { return allow_config_extras_; }
+
+    /// Get a pointer to the help flag.
+    Option *get_help_ptr() { return help_ptr_; }
+
+    /// Get a pointer to the help flag. (const)
+    const Option *get_help_ptr() const { return help_ptr_; }
+
+    /// Get a pointer to the help all flag. (const)
+    const Option *get_help_all_ptr() const { return help_all_ptr_; }
+
+    /// Get a pointer to the config option.
+    Option *get_config_ptr() { return config_ptr_; }
+
+    /// Get a pointer to the config option. (const)
+    const Option *get_config_ptr() const { return config_ptr_; }
+
+    /// Get a pointer to the version option.
+    Option *get_version_ptr() { return version_ptr_; }
+
+    /// Get a pointer to the version option. (const)
+    const Option *get_version_ptr() const { return version_ptr_; }
+
+    /// Get the parent of this subcommand (or nullptr if master app)
+    App *get_parent() { return parent_; }
+
+    /// Get the parent of this subcommand (or nullptr if master app) (const version)
+    const App *get_parent() const { return parent_; }
+
+    /// Get the name of the current app
+    const std::string &get_name() const { return name_; }
+
+    /// Get the aliases of the current app
+    const std::vector<std::string> &get_aliases() const { return aliases_; }
+
+    /// clear all the aliases of the current App
+    App *clear_aliases() {
+        aliases_.clear();
+        return this;
+    }
+
+    /// Get a display name for an app
+    std::string get_display_name(bool with_aliases = false) const {
+        if(name_.empty()) {
+            return std::string("[Option Group: ") + get_group() + "]";
+        }
+        if(aliases_.empty() || !with_aliases) {
+            return name_;
+        }
+        std::string dispname = name_;
+        for(const auto &lalias : aliases_) {
+            dispname.push_back(',');
+            dispname.push_back(' ');
+            dispname.append(lalias);
+        }
+        return dispname;
+    }
+
+    /// Check the name, case insensitive and underscore insensitive if set
+    bool check_name(std::string name_to_check) const {
+        std::string local_name = name_;
+        if(ignore_underscore_) {
+            local_name = detail::remove_underscore(name_);
+            name_to_check = detail::remove_underscore(name_to_check);
+        }
+        if(ignore_case_) {
+            local_name = detail::to_lower(name_);
+            name_to_check = detail::to_lower(name_to_check);
+        }
+
+        if(local_name == name_to_check) {
+            return true;
+        }
+        for(auto les : aliases_) {
+            if(ignore_underscore_) {
+                les = detail::remove_underscore(les);
+            }
+            if(ignore_case_) {
+                les = detail::to_lower(les);
+            }
+            if(les == name_to_check) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /// Get the groups available directly from this option (in order)
+    std::vector<std::string> get_groups() const {
+        std::vector<std::string> groups;
+
+        for(const Option_p &opt : options_) {
+            // Add group if it is not already in there
+            if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
+                groups.push_back(opt->get_group());
+            }
+        }
+
+        return groups;
+    }
+
+    /// This gets a vector of pointers with the original parse order
+    const std::vector<Option *> &parse_order() const { return parse_order_; }
+
+    /// This returns the missing options from the current subcommand
+    std::vector<std::string> remaining(bool recurse = false) const {
+        std::vector<std::string> miss_list;
+        for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
+            miss_list.push_back(std::get<1>(miss));
+        }
+        // Get from a subcommand that may allow extras
+        if(recurse) {
+            if(!allow_extras_) {
+                for(const auto &sub : subcommands_) {
+                    if(sub->name_.empty() && !sub->missing_.empty()) {
+                        for(const std::pair<detail::Classifier, std::string> &miss : sub->missing_) {
+                            miss_list.push_back(std::get<1>(miss));
+                        }
+                    }
+                }
+            }
+            // Recurse into subcommands
+
+            for(const App *sub : parsed_subcommands_) {
+                std::vector<std::string> output = sub->remaining(recurse);
+                std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
+            }
+        }
+        return miss_list;
+    }
+
+    /// This returns the missing options in a form ready for processing by another command line program
+    std::vector<std::string> remaining_for_passthrough(bool recurse = false) const {
+        std::vector<std::string> miss_list = remaining(recurse);
+        std::reverse(std::begin(miss_list), std::end(miss_list));
+        return miss_list;
+    }
+
+    /// This returns the number of remaining options, minus the -- separator
+    std::size_t remaining_size(bool recurse = false) const {
+        auto remaining_options = static_cast<std::size_t>(std::count_if(
+            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifier, std::string> &val) {
+                return val.first != detail::Classifier::POSITIONAL_MARK;
+            }));
+
+        if(recurse) {
+            for(const App_p &sub : subcommands_) {
+                remaining_options += sub->remaining_size(recurse);
+            }
+        }
+        return remaining_options;
+    }
+
+    ///@}
+
+  protected:
+    /// Check the options to make sure there are no conflicts.
+    ///
+    /// Currently checks to see if multiple positionals exist with unlimited args and checks if the min and max options
+    /// are feasible
+    void _validate() const {
+        // count the number of positional only args
+        auto pcount = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
+            return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional();
+        });
+        if(pcount > 1) {
+            auto pcount_req = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
+                return opt->get_items_expected_max() >= detail::expected_max_vector_size && !opt->nonpositional() &&
+                       opt->get_required();
+            });
+            if(pcount - pcount_req > 1) {
+                throw InvalidError(name_);
+            }
+        }
+
+        std::size_t nameless_subs{0};
+        for(const App_p &app : subcommands_) {
+            app->_validate();
+            if(app->get_name().empty())
+                ++nameless_subs;
+        }
+
+        if(require_option_min_ > 0) {
+            if(require_option_max_ > 0) {
+                if(require_option_max_ < require_option_min_) {
+                    throw(InvalidError("Required min options greater than required max options",
+                                       ExitCodes::InvalidError));
+                }
+            }
+            if(require_option_min_ > (options_.size() + nameless_subs)) {
+                throw(InvalidError("Required min options greater than number of available options",
+                                   ExitCodes::InvalidError));
+            }
+        }
+    }
+
+    /// configure subcommands to enable parsing through the current object
+    /// set the correct fallthrough and prefix for nameless subcommands and manage the automatic enable or disable
+    /// makes sure parent is set correctly
+    void _configure() {
+        if(default_startup == startup_mode::enabled) {
+            disabled_ = false;
+        } else if(default_startup == startup_mode::disabled) {
+            disabled_ = true;
+        }
+        for(const App_p &app : subcommands_) {
+            if(app->has_automatic_name_) {
+                app->name_.clear();
+            }
+            if(app->name_.empty()) {
+                app->fallthrough_ = false;  // make sure fallthrough_ is false to prevent infinite loop
+                app->prefix_command_ = false;
+            }
+            // make sure the parent is set to be this object in preparation for parse
+            app->parent_ = this;
+            app->_configure();
+        }
+    }
+
+    /// Internal function to run (App) callback, bottom up
+    void run_callback(bool final_mode = false, bool suppress_final_callback = false) {
+        pre_callback();
+        // in the main app if immediate_callback_ is set it runs the main callback before the used subcommands
+        if(!final_mode && parse_complete_callback_) {
+            parse_complete_callback_();
+        }
+        // run the callbacks for the received subcommands
+        for(App *subc : get_subcommands()) {
+            subc->run_callback(true, suppress_final_callback);
+        }
+        // now run callbacks for option_groups
+        for(auto &subc : subcommands_) {
+            if(subc->name_.empty() && subc->count_all() > 0) {
+                subc->run_callback(true, suppress_final_callback);
+            }
+        }
+
+        // finally run the main callback
+        if(final_callback_ && (parsed_ > 0) && (!suppress_final_callback)) {
+            if(!name_.empty() || count_all() > 0 || parent_ == nullptr) {
+                final_callback_();
+            }
+        }
+    }
+
+    /// Check to see if a subcommand is valid. Give up immediately if subcommand max has been reached.
+    bool _valid_subcommand(const std::string &current, bool ignore_used = true) const {
+        // Don't match if max has been reached - but still check parents
+        if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
+            return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
+        }
+        auto com = _find_subcommand(current, true, ignore_used);
+        if(com != nullptr) {
+            return true;
+        }
+        // Check parent if exists, else return false
+        return parent_ != nullptr && parent_->_valid_subcommand(current, ignore_used);
+    }
+
+    /// Selects a Classifier enum based on the type of the current argument
+    detail::Classifier _recognize(const std::string &current, bool ignore_used_subcommands = true) const {
+        std::string dummy1, dummy2;
+
+        if(current == "--")
+            return detail::Classifier::POSITIONAL_MARK;
+        if(_valid_subcommand(current, ignore_used_subcommands))
+            return detail::Classifier::SUBCOMMAND;
+        if(detail::split_long(current, dummy1, dummy2))
+            return detail::Classifier::LONG;
+        if(detail::split_short(current, dummy1, dummy2)) {
+            if(dummy1[0] >= '0' && dummy1[0] <= '9') {
+                if(get_option_no_throw(std::string{'-', dummy1[0]}) == nullptr) {
+                    return detail::Classifier::NONE;
+                }
+            }
+            return detail::Classifier::SHORT;
+        }
+        if((allow_windows_style_options_) && (detail::split_windows_style(current, dummy1, dummy2)))
+            return detail::Classifier::WINDOWS_STYLE;
+        if((current == "++") && !name_.empty() && parent_ != nullptr)
+            return detail::Classifier::SUBCOMMAND_TERMINATOR;
+        return detail::Classifier::NONE;
+    }
+
+    // The parse function is now broken into several parts, and part of process
+
+    /// Read and process a configuration file (main app only)
+    void _process_config_file() {
+        if(config_ptr_ != nullptr) {
+            bool config_required = config_ptr_->get_required();
+            auto file_given = config_ptr_->count() > 0;
+            auto config_files = config_ptr_->as<std::vector<std::string>>();
+            if(config_files.empty() || config_files.front().empty()) {
+                if(config_required) {
+                    throw FileError::Missing("no specified config file");
+                }
+                return;
+            }
+            for(auto rit = config_files.rbegin(); rit != config_files.rend(); ++rit) {
+                const auto &config_file = *rit;
+                auto path_result = detail::check_path(config_file.c_str());
+                if(path_result == detail::path_type::file) {
+                    try {
+                        std::vector<ConfigItem> values = config_formatter_->from_file(config_file);
+                        _parse_config(values);
+                        if(!file_given) {
+                            config_ptr_->add_result(config_file);
+                        }
+                    } catch(const FileError &) {
+                        if(config_required || file_given)
+                            throw;
+                    }
+                } else if(config_required || file_given) {
+                    throw FileError::Missing(config_file);
+                }
+            }
+        }
+    }
+
+    /// Get envname options if not yet passed. Runs on *all* subcommands.
+    void _process_env() {
+        for(const Option_p &opt : options_) {
+            if(opt->count() == 0 && !opt->envname_.empty()) {
+                char *buffer = nullptr;
+                std::string ename_string;
+
+#ifdef _MSC_VER
+                // Windows version
+                std::size_t sz = 0;
+                if(_dupenv_s(&buffer, &sz, opt->envname_.c_str()) == 0 && buffer != nullptr) {
+                    ename_string = std::string(buffer);
+                    free(buffer);
+                }
+#else
+                // This also works on Windows, but gives a warning
+                buffer = std::getenv(opt->envname_.c_str());
+                if(buffer != nullptr)
+                    ename_string = std::string(buffer);
+#endif
+
+                if(!ename_string.empty()) {
+                    opt->add_result(ename_string);
+                }
+            }
+        }
+
+        for(App_p &sub : subcommands_) {
+            if(sub->get_name().empty() || !sub->parse_complete_callback_)
+                sub->_process_env();
+        }
+    }
+
+    /// Process callbacks. Runs on *all* subcommands.
+    void _process_callbacks() {
+
+        for(App_p &sub : subcommands_) {
+            // process the priority option_groups first
+            if(sub->get_name().empty() && sub->parse_complete_callback_) {
+                if(sub->count_all() > 0) {
+                    sub->_process_callbacks();
+                    sub->run_callback();
+                }
+            }
+        }
+
+        for(const Option_p &opt : options_) {
+            if((*opt) && !opt->get_callback_run()) {
+                opt->run_callback();
+            }
+        }
+        for(App_p &sub : subcommands_) {
+            if(!sub->parse_complete_callback_) {
+                sub->_process_callbacks();
+            }
+        }
+    }
+
+    /// Run help flag processing if any are found.
+    ///
+    /// The flags allow recursive calls to remember if there was a help flag on a parent.
+    void _process_help_flags(bool trigger_help = false, bool trigger_all_help = false) const {
+        const Option *help_ptr = get_help_ptr();
+        const Option *help_all_ptr = get_help_all_ptr();
+
+        if(help_ptr != nullptr && help_ptr->count() > 0)
+            trigger_help = true;
+        if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
+            trigger_all_help = true;
+
+        // If there were parsed subcommands, call those. First subcommand wins if there are multiple ones.
+        if(!parsed_subcommands_.empty()) {
+            for(const App *sub : parsed_subcommands_)
+                sub->_process_help_flags(trigger_help, trigger_all_help);
+
+            // Only the final subcommand should call for help. All help wins over help.
+        } else if(trigger_all_help) {
+            throw CallForAllHelp();
+        } else if(trigger_help) {
+            throw CallForHelp();
+        }
+    }
+
+    /// Verify required options and cross requirements. Subcommands too (only if selected).
+    void _process_requirements() {
+        // check excludes
+        bool excluded{false};
+        std::string excluder;
+        for(auto &opt : exclude_options_) {
+            if(opt->count() > 0) {
+                excluded = true;
+                excluder = opt->get_name();
+            }
+        }
+        for(auto &subc : exclude_subcommands_) {
+            if(subc->count_all() > 0) {
+                excluded = true;
+                excluder = subc->get_display_name();
+            }
+        }
+        if(excluded) {
+            if(count_all() > 0) {
+                throw ExcludesError(get_display_name(), excluder);
+            }
+            // if we are excluded but didn't receive anything, just return
+            return;
+        }
+
+        // check excludes
+        bool missing_needed{false};
+        std::string missing_need;
+        for(auto &opt : need_options_) {
+            if(opt->count() == 0) {
+                missing_needed = true;
+                missing_need = opt->get_name();
+            }
+        }
+        for(auto &subc : need_subcommands_) {
+            if(subc->count_all() == 0) {
+                missing_needed = true;
+                missing_need = subc->get_display_name();
+            }
+        }
+        if(missing_needed) {
+            if(count_all() > 0) {
+                throw RequiresError(get_display_name(), missing_need);
+            }
+            // if we missing something but didn't have any options, just return
+            return;
+        }
+
+        std::size_t used_options = 0;
+        for(const Option_p &opt : options_) {
+
+            if(opt->count() != 0) {
+                ++used_options;
+            }
+            // Required but empty
+            if(opt->get_required() && opt->count() == 0) {
+                throw RequiredError(opt->get_name());
+            }
+            // Requires
+            for(const Option *opt_req : opt->needs_)
+                if(opt->count() > 0 && opt_req->count() == 0)
+                    throw RequiresError(opt->get_name(), opt_req->get_name());
+            // Excludes
+            for(const Option *opt_ex : opt->excludes_)
+                if(opt->count() > 0 && opt_ex->count() != 0)
+                    throw ExcludesError(opt->get_name(), opt_ex->get_name());
+        }
+        // check for the required number of subcommands
+        if(require_subcommand_min_ > 0) {
+            auto selected_subcommands = get_subcommands();
+            if(require_subcommand_min_ > selected_subcommands.size())
+                throw RequiredError::Subcommand(require_subcommand_min_);
+        }
+
+        // Max error cannot occur, the extra subcommand will parse as an ExtrasError or a remaining item.
+
+        // run this loop to check how many unnamed subcommands were actually used since they are considered options
+        // from the perspective of an App
+        for(App_p &sub : subcommands_) {
+            if(sub->disabled_)
+                continue;
+            if(sub->name_.empty() && sub->count_all() > 0) {
+                ++used_options;
+            }
+        }
+
+        if(require_option_min_ > used_options || (require_option_max_ > 0 && require_option_max_ < used_options)) {
+            auto option_list = detail::join(options_, [this](const Option_p &ptr) {
+                if(ptr.get() == help_ptr_ || ptr.get() == help_all_ptr_) {
+                    return std::string{};
+                }
+                return ptr->get_name(false, true);
+            });
+
+            auto subc_list = get_subcommands([](App *app) { return ((app->get_name().empty()) && (!app->disabled_)); });
+            if(!subc_list.empty()) {
+                option_list += "," + detail::join(subc_list, [](const App *app) { return app->get_display_name(); });
+            }
+            throw RequiredError::Option(require_option_min_, require_option_max_, used_options, option_list);
+        }
+
+        // now process the requirements for subcommands if needed
+        for(App_p &sub : subcommands_) {
+            if(sub->disabled_)
+                continue;
+            if(sub->name_.empty() && sub->required_ == false) {
+                if(sub->count_all() == 0) {
+                    if(require_option_min_ > 0 && require_option_min_ <= used_options) {
+                        continue;
+                        // if we have met the requirement and there is nothing in this option group skip checking
+                        // requirements
+                    }
+                    if(require_option_max_ > 0 && used_options >= require_option_min_) {
+                        continue;
+                        // if we have met the requirement and there is nothing in this option group skip checking
+                        // requirements
+                    }
+                }
+            }
+            if(sub->count() > 0 || sub->name_.empty()) {
+                sub->_process_requirements();
+            }
+
+            if(sub->required_ && sub->count_all() == 0) {
+                throw(CLI::RequiredError(sub->get_display_name()));
+            }
+        }
+    }
+
+    /// Process callbacks and such.
+    void _process() {
+        CLI::FileError fe("ne");
+        bool caught_error{false};
+        try {
+            // the config file might generate a FileError but that should not be processed until later in the process
+            // to allow for help, version and other errors to generate first.
+            _process_config_file();
+            // process env shouldn't throw but no reason to process it if config generated an error
+            _process_env();
+        } catch(const CLI::FileError &fe2) {
+            fe = fe2;
+            caught_error = true;
+        }
+        // callbacks and help_flags can generate exceptions which should take priority over the config file error if one
+        // exists
+        _process_callbacks();
+        _process_help_flags();
+
+        if(caught_error) {
+            throw CLI::FileError(std::move(fe));
+        }
+
+        _process_requirements();
+    }
+
+    /// Throw an error if anything is left over and should not be.
+    void _process_extras() {
+        if(!(allow_extras_ || prefix_command_)) {
+            std::size_t num_left_over = remaining_size();
+            if(num_left_over > 0) {
+                throw ExtrasError(name_, remaining(false));
+            }
+        }
+
+        for(App_p &sub : subcommands_) {
+            if(sub->count() > 0)
+                sub->_process_extras();
+        }
+    }
+
+    /// Throw an error if anything is left over and should not be.
+    /// Modifies the args to fill in the missing items before throwing.
+    void _process_extras(std::vector<std::string> &args) {
+        if(!(allow_extras_ || prefix_command_)) {
+            std::size_t num_left_over = remaining_size();
+            if(num_left_over > 0) {
+                args = remaining(false);
+                throw ExtrasError(name_, args);
+            }
+        }
+
+        for(App_p &sub : subcommands_) {
+            if(sub->count() > 0)
+                sub->_process_extras(args);
+        }
+    }
+
+    /// Internal function to recursively increment the parsed counter on the current app as well unnamed subcommands
+    void increment_parsed() {
+        ++parsed_;
+        for(App_p &sub : subcommands_) {
+            if(sub->get_name().empty())
+                sub->increment_parsed();
+        }
+    }
+    /// Internal parse function
+    void _parse(std::vector<std::string> &args) {
+        increment_parsed();
+        _trigger_pre_parse(args.size());
+        bool positional_only = false;
+
+        while(!args.empty()) {
+            if(!_parse_single(args, positional_only)) {
+                break;
+            }
+        }
+
+        if(parent_ == nullptr) {
+            _process();
+
+            // Throw error if any items are left over (depending on settings)
+            _process_extras(args);
+
+            // Convert missing (pairs) to extras (string only) ready for processing in another app
+            args = remaining_for_passthrough(false);
+        } else if(parse_complete_callback_) {
+            _process_env();
+            _process_callbacks();
+            _process_help_flags();
+            _process_requirements();
+            run_callback(false, true);
+        }
+    }
+
+    /// Internal parse function
+    void _parse(std::vector<std::string> &&args) {
+        // this can only be called by the top level in which case parent == nullptr by definition
+        // operation is simplified
+        increment_parsed();
+        _trigger_pre_parse(args.size());
+        bool positional_only = false;
+
+        while(!args.empty()) {
+            _parse_single(args, positional_only);
+        }
+        _process();
+
+        // Throw error if any items are left over (depending on settings)
+        _process_extras();
+    }
+
+    /// Internal function to parse a stream
+    void _parse_stream(std::istream &input) {
+        auto values = config_formatter_->from_config(input);
+        _parse_config(values);
+        increment_parsed();
+        _trigger_pre_parse(values.size());
+        _process();
+
+        // Throw error if any items are left over (depending on settings)
+        _process_extras();
+    }
+
+    /// Parse one config param, return false if not found in any subcommand, remove if it is
+    ///
+    /// If this has more than one dot.separated.name, go into the subcommand matching it
+    /// Returns true if it managed to find the option, if false you'll need to remove the arg manually.
+    void _parse_config(const std::vector<ConfigItem> &args) {
+        for(const ConfigItem &item : args) {
+            if(!_parse_single_config(item) && allow_config_extras_ == config_extras_mode::error)
+                throw ConfigError::Extras(item.fullname());
+        }
+    }
+
+    /// Fill in a single config option
+    bool _parse_single_config(const ConfigItem &item, std::size_t level = 0) {
+        if(level < item.parents.size()) {
+            try {
+                auto subcom = get_subcommand(item.parents.at(level));
+                auto result = subcom->_parse_single_config(item, level + 1);
+
+                return result;
+            } catch(const OptionNotFound &) {
+                return false;
+            }
+        }
+        // check for section open
+        if(item.name == "++") {
+            if(configurable_) {
+                increment_parsed();
+                _trigger_pre_parse(2);
+                if(parent_ != nullptr) {
+                    parent_->parsed_subcommands_.push_back(this);
+                }
+            }
+            return true;
+        }
+        // check for section close
+        if(item.name == "--") {
+            if(configurable_) {
+                _process_callbacks();
+                _process_requirements();
+                run_callback();
+            }
+            return true;
+        }
+        Option *op = get_option_no_throw("--" + item.name);
+        if(op == nullptr) {
+            if(item.name.size() == 1) {
+                op = get_option_no_throw("-" + item.name);
+            }
+        }
+        if(op == nullptr) {
+            op = get_option_no_throw(item.name);
+        }
+        if(op == nullptr) {
+            // If the option was not present
+            if(get_allow_config_extras() == config_extras_mode::capture)
+                // Should we worry about classifying the extras properly?
+                missing_.emplace_back(detail::Classifier::NONE, item.fullname());
+            return false;
+        }
+
+        if(!op->get_configurable()) {
+            if(get_allow_config_extras() == config_extras_mode::ignore_all) {
+                return false;
+            }
+            throw ConfigError::NotConfigurable(item.fullname());
+        }
+
+        if(op->empty()) {
+            // Flag parsing
+            if(op->get_expected_min() == 0) {
+                auto res = config_formatter_->to_flag(item);
+                res = op->get_flag_value(item.name, res);
+
+                op->add_result(res);
+
+            } else {
+                op->add_result(item.inputs);
+                op->run_callback();
+            }
+        }
+
+        return true;
+    }
+
+    /// Parse "one" argument (some may eat more than one), delegate to parent if fails, add to missing if missing
+    /// from master return false if the parse has failed and needs to return to parent
+    bool _parse_single(std::vector<std::string> &args, bool &positional_only) {
+        bool retval = true;
+        detail::Classifier classifier = positional_only ? detail::Classifier::NONE : _recognize(args.back());
+        switch(classifier) {
+        case detail::Classifier::POSITIONAL_MARK:
+            args.pop_back();
+            positional_only = true;
+            if((!_has_remaining_positionals()) && (parent_ != nullptr)) {
+                retval = false;
+            } else {
+                _move_to_missing(classifier, "--");
+            }
+            break;
+        case detail::Classifier::SUBCOMMAND_TERMINATOR:
+            // treat this like a positional mark if in the parent app
+            args.pop_back();
+            retval = false;
+            break;
+        case detail::Classifier::SUBCOMMAND:
+            retval = _parse_subcommand(args);
+            break;
+        case detail::Classifier::LONG:
+        case detail::Classifier::SHORT:
+        case detail::Classifier::WINDOWS_STYLE:
+            // If already parsed a subcommand, don't accept options_
+            _parse_arg(args, classifier);
+            break;
+        case detail::Classifier::NONE:
+            // Probably a positional or something for a parent (sub)command
+            retval = _parse_positional(args, false);
+            if(retval && positionals_at_end_) {
+                positional_only = true;
+            }
+            break;
+            // LCOV_EXCL_START
+        default:
+            throw HorribleError("unrecognized classifier (you should not see this!)");
+            // LCOV_EXCL_STOP
+        }
+        return retval;
+    }
+
+    /// Count the required remaining positional arguments
+    std::size_t _count_remaining_positionals(bool required_only = false) const {
+        std::size_t retval = 0;
+        for(const Option_p &opt : options_) {
+            if(opt->get_positional() && (!required_only || opt->get_required())) {
+                if(opt->get_items_expected_min() > 0 &&
+                   static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
+                    retval += static_cast<std::size_t>(opt->get_items_expected_min()) - opt->count();
+                }
+            }
+        }
+        return retval;
+    }
+
+    /// Count the required remaining positional arguments
+    bool _has_remaining_positionals() const {
+        for(const Option_p &opt : options_) {
+            if(opt->get_positional() && ((static_cast<int>(opt->count()) < opt->get_items_expected_min()))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// Parse a positional, go up the tree to check
+    /// @param haltOnSubcommand if set to true the operation will not process subcommands merely return false
+    /// Return true if the positional was used false otherwise
+    bool _parse_positional(std::vector<std::string> &args, bool haltOnSubcommand) {
+
+        const std::string &positional = args.back();
+
+        if(positionals_at_end_) {
+            // deal with the case of required arguments at the end which should take precedence over other arguments
+            auto arg_rem = args.size();
+            auto remreq = _count_remaining_positionals(true);
+            if(arg_rem <= remreq) {
+                for(const Option_p &opt : options_) {
+                    if(opt->get_positional() && opt->required_) {
+                        if(static_cast<int>(opt->count()) < opt->get_items_expected_min()) {
+                            if(validate_positionals_) {
+                                std::string pos = positional;
+                                pos = opt->_validate(pos, 0);
+                                if(!pos.empty()) {
+                                    continue;
+                                }
+                            }
+                            opt->add_result(positional);
+                            parse_order_.push_back(opt.get());
+                            args.pop_back();
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        for(const Option_p &opt : options_) {
+            // Eat options, one by one, until done
+            if(opt->get_positional() &&
+               (static_cast<int>(opt->count()) < opt->get_items_expected_min() || opt->get_allow_extra_args())) {
+                if(validate_positionals_) {
+                    std::string pos = positional;
+                    pos = opt->_validate(pos, 0);
+                    if(!pos.empty()) {
+                        continue;
+                    }
+                }
+                opt->add_result(positional);
+                parse_order_.push_back(opt.get());
+                args.pop_back();
+                return true;
+            }
+        }
+
+        for(auto &subc : subcommands_) {
+            if((subc->name_.empty()) && (!subc->disabled_)) {
+                if(subc->_parse_positional(args, false)) {
+                    if(!subc->pre_parse_called_) {
+                        subc->_trigger_pre_parse(args.size());
+                    }
+                    return true;
+                }
+            }
+        }
+        // let the parent deal with it if possible
+        if(parent_ != nullptr && fallthrough_)
+            return _get_fallthrough_parent()->_parse_positional(args, static_cast<bool>(parse_complete_callback_));
+
+        /// Try to find a local subcommand that is repeated
+        auto com = _find_subcommand(args.back(), true, false);
+        if(com != nullptr && (require_subcommand_max_ == 0 || require_subcommand_max_ > parsed_subcommands_.size())) {
+            if(haltOnSubcommand) {
+                return false;
+            }
+            args.pop_back();
+            com->_parse(args);
+            return true;
+        }
+        /// now try one last gasp at subcommands that have been executed before, go to root app and try to find a
+        /// subcommand in a broader way, if one exists let the parent deal with it
+        auto parent_app = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
+        com = parent_app->_find_subcommand(args.back(), true, false);
+        if(com != nullptr && (com->parent_->require_subcommand_max_ == 0 ||
+                              com->parent_->require_subcommand_max_ > com->parent_->parsed_subcommands_.size())) {
+            return false;
+        }
+
+        if(positionals_at_end_) {
+            throw CLI::ExtrasError(name_, args);
+        }
+        /// If this is an option group don't deal with it
+        if(parent_ != nullptr && name_.empty()) {
+            return false;
+        }
+        /// We are out of other options this goes to missing
+        _move_to_missing(detail::Classifier::NONE, positional);
+        args.pop_back();
+        if(prefix_command_) {
+            while(!args.empty()) {
+                _move_to_missing(detail::Classifier::NONE, args.back());
+                args.pop_back();
+            }
+        }
+
+        return true;
+    }
+
+    /// Locate a subcommand by name with two conditions, should disabled subcommands be ignored, and should used
+    /// subcommands be ignored
+    App *_find_subcommand(const std::string &subc_name, bool ignore_disabled, bool ignore_used) const noexcept {
+        for(const App_p &com : subcommands_) {
+            if(com->disabled_ && ignore_disabled)
+                continue;
+            if(com->get_name().empty()) {
+                auto subc = com->_find_subcommand(subc_name, ignore_disabled, ignore_used);
+                if(subc != nullptr) {
+                    return subc;
+                }
+            }
+            if(com->check_name(subc_name)) {
+                if((!*com) || !ignore_used)
+                    return com.get();
+            }
+        }
+        return nullptr;
+    }
+
+    /// Parse a subcommand, modify args and continue
+    ///
+    /// Unlike the others, this one will always allow fallthrough
+    /// return true if the subcommand was processed false otherwise
+    bool _parse_subcommand(std::vector<std::string> &args) {
+        if(_count_remaining_positionals(/* required */ true) > 0) {
+            _parse_positional(args, false);
+            return true;
+        }
+        auto com = _find_subcommand(args.back(), true, true);
+        if(com != nullptr) {
+            args.pop_back();
+            if(!com->silent_) {
+                parsed_subcommands_.push_back(com);
+            }
+            com->_parse(args);
+            auto parent_app = com->parent_;
+            while(parent_app != this) {
+                parent_app->_trigger_pre_parse(args.size());
+                if(!com->silent_) {
+                    parent_app->parsed_subcommands_.push_back(com);
+                }
+                parent_app = parent_app->parent_;
+            }
+            return true;
+        }
+
+        if(parent_ == nullptr)
+            throw HorribleError("Subcommand " + args.back() + " missing");
+        return false;
+    }
+
+    /// Parse a short (false) or long (true) argument, must be at the top of the list
+    /// return true if the argument was processed or false if nothing was done
+    bool _parse_arg(std::vector<std::string> &args, detail::Classifier current_type) {
+
+        std::string current = args.back();
+
+        std::string arg_name;
+        std::string value;
+        std::string rest;
+
+        switch(current_type) {
+        case detail::Classifier::LONG:
+            if(!detail::split_long(current, arg_name, value))
+                throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
+            break;
+        case detail::Classifier::SHORT:
+            if(!detail::split_short(current, arg_name, rest))
+                throw HorribleError("Short parsed but missing! You should not see this");
+            break;
+        case detail::Classifier::WINDOWS_STYLE:
+            if(!detail::split_windows_style(current, arg_name, value))
+                throw HorribleError("windows option parsed but missing! You should not see this");
+            break;
+        case detail::Classifier::SUBCOMMAND:
+        case detail::Classifier::SUBCOMMAND_TERMINATOR:
+        case detail::Classifier::POSITIONAL_MARK:
+        case detail::Classifier::NONE:
+        default:
+            throw HorribleError("parsing got called with invalid option! You should not see this");
+        }
+
+        auto op_ptr =
+            std::find_if(std::begin(options_), std::end(options_), [arg_name, current_type](const Option_p &opt) {
+                if(current_type == detail::Classifier::LONG)
+                    return opt->check_lname(arg_name);
+                if(current_type == detail::Classifier::SHORT)
+                    return opt->check_sname(arg_name);
+                // this will only get called for detail::Classifier::WINDOWS_STYLE
+                return opt->check_lname(arg_name) || opt->check_sname(arg_name);
+            });
+
+        // Option not found
+        if(op_ptr == std::end(options_)) {
+            for(auto &subc : subcommands_) {
+                if(subc->name_.empty() && !subc->disabled_) {
+                    if(subc->_parse_arg(args, current_type)) {
+                        if(!subc->pre_parse_called_) {
+                            subc->_trigger_pre_parse(args.size());
+                        }
+                        return true;
+                    }
+                }
+            }
+            // If a subcommand, try the master command
+            if(parent_ != nullptr && fallthrough_)
+                return _get_fallthrough_parent()->_parse_arg(args, current_type);
+            // don't capture missing if this is a nameless subcommand
+            if(parent_ != nullptr && name_.empty()) {
+                return false;
+            }
+            // Otherwise, add to missing
+            args.pop_back();
+            _move_to_missing(current_type, current);
+            return true;
+        }
+
+        args.pop_back();
+
+        // Get a reference to the pointer to make syntax bearable
+        Option_p &op = *op_ptr;
+        /// if we require a separator add it here
+        if(op->get_inject_separator()) {
+            if(!op->results().empty() && !op->results().back().empty()) {
+                op->add_result(std::string{});
+            }
+        }
+        if(op->get_trigger_on_parse() && op->current_option_state_ == Option::option_state::callback_run) {
+            op->clear();
+        }
+        int min_num = (std::min)(op->get_type_size_min(), op->get_items_expected_min());
+        int max_num = op->get_items_expected_max();
+        // check container like options to limit the argument size to a single type if the allow_extra_flags argument is
+        // set. 16 is somewhat arbitrary (needs to be at least 4)
+        if(max_num >= detail::expected_max_vector_size / 16 && !op->get_allow_extra_args()) {
+            auto tmax = op->get_type_size_max();
+            max_num = detail::checked_multiply(tmax, op->get_expected_min()) ? tmax : detail::expected_max_vector_size;
+        }
+        // Make sure we always eat the minimum for unlimited vectors
+        int collected = 0;     // total number of arguments collected
+        int result_count = 0;  // local variable for number of results in a single arg string
+        // deal with purely flag like things
+        if(max_num == 0) {
+            auto res = op->get_flag_value(arg_name, value);
+            op->add_result(res);
+            parse_order_.push_back(op.get());
+        } else if(!value.empty()) {  // --this=value
+            op->add_result(value, result_count);
+            parse_order_.push_back(op.get());
+            collected += result_count;
+            // -Trest
+        } else if(!rest.empty()) {
+            op->add_result(rest, result_count);
+            parse_order_.push_back(op.get());
+            rest = "";
+            collected += result_count;
+        }
+
+        // gather the minimum number of arguments
+        while(min_num > collected && !args.empty()) {
+            std::string current_ = args.back();
+            args.pop_back();
+            op->add_result(current_, result_count);
+            parse_order_.push_back(op.get());
+            collected += result_count;
+        }
+
+        if(min_num > collected) {  // if we have run out of arguments and the minimum was not met
+            throw ArgumentMismatch::TypedAtLeast(op->get_name(), min_num, op->get_type_name());
+        }
+
+        if(max_num > collected || op->get_allow_extra_args()) {  // we allow optional arguments
+            auto remreqpos = _count_remaining_positionals(true);
+            // we have met the minimum now optionally check up to the maximum
+            while((collected < max_num || op->get_allow_extra_args()) && !args.empty() &&
+                  _recognize(args.back(), false) == detail::Classifier::NONE) {
+                // If any required positionals remain, don't keep eating
+                if(remreqpos >= args.size()) {
+                    break;
+                }
+
+                op->add_result(args.back(), result_count);
+                parse_order_.push_back(op.get());
+                args.pop_back();
+                collected += result_count;
+            }
+
+            // Allow -- to end an unlimited list and "eat" it
+            if(!args.empty() && _recognize(args.back()) == detail::Classifier::POSITIONAL_MARK)
+                args.pop_back();
+            // optional flag that didn't receive anything now get the default value
+            if(min_num == 0 && max_num > 0 && collected == 0) {
+                auto res = op->get_flag_value(arg_name, std::string{});
+                op->add_result(res);
+                parse_order_.push_back(op.get());
+            }
+        }
+
+        // if we only partially completed a type then add an empty string for later processing
+        if(min_num > 0 && op->get_type_size_max() != min_num && (collected % op->get_type_size_max()) != 0) {
+            op->add_result(std::string{});
+        }
+        if(op->get_trigger_on_parse()) {
+            op->run_callback();
+        }
+        if(!rest.empty()) {
+            rest = "-" + rest;
+            args.push_back(rest);
+        }
+        return true;
+    }
+
+    /// Trigger the pre_parse callback if needed
+    void _trigger_pre_parse(std::size_t remaining_args) {
+        if(!pre_parse_called_) {
+            pre_parse_called_ = true;
+            if(pre_parse_callback_) {
+                pre_parse_callback_(remaining_args);
+            }
+        } else if(immediate_callback_) {
+            if(!name_.empty()) {
+                auto pcnt = parsed_;
+                auto extras = std::move(missing_);
+                clear();
+                parsed_ = pcnt;
+                pre_parse_called_ = true;
+                missing_ = std::move(extras);
+            }
+        }
+    }
+
+    /// Get the appropriate parent to fallthrough to which is the first one that has a name or the main app
+    App *_get_fallthrough_parent() {
+        if(parent_ == nullptr) {
+            throw(HorribleError("No Valid parent"));
+        }
+        auto fallthrough_parent = parent_;
+        while((fallthrough_parent->parent_ != nullptr) && (fallthrough_parent->get_name().empty())) {
+            fallthrough_parent = fallthrough_parent->parent_;
+        }
+        return fallthrough_parent;
+    }
+
+    /// Helper function to run through all possible comparisons of subcommand names to check there is no overlap
+    const std::string &_compare_subcommand_names(const App &subcom, const App &base) const {
+        static const std::string estring;
+        if(subcom.disabled_) {
+            return estring;
+        }
+        for(auto &subc : base.subcommands_) {
+            if(subc.get() != &subcom) {
+                if(subc->disabled_) {
+                    continue;
+                }
+                if(!subcom.get_name().empty()) {
+                    if(subc->check_name(subcom.get_name())) {
+                        return subcom.get_name();
+                    }
+                }
+                if(!subc->get_name().empty()) {
+                    if(subcom.check_name(subc->get_name())) {
+                        return subc->get_name();
+                    }
+                }
+                for(const auto &les : subcom.aliases_) {
+                    if(subc->check_name(les)) {
+                        return les;
+                    }
+                }
+                // this loop is needed in case of ignore_underscore or ignore_case on one but not the other
+                for(const auto &les : subc->aliases_) {
+                    if(subcom.check_name(les)) {
+                        return les;
+                    }
+                }
+                // if the subcommand is an option group we need to check deeper
+                if(subc->get_name().empty()) {
+                    auto &cmpres = _compare_subcommand_names(subcom, *subc);
+                    if(!cmpres.empty()) {
+                        return cmpres;
+                    }
+                }
+                // if the test subcommand is an option group we need to check deeper
+                if(subcom.get_name().empty()) {
+                    auto &cmpres = _compare_subcommand_names(*subc, subcom);
+                    if(!cmpres.empty()) {
+                        return cmpres;
+                    }
+                }
+            }
+        }
+        return estring;
+    }
+    /// Helper function to place extra values in the most appropriate position
+    void _move_to_missing(detail::Classifier val_type, const std::string &val) {
+        if(allow_extras_ || subcommands_.empty()) {
+            missing_.emplace_back(val_type, val);
+            return;
+        }
+        // allow extra arguments to be places in an option group if it is allowed there
+        for(auto &subc : subcommands_) {
+            if(subc->name_.empty() && subc->allow_extras_) {
+                subc->missing_.emplace_back(val_type, val);
+                return;
+            }
+        }
+        // if we haven't found any place to put them yet put them in missing
+        missing_.emplace_back(val_type, val);
+    }
+
+  public:
+    /// function that could be used by subclasses of App to shift options around into subcommands
+    void _move_option(Option *opt, App *app) {
+        if(opt == nullptr) {
+            throw OptionNotFound("the option is NULL");
+        }
+        // verify that the give app is actually a subcommand
+        bool found = false;
+        for(auto &subc : subcommands_) {
+            if(app == subc.get()) {
+                found = true;
+            }
+        }
+        if(!found) {
+            throw OptionNotFound("The Given app is not a subcommand");
+        }
+
+        if((help_ptr_ == opt) || (help_all_ptr_ == opt))
+            throw OptionAlreadyAdded("cannot move help options");
+
+        if(config_ptr_ == opt)
+            throw OptionAlreadyAdded("cannot move config file options");
+
+        auto iterator =
+            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
+        if(iterator != std::end(options_)) {
+            const auto &opt_p = *iterator;
+            if(std::find_if(std::begin(app->options_), std::end(app->options_), [&opt_p](const Option_p &v) {
+                   return (*v == *opt_p);
+               }) == std::end(app->options_)) {
+                // only erase after the insertion was successful
+                app->options_.push_back(std::move(*iterator));
+                options_.erase(iterator);
+            } else {
+                throw OptionAlreadyAdded("option was not located: " + opt->get_name());
+            }
+        } else {
+            throw OptionNotFound("could not locate the given Option");
+        }
+    }
+};  // namespace CLI
+
+/// Extension of App to better manage groups of options
+class Option_group : public App {
+  public:
+    Option_group(std::string group_description, std::string group_name, App *parent)
+        : App(std::move(group_description), "", parent) {
+        group(group_name);
+        // option groups should have automatic fallthrough
+    }
+    using App::add_option;
+    /// Add an existing option to the Option_group
+    Option *add_option(Option *opt) {
+        if(get_parent() == nullptr) {
+            throw OptionNotFound("Unable to locate the specified option");
+        }
+        get_parent()->_move_option(opt, this);
+        return opt;
+    }
+    /// Add an existing option to the Option_group
+    void add_options(Option *opt) { add_option(opt); }
+    /// Add a bunch of options to the group
+    template <typename... Args> void add_options(Option *opt, Args... args) {
+        add_option(opt);
+        add_options(args...);
+    }
+    using App::add_subcommand;
+    /// Add an existing subcommand to be a member of an option_group
+    App *add_subcommand(App *subcom) {
+        App_p subc = subcom->get_parent()->get_subcommand_ptr(subcom);
+        subc->get_parent()->remove_subcommand(subcom);
+        add_subcommand(std::move(subc));
+        return subcom;
+    }
+};
+/// Helper function to enable one option group/subcommand when another is used
+inline void TriggerOn(App *trigger_app, App *app_to_enable) {
+    app_to_enable->enabled_by_default(false);
+    app_to_enable->disabled_by_default();
+    trigger_app->preparse_callback([app_to_enable](std::size_t) { app_to_enable->disabled(false); });
+}
+
+/// Helper function to enable one option group/subcommand when another is used
+inline void TriggerOn(App *trigger_app, std::vector<App *> apps_to_enable) {
+    for(auto &app : apps_to_enable) {
+        app->enabled_by_default(false);
+        app->disabled_by_default();
+    }
+
+    trigger_app->preparse_callback([apps_to_enable](std::size_t) {
+        for(auto &app : apps_to_enable) {
+            app->disabled(false);
+        }
+    });
+}
+
+/// Helper function to disable one option group/subcommand when another is used
+inline void TriggerOff(App *trigger_app, App *app_to_enable) {
+    app_to_enable->disabled_by_default(false);
+    app_to_enable->enabled_by_default();
+    trigger_app->preparse_callback([app_to_enable](std::size_t) { app_to_enable->disabled(); });
+}
+
+/// Helper function to disable one option group/subcommand when another is used
+inline void TriggerOff(App *trigger_app, std::vector<App *> apps_to_enable) {
+    for(auto &app : apps_to_enable) {
+        app->disabled_by_default(false);
+        app->enabled_by_default();
+    }
+
+    trigger_app->preparse_callback([apps_to_enable](std::size_t) {
+        for(auto &app : apps_to_enable) {
+            app->disabled();
+        }
+    });
+}
+
+/// Helper function to mark an option as deprecated
+inline void deprecate_option(Option *opt, const std::string &replacement = "") {
+    Validator deprecate_warning{[opt, replacement](std::string &) {
+                                    std::cout << opt->get_name() << " is deprecated please use '" << replacement
+                                              << "' instead\n";
+                                    return std::string();
+                                },
+                                "DEPRECATED"};
+    deprecate_warning.application_index(0);
+    opt->check(deprecate_warning);
+    if(!replacement.empty()) {
+        opt->description(opt->get_description() + " DEPRECATED: please use '" + replacement + "' instead");
+    }
+}
+
+/// Helper function to mark an option as deprecated
+inline void deprecate_option(App *app, const std::string &option_name, const std::string &replacement = "") {
+    auto opt = app->get_option(option_name);
+    deprecate_option(opt, replacement);
+}
+
+/// Helper function to mark an option as deprecated
+inline void deprecate_option(App &app, const std::string &option_name, const std::string &replacement = "") {
+    auto opt = app.get_option(option_name);
+    deprecate_option(opt, replacement);
+}
+
+/// Helper function to mark an option as retired
+inline void retire_option(App *app, Option *opt) {
+    App temp;
+    auto option_copy = temp.add_option(opt->get_name(false, true))
+                           ->type_size(opt->get_type_size_min(), opt->get_type_size_max())
+                           ->expected(opt->get_expected_min(), opt->get_expected_max())
+                           ->allow_extra_args(opt->get_allow_extra_args());
+
+    app->remove_option(opt);
+    auto opt2 = app->add_option(option_copy->get_name(false, true), "option has been retired and has no effect")
+                    ->type_name("RETIRED")
+                    ->default_str("RETIRED")
+                    ->type_size(option_copy->get_type_size_min(), option_copy->get_type_size_max())
+                    ->expected(option_copy->get_expected_min(), option_copy->get_expected_max())
+                    ->allow_extra_args(option_copy->get_allow_extra_args());
+
+    Validator retired_warning{[opt2](std::string &) {
+                                  std::cout << "WARNING " << opt2->get_name() << " is retired and has no effect\n";
+                                  return std::string();
+                              },
+                              ""};
+    retired_warning.application_index(0);
+    opt2->check(retired_warning);
+}
+
+/// Helper function to mark an option as retired
+inline void retire_option(App &app, Option *opt) { retire_option(&app, opt); }
+
+/// Helper function to mark an option as retired
+inline void retire_option(App *app, const std::string &option_name) {
+
+    auto opt = app->get_option_no_throw(option_name);
+    if(opt != nullptr) {
+        retire_option(app, opt);
+        return;
+    }
+    auto opt2 = app->add_option(option_name, "option has been retired and has no effect")
+                    ->type_name("RETIRED")
+                    ->expected(0, 1)
+                    ->default_str("RETIRED");
+    Validator retired_warning{[opt2](std::string &) {
+                                  std::cout << "WARNING " << opt2->get_name() << " is retired and has no effect\n";
+                                  return std::string();
+                              },
+                              ""};
+    retired_warning.application_index(0);
+    opt2->check(retired_warning);
+}
+
+/// Helper function to mark an option as retired
+inline void retire_option(App &app, const std::string &option_name) { retire_option(&app, option_name); }
+
+namespace FailureMessage {
+
+/// Printout a clean, simple message on error (the default in CLI11 1.5+)
+inline std::string simple(const App *app, const Error &e) {
+    std::string header = std::string(e.what()) + "\n";
+    std::vector<std::string> names;
+
+    // Collect names
+    if(app->get_help_ptr() != nullptr)
+        names.push_back(app->get_help_ptr()->get_name());
+
+    if(app->get_help_all_ptr() != nullptr)
+        names.push_back(app->get_help_all_ptr()->get_name());
+
+    // If any names found, suggest those
+    if(!names.empty())
+        header += "Run with " + detail::join(names, " or ") + " for more information.\n";
+
+    return header;
+}
+
+/// Printout the full help string on error (if this fn is set, the old default for CLI11)
+inline std::string help(const App *app, const Error &e) {
+    std::string header = std::string("ERROR: ") + e.get_name() + ": " + e.what() + "\n";
+    header += app->help();
+    return header;
+}
+
+}  // namespace FailureMessage
+
+namespace detail {
+/// This class is simply to allow tests access to App's protected functions
+struct AppFriend {
+#ifdef CLI11_CPP14
+
+    /// Wrap _parse_short, perfectly forward arguments and return
+    template <typename... Args> static decltype(auto) parse_arg(App *app, Args &&...args) {
+        return app->_parse_arg(std::forward<Args>(args)...);
+    }
+
+    /// Wrap _parse_subcommand, perfectly forward arguments and return
+    template <typename... Args> static decltype(auto) parse_subcommand(App *app, Args &&...args) {
+        return app->_parse_subcommand(std::forward<Args>(args)...);
+    }
+#else
+    /// Wrap _parse_short, perfectly forward arguments and return
+    template <typename... Args>
+    static auto parse_arg(App *app, Args &&...args) ->
+        typename std::result_of<decltype (&App::_parse_arg)(App, Args...)>::type {
+        return app->_parse_arg(std::forward<Args>(args)...);
+    }
+
+    /// Wrap _parse_subcommand, perfectly forward arguments and return
+    template <typename... Args>
+    static auto parse_subcommand(App *app, Args &&...args) ->
+        typename std::result_of<decltype (&App::_parse_subcommand)(App, Args...)>::type {
+        return app->_parse_subcommand(std::forward<Args>(args)...);
+    }
+#endif
+    /// Wrap the fallthrough parent function to make sure that is working correctly
+    static App *get_fallthrough_parent(App *app) { return app->_get_fallthrough_parent(); }
+};
+}  // namespace detail
+
+// [CLI11:app_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/CLI.hpp b/src/phasicFlow/commandLine/CLI/CLI.hpp
new file mode 100644
index 00000000..990ba407
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/CLI.hpp
@@ -0,0 +1,36 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// CLI Library includes
+// Order is important for combiner script
+
+#include "Version.hpp"
+
+#include "Macros.hpp"
+
+#include "StringTools.hpp"
+
+#include "Error.hpp"
+
+#include "TypeTools.hpp"
+
+#include "Split.hpp"
+
+#include "ConfigFwd.hpp"
+
+#include "Validators.hpp"
+
+#include "FormatterFwd.hpp"
+
+#include "Option.hpp"
+
+#include "App.hpp"
+
+#include "Config.hpp"
+
+#include "Formatter.hpp"
diff --git a/src/phasicFlow/commandLine/CLI/Config.hpp b/src/phasicFlow/commandLine/CLI/Config.hpp
new file mode 100644
index 00000000..57944eca
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Config.hpp
@@ -0,0 +1,396 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:set]
+
+#include "App.hpp"
+#include "ConfigFwd.hpp"
+#include "StringTools.hpp"
+
+namespace CLI {
+// [CLI11:config_hpp:verbatim]
+namespace detail {
+
+inline std::string convert_arg_for_ini(const std::string &arg, char stringQuote = '"', char characterQuote = '\'') {
+    if(arg.empty()) {
+        return std::string(2, stringQuote);
+    }
+    // some specifically supported strings
+    if(arg == "true" || arg == "false" || arg == "nan" || arg == "inf") {
+        return arg;
+    }
+    // floating point conversion can convert some hex codes, but don't try that here
+    if(arg.compare(0, 2, "0x") != 0 && arg.compare(0, 2, "0X") != 0) {
+        double val;
+        if(detail::lexical_cast(arg, val)) {
+            return arg;
+        }
+    }
+    // just quote a single non numeric character
+    if(arg.size() == 1) {
+        return std::string(1, characterQuote) + arg + characterQuote;
+    }
+    // handle hex, binary or octal arguments
+    if(arg.front() == '0') {
+        if(arg[1] == 'x') {
+            if(std::all_of(arg.begin() + 2, arg.end(), [](char x) {
+                   return (x >= '0' && x <= '9') || (x >= 'A' && x <= 'F') || (x >= 'a' && x <= 'f');
+               })) {
+                return arg;
+            }
+        } else if(arg[1] == 'o') {
+            if(std::all_of(arg.begin() + 2, arg.end(), [](char x) { return (x >= '0' && x <= '7'); })) {
+                return arg;
+            }
+        } else if(arg[1] == 'b') {
+            if(std::all_of(arg.begin() + 2, arg.end(), [](char x) { return (x == '0' || x == '1'); })) {
+                return arg;
+            }
+        }
+    }
+    if(arg.find_first_of(stringQuote) == std::string::npos) {
+        return std::string(1, stringQuote) + arg + stringQuote;
+    } else {
+        return characterQuote + arg + characterQuote;
+    }
+}
+
+/// Comma separated join, adds quotes if needed
+inline std::string ini_join(const std::vector<std::string> &args,
+                            char sepChar = ',',
+                            char arrayStart = '[',
+                            char arrayEnd = ']',
+                            char stringQuote = '"',
+                            char characterQuote = '\'') {
+    std::string joined;
+    if(args.size() > 1 && arrayStart != '\0') {
+        joined.push_back(arrayStart);
+    }
+    std::size_t start = 0;
+    for(const auto &arg : args) {
+        if(start++ > 0) {
+            joined.push_back(sepChar);
+            if(isspace(sepChar) == 0) {
+                joined.push_back(' ');
+            }
+        }
+        joined.append(convert_arg_for_ini(arg, stringQuote, characterQuote));
+    }
+    if(args.size() > 1 && arrayEnd != '\0') {
+        joined.push_back(arrayEnd);
+    }
+    return joined;
+}
+
+inline std::vector<std::string> generate_parents(const std::string &section, std::string &name, char parentSeparator) {
+    std::vector<std::string> parents;
+    if(detail::to_lower(section) != "default") {
+        if(section.find(parentSeparator) != std::string::npos) {
+            parents = detail::split(section, parentSeparator);
+        } else {
+            parents = {section};
+        }
+    }
+    if(name.find(parentSeparator) != std::string::npos) {
+        std::vector<std::string> plist = detail::split(name, parentSeparator);
+        name = plist.back();
+        detail::remove_quotes(name);
+        plist.pop_back();
+        parents.insert(parents.end(), plist.begin(), plist.end());
+    }
+
+    // clean up quotes on the parents
+    for(auto &parent : parents) {
+        detail::remove_quotes(parent);
+    }
+    return parents;
+}
+
+/// assuming non default segments do a check on the close and open of the segments in a configItem structure
+inline void
+checkParentSegments(std::vector<ConfigItem> &output, const std::string &currentSection, char parentSeparator) {
+
+    std::string estring;
+    auto parents = detail::generate_parents(currentSection, estring, parentSeparator);
+    if(!output.empty() && output.back().name == "--") {
+        std::size_t msize = (parents.size() > 1U) ? parents.size() : 2;
+        while(output.back().parents.size() >= msize) {
+            output.push_back(output.back());
+            output.back().parents.pop_back();
+        }
+
+        if(parents.size() > 1) {
+            std::size_t common = 0;
+            std::size_t mpair = (std::min)(output.back().parents.size(), parents.size() - 1);
+            for(std::size_t ii = 0; ii < mpair; ++ii) {
+                if(output.back().parents[ii] != parents[ii]) {
+                    break;
+                }
+                ++common;
+            }
+            if(common == mpair) {
+                output.pop_back();
+            } else {
+                while(output.back().parents.size() > common + 1) {
+                    output.push_back(output.back());
+                    output.back().parents.pop_back();
+                }
+            }
+            for(std::size_t ii = common; ii < parents.size() - 1; ++ii) {
+                output.emplace_back();
+                output.back().parents.assign(parents.begin(), parents.begin() + static_cast<std::ptrdiff_t>(ii) + 1);
+                output.back().name = "++";
+            }
+        }
+    } else if(parents.size() > 1) {
+        for(std::size_t ii = 0; ii < parents.size() - 1; ++ii) {
+            output.emplace_back();
+            output.back().parents.assign(parents.begin(), parents.begin() + static_cast<std::ptrdiff_t>(ii) + 1);
+            output.back().name = "++";
+        }
+    }
+
+    // insert a section end which is just an empty items_buffer
+    output.emplace_back();
+    output.back().parents = std::move(parents);
+    output.back().name = "++";
+}
+}  // namespace detail
+
+inline std::vector<ConfigItem> ConfigBase::from_config(std::istream &input) const {
+    std::string line;
+    std::string currentSection = "default";
+    std::string previousSection = "default";
+    std::vector<ConfigItem> output;
+    bool isDefaultArray = (arrayStart == '[' && arrayEnd == ']' && arraySeparator == ',');
+    bool isINIArray = (arrayStart == '\0' || arrayStart == ' ') && arrayStart == arrayEnd;
+    bool inSection{false};
+    char aStart = (isINIArray) ? '[' : arrayStart;
+    char aEnd = (isINIArray) ? ']' : arrayEnd;
+    char aSep = (isINIArray && arraySeparator == ' ') ? ',' : arraySeparator;
+    int currentSectionIndex{0};
+    while(getline(input, line)) {
+        std::vector<std::string> items_buffer;
+        std::string name;
+
+        detail::trim(line);
+        std::size_t len = line.length();
+        // lines have to be at least 3 characters to have any meaning to CLI just skip the rest
+        if(len < 3) {
+            continue;
+        }
+        if(line.front() == '[' && line.back() == ']') {
+            if(currentSection != "default") {
+                // insert a section end which is just an empty items_buffer
+                output.emplace_back();
+                output.back().parents = detail::generate_parents(currentSection, name, parentSeparatorChar);
+                output.back().name = "--";
+            }
+            currentSection = line.substr(1, len - 2);
+            // deal with double brackets for TOML
+            if(currentSection.size() > 1 && currentSection.front() == '[' && currentSection.back() == ']') {
+                currentSection = currentSection.substr(1, currentSection.size() - 2);
+            }
+            if(detail::to_lower(currentSection) == "default") {
+                currentSection = "default";
+            } else {
+                detail::checkParentSegments(output, currentSection, parentSeparatorChar);
+            }
+            inSection = false;
+            if(currentSection == previousSection) {
+                ++currentSectionIndex;
+            } else {
+                currentSectionIndex = 0;
+                previousSection = currentSection;
+            }
+            continue;
+        }
+
+        // comment lines
+        if(line.front() == ';' || line.front() == '#' || line.front() == commentChar) {
+            continue;
+        }
+
+        // Find = in string, split and recombine
+        auto pos = line.find(valueDelimiter);
+        if(pos != std::string::npos) {
+            name = detail::trim_copy(line.substr(0, pos));
+            std::string item = detail::trim_copy(line.substr(pos + 1));
+            auto cloc = item.find(commentChar);
+            if(cloc != std::string::npos) {
+                item.erase(cloc, std::string::npos);
+                detail::trim(item);
+            }
+            if(item.size() > 1 && item.front() == aStart) {
+                for(std::string multiline; item.back() != aEnd && std::getline(input, multiline);) {
+                    detail::trim(multiline);
+                    item += multiline;
+                }
+                items_buffer = detail::split_up(item.substr(1, item.length() - 2), aSep);
+            } else if((isDefaultArray || isINIArray) && item.find_first_of(aSep) != std::string::npos) {
+                items_buffer = detail::split_up(item, aSep);
+            } else if((isDefaultArray || isINIArray) && item.find_first_of(' ') != std::string::npos) {
+                items_buffer = detail::split_up(item);
+            } else {
+                items_buffer = {item};
+            }
+        } else {
+            name = detail::trim_copy(line);
+            auto cloc = name.find(commentChar);
+            if(cloc != std::string::npos) {
+                name.erase(cloc, std::string::npos);
+                detail::trim(name);
+            }
+
+            items_buffer = {"true"};
+        }
+        if(name.find(parentSeparatorChar) == std::string::npos) {
+            detail::remove_quotes(name);
+        }
+        // clean up quotes on the items
+        for(auto &it : items_buffer) {
+            detail::remove_quotes(it);
+        }
+
+        std::vector<std::string> parents = detail::generate_parents(currentSection, name, parentSeparatorChar);
+        if(parents.size() > maximumLayers) {
+            continue;
+        }
+        if(!configSection.empty() && !inSection) {
+            if(parents.empty() || parents.front() != configSection) {
+                continue;
+            }
+            if(configIndex >= 0 && currentSectionIndex != configIndex) {
+                continue;
+            }
+            parents.erase(parents.begin());
+            inSection = true;
+        }
+        if(!output.empty() && name == output.back().name && parents == output.back().parents) {
+            output.back().inputs.insert(output.back().inputs.end(), items_buffer.begin(), items_buffer.end());
+        } else {
+            output.emplace_back();
+            output.back().parents = std::move(parents);
+            output.back().name = std::move(name);
+            output.back().inputs = std::move(items_buffer);
+        }
+    }
+    if(currentSection != "default") {
+        // insert a section end which is just an empty items_buffer
+        std::string ename;
+        output.emplace_back();
+        output.back().parents = detail::generate_parents(currentSection, ename, parentSeparatorChar);
+        output.back().name = "--";
+        while(output.back().parents.size() > 1) {
+            output.push_back(output.back());
+            output.back().parents.pop_back();
+        }
+    }
+    return output;
+}
+
+inline std::string
+ConfigBase::to_config(const App *app, bool default_also, bool write_description, std::string prefix) const {
+    std::stringstream out;
+    std::string commentLead;
+    commentLead.push_back(commentChar);
+    commentLead.push_back(' ');
+
+    std::vector<std::string> groups = app->get_groups();
+    bool defaultUsed = false;
+    groups.insert(groups.begin(), std::string("Options"));
+    if(write_description && (app->get_configurable() || app->get_parent() == nullptr || app->get_name().empty())) {
+        out << commentLead << detail::fix_newlines(commentLead, app->get_description()) << '\n';
+    }
+    for(auto &group : groups) {
+        if(group == "Options" || group.empty()) {
+            if(defaultUsed) {
+                continue;
+            }
+            defaultUsed = true;
+        }
+        if(write_description && group != "Options" && !group.empty()) {
+            out << '\n' << commentLead << group << " Options\n";
+        }
+        for(const Option *opt : app->get_options({})) {
+
+            // Only process options that are configurable
+            if(opt->get_configurable()) {
+                if(opt->get_group() != group) {
+                    if(!(group == "Options" && opt->get_group().empty())) {
+                        continue;
+                    }
+                }
+                std::string name = prefix + opt->get_single_name();
+                std::string value = detail::ini_join(
+                    opt->reduced_results(), arraySeparator, arrayStart, arrayEnd, stringQuote, characterQuote);
+
+                if(value.empty() && default_also) {
+                    if(!opt->get_default_str().empty()) {
+                        value = detail::convert_arg_for_ini(opt->get_default_str(), stringQuote, characterQuote);
+                    } else if(opt->get_expected_min() == 0) {
+                        value = "false";
+                    } else if(opt->get_run_callback_for_default()) {
+                        value = "\"\"";  // empty string default value
+                    }
+                }
+
+                if(!value.empty()) {
+                    if(write_description && opt->has_description()) {
+                        out << '\n';
+                        out << commentLead << detail::fix_newlines(commentLead, opt->get_description()) << '\n';
+                    }
+                    out << name << valueDelimiter << value << '\n';
+                }
+            }
+        }
+    }
+    auto subcommands = app->get_subcommands({});
+    for(const App *subcom : subcommands) {
+        if(subcom->get_name().empty()) {
+            if(write_description && !subcom->get_group().empty()) {
+                out << '\n' << commentLead << subcom->get_group() << " Options\n";
+            }
+            out << to_config(subcom, default_also, write_description, prefix);
+        }
+    }
+
+    for(const App *subcom : subcommands) {
+        if(!subcom->get_name().empty()) {
+            if(subcom->get_configurable() && app->got_subcommand(subcom)) {
+                if(!prefix.empty() || app->get_parent() == nullptr) {
+                    out << '[' << prefix << subcom->get_name() << "]\n";
+                } else {
+                    std::string subname = app->get_name() + parentSeparatorChar + subcom->get_name();
+                    auto p = app->get_parent();
+                    while(p->get_parent() != nullptr) {
+                        subname = p->get_name() + parentSeparatorChar + subname;
+                        p = p->get_parent();
+                    }
+                    out << '[' << subname << "]\n";
+                }
+                out << to_config(subcom, default_also, write_description, "");
+            } else {
+                out << to_config(
+                    subcom, default_also, write_description, prefix + subcom->get_name() + parentSeparatorChar);
+            }
+        }
+    }
+
+    return out.str();
+}
+
+// [CLI11:config_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/ConfigFwd.hpp b/src/phasicFlow/commandLine/CLI/ConfigFwd.hpp
new file mode 100644
index 00000000..ef2ac345
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/ConfigFwd.hpp
@@ -0,0 +1,182 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+// [CLI11:public_includes:end]
+
+#include "Error.hpp"
+#include "StringTools.hpp"
+
+namespace CLI {
+// [CLI11:config_fwd_hpp:verbatim]
+
+class App;
+
+/// Holds values to load into Options
+struct ConfigItem {
+    /// This is the list of parents
+    std::vector<std::string> parents{};
+
+    /// This is the name
+    std::string name{};
+
+    /// Listing of inputs
+    std::vector<std::string> inputs{};
+
+    /// The list of parents and name joined by "."
+    std::string fullname() const {
+        std::vector<std::string> tmp = parents;
+        tmp.emplace_back(name);
+        return detail::join(tmp, ".");
+    }
+};
+
+/// This class provides a converter for configuration files.
+class Config {
+  protected:
+    std::vector<ConfigItem> items{};
+
+  public:
+    /// Convert an app into a configuration
+    virtual std::string to_config(const App *, bool, bool, std::string) const = 0;
+
+    /// Convert a configuration into an app
+    virtual std::vector<ConfigItem> from_config(std::istream &) const = 0;
+
+    /// Get a flag value
+    virtual std::string to_flag(const ConfigItem &item) const {
+        if(item.inputs.size() == 1) {
+            return item.inputs.at(0);
+        }
+        throw ConversionError::TooManyInputsFlag(item.fullname());
+    }
+
+    /// Parse a config file, throw an error (ParseError:ConfigParseError or FileError) on failure
+    std::vector<ConfigItem> from_file(const std::string &name) {
+        std::ifstream input{name};
+        if(!input.good())
+            throw FileError::Missing(name);
+
+        return from_config(input);
+    }
+
+    /// Virtual destructor
+    virtual ~Config() = default;
+};
+
+/// This converter works with INI/TOML files; to write INI files use ConfigINI
+class ConfigBase : public Config {
+  protected:
+    /// the character used for comments
+    char commentChar = '#';
+    /// the character used to start an array '\0' is a default to not use
+    char arrayStart = '[';
+    /// the character used to end an array '\0' is a default to not use
+    char arrayEnd = ']';
+    /// the character used to separate elements in an array
+    char arraySeparator = ',';
+    /// the character used separate the name from the value
+    char valueDelimiter = '=';
+    /// the character to use around strings
+    char stringQuote = '"';
+    /// the character to use around single characters
+    char characterQuote = '\'';
+    /// the maximum number of layers to allow
+    uint8_t maximumLayers{255};
+    /// the separator used to separator parent layers
+    char parentSeparatorChar{'.'};
+    /// Specify the configuration index to use for arrayed sections
+    int16_t configIndex{-1};
+    /// Specify the configuration section that should be used
+    std::string configSection{};
+
+  public:
+    std::string
+    to_config(const App * /*app*/, bool default_also, bool write_description, std::string prefix) const override;
+
+    std::vector<ConfigItem> from_config(std::istream &input) const override;
+    /// Specify the configuration for comment characters
+    ConfigBase *comment(char cchar) {
+        commentChar = cchar;
+        return this;
+    }
+    /// Specify the start and end characters for an array
+    ConfigBase *arrayBounds(char aStart, char aEnd) {
+        arrayStart = aStart;
+        arrayEnd = aEnd;
+        return this;
+    }
+    /// Specify the delimiter character for an array
+    ConfigBase *arrayDelimiter(char aSep) {
+        arraySeparator = aSep;
+        return this;
+    }
+    /// Specify the delimiter between a name and value
+    ConfigBase *valueSeparator(char vSep) {
+        valueDelimiter = vSep;
+        return this;
+    }
+    /// Specify the quote characters used around strings and characters
+    ConfigBase *quoteCharacter(char qString, char qChar) {
+        stringQuote = qString;
+        characterQuote = qChar;
+        return this;
+    }
+    /// Specify the maximum number of parents
+    ConfigBase *maxLayers(uint8_t layers) {
+        maximumLayers = layers;
+        return this;
+    }
+    /// Specify the separator to use for parent layers
+    ConfigBase *parentSeparator(char sep) {
+        parentSeparatorChar = sep;
+        return this;
+    }
+    /// get a reference to the configuration section
+    std::string &sectionRef() { return configSection; }
+    /// get the section
+    const std::string &section() const { return configSection; }
+    /// specify a particular section of the configuration file to use
+    ConfigBase *section(const std::string &sectionName) {
+        configSection = sectionName;
+        return this;
+    }
+
+    /// get a reference to the configuration index
+    int16_t &indexRef() { return configIndex; }
+    /// get the section index
+    int16_t index() const { return configIndex; }
+    /// specify a particular index in the section to use (-1) for all sections to use
+    ConfigBase *index(int16_t sectionIndex) {
+        configIndex = sectionIndex;
+        return this;
+    }
+};
+
+/// the default Config is the TOML file format
+using ConfigTOML = ConfigBase;
+
+/// ConfigINI generates a "standard" INI compliant output
+class ConfigINI : public ConfigTOML {
+
+  public:
+    ConfigINI() {
+        commentChar = ';';
+        arrayStart = '\0';
+        arrayEnd = '\0';
+        arraySeparator = ' ';
+        valueDelimiter = '=';
+    }
+};
+// [CLI11:config_fwd_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/Error.hpp b/src/phasicFlow/commandLine/CLI/Error.hpp
new file mode 100644
index 00000000..de3122bb
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Error.hpp
@@ -0,0 +1,351 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <exception>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:end]
+
+// CLI library includes
+#include "StringTools.hpp"
+
+namespace CLI {
+// [CLI11:error_hpp:verbatim]
+
+// Use one of these on all error classes.
+// These are temporary and are undef'd at the end of this file.
+#define CLI11_ERROR_DEF(parent, name)                                                                                  \
+  protected:                                                                                                           \
+    name(std::string ename, std::string msg, int exit_code) : parent(std::move(ename), std::move(msg), exit_code) {}   \
+    name(std::string ename, std::string msg, ExitCodes exit_code)                                                      \
+        : parent(std::move(ename), std::move(msg), exit_code) {}                                                       \
+                                                                                                                       \
+  public:                                                                                                              \
+    name(std::string msg, ExitCodes exit_code) : parent(#name, std::move(msg), exit_code) {}                           \
+    name(std::string msg, int exit_code) : parent(#name, std::move(msg), exit_code) {}
+
+// This is added after the one above if a class is used directly and builds its own message
+#define CLI11_ERROR_SIMPLE(name)                                                                                       \
+    explicit name(std::string msg) : name(#name, msg, ExitCodes::name) {}
+
+/// These codes are part of every error in CLI. They can be obtained from e using e.exit_code or as a quick shortcut,
+/// int values from e.get_error_code().
+enum class ExitCodes {
+    Success = 0,
+    IncorrectConstruction = 100,
+    BadNameString,
+    OptionAlreadyAdded,
+    FileError,
+    ConversionError,
+    ValidationError,
+    RequiredError,
+    RequiresError,
+    ExcludesError,
+    ExtrasError,
+    ConfigError,
+    InvalidError,
+    HorribleError,
+    OptionNotFound,
+    ArgumentMismatch,
+    BaseClass = 127
+};
+
+// Error definitions
+
+/// @defgroup error_group Errors
+/// @brief Errors thrown by CLI11
+///
+/// These are the errors that can be thrown. Some of them, like CLI::Success, are not really errors.
+/// @{
+
+/// All errors derive from this one
+class Error : public std::runtime_error {
+    int actual_exit_code;
+    std::string error_name{"Error"};
+
+  public:
+    int get_exit_code() const { return actual_exit_code; }
+
+    std::string get_name() const { return error_name; }
+
+    Error(std::string name, std::string msg, int exit_code = static_cast<int>(ExitCodes::BaseClass))
+        : runtime_error(msg), actual_exit_code(exit_code), error_name(std::move(name)) {}
+
+    Error(std::string name, std::string msg, ExitCodes exit_code) : Error(name, msg, static_cast<int>(exit_code)) {}
+};
+
+// Note: Using Error::Error constructors does not work on GCC 4.7
+
+/// Construction errors (not in parsing)
+class ConstructionError : public Error {
+    CLI11_ERROR_DEF(Error, ConstructionError)
+};
+
+/// Thrown when an option is set to conflicting values (non-vector and multi args, for example)
+class IncorrectConstruction : public ConstructionError {
+    CLI11_ERROR_DEF(ConstructionError, IncorrectConstruction)
+    CLI11_ERROR_SIMPLE(IncorrectConstruction)
+    static IncorrectConstruction PositionalFlag(std::string name) {
+        return IncorrectConstruction(name + ": Flags cannot be positional");
+    }
+    static IncorrectConstruction Set0Opt(std::string name) {
+        return IncorrectConstruction(name + ": Cannot set 0 expected, use a flag instead");
+    }
+    static IncorrectConstruction SetFlag(std::string name) {
+        return IncorrectConstruction(name + ": Cannot set an expected number for flags");
+    }
+    static IncorrectConstruction ChangeNotVector(std::string name) {
+        return IncorrectConstruction(name + ": You can only change the expected arguments for vectors");
+    }
+    static IncorrectConstruction AfterMultiOpt(std::string name) {
+        return IncorrectConstruction(
+            name + ": You can't change expected arguments after you've changed the multi option policy!");
+    }
+    static IncorrectConstruction MissingOption(std::string name) {
+        return IncorrectConstruction("Option " + name + " is not defined");
+    }
+    static IncorrectConstruction MultiOptionPolicy(std::string name) {
+        return IncorrectConstruction(name + ": multi_option_policy only works for flags and exact value options");
+    }
+};
+
+/// Thrown on construction of a bad name
+class BadNameString : public ConstructionError {
+    CLI11_ERROR_DEF(ConstructionError, BadNameString)
+    CLI11_ERROR_SIMPLE(BadNameString)
+    static BadNameString OneCharName(std::string name) { return BadNameString("Invalid one char name: " + name); }
+    static BadNameString BadLongName(std::string name) { return BadNameString("Bad long name: " + name); }
+    static BadNameString DashesOnly(std::string name) {
+        return BadNameString("Must have a name, not just dashes: " + name);
+    }
+    static BadNameString MultiPositionalNames(std::string name) {
+        return BadNameString("Only one positional name allowed, remove: " + name);
+    }
+};
+
+/// Thrown when an option already exists
+class OptionAlreadyAdded : public ConstructionError {
+    CLI11_ERROR_DEF(ConstructionError, OptionAlreadyAdded)
+    explicit OptionAlreadyAdded(std::string name)
+        : OptionAlreadyAdded(name + " is already added", ExitCodes::OptionAlreadyAdded) {}
+    static OptionAlreadyAdded Requires(std::string name, std::string other) {
+        return OptionAlreadyAdded(name + " requires " + other, ExitCodes::OptionAlreadyAdded);
+    }
+    static OptionAlreadyAdded Excludes(std::string name, std::string other) {
+        return OptionAlreadyAdded(name + " excludes " + other, ExitCodes::OptionAlreadyAdded);
+    }
+};
+
+// Parsing errors
+
+/// Anything that can error in Parse
+class ParseError : public Error {
+    CLI11_ERROR_DEF(Error, ParseError)
+};
+
+// Not really "errors"
+
+/// This is a successful completion on parsing, supposed to exit
+class Success : public ParseError {
+    CLI11_ERROR_DEF(ParseError, Success)
+    Success() : Success("Successfully completed, should be caught and quit", ExitCodes::Success) {}
+};
+
+/// -h or --help on command line
+class CallForHelp : public Success {
+    CLI11_ERROR_DEF(Success, CallForHelp)
+    CallForHelp() : CallForHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
+};
+
+/// Usually something like --help-all on command line
+class CallForAllHelp : public Success {
+    CLI11_ERROR_DEF(Success, CallForAllHelp)
+    CallForAllHelp()
+        : CallForAllHelp("This should be caught in your main function, see examples", ExitCodes::Success) {}
+};
+
+/// -v or --version on command line
+class CallForVersion : public Success {
+    CLI11_ERROR_DEF(Success, CallForVersion)
+    CallForVersion()
+        : CallForVersion("This should be caught in your main function, see examples", ExitCodes::Success) {}
+};
+
+/// Does not output a diagnostic in CLI11_PARSE, but allows main() to return with a specific error code.
+class RuntimeError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, RuntimeError)
+    explicit RuntimeError(int exit_code = 1) : RuntimeError("Runtime error", exit_code) {}
+};
+
+/// Thrown when parsing an INI file and it is missing
+class FileError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, FileError)
+    CLI11_ERROR_SIMPLE(FileError)
+    static FileError Missing(std::string name) { return FileError(name + " was not readable (missing?)"); }
+};
+
+/// Thrown when conversion call back fails, such as when an int fails to coerce to a string
+class ConversionError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ConversionError)
+    CLI11_ERROR_SIMPLE(ConversionError)
+    ConversionError(std::string member, std::string name)
+        : ConversionError("The value " + member + " is not an allowed value for " + name) {}
+    ConversionError(std::string name, std::vector<std::string> results)
+        : ConversionError("Could not convert: " + name + " = " + detail::join(results)) {}
+    static ConversionError TooManyInputsFlag(std::string name) {
+        return ConversionError(name + ": too many inputs for a flag");
+    }
+    static ConversionError TrueFalse(std::string name) {
+        return ConversionError(name + ": Should be true/false or a number");
+    }
+};
+
+/// Thrown when validation of results fails
+class ValidationError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ValidationError)
+    CLI11_ERROR_SIMPLE(ValidationError)
+    explicit ValidationError(std::string name, std::string msg) : ValidationError(name + ": " + msg) {}
+};
+
+/// Thrown when a required option is missing
+class RequiredError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, RequiredError)
+    explicit RequiredError(std::string name) : RequiredError(name + " is required", ExitCodes::RequiredError) {}
+    static RequiredError Subcommand(std::size_t min_subcom) {
+        if(min_subcom == 1) {
+            return RequiredError("A subcommand");
+        }
+        return RequiredError("Requires at least " + std::to_string(min_subcom) + " subcommands",
+                             ExitCodes::RequiredError);
+    }
+    static RequiredError
+    Option(std::size_t min_option, std::size_t max_option, std::size_t used, const std::string &option_list) {
+        if((min_option == 1) && (max_option == 1) && (used == 0))
+            return RequiredError("Exactly 1 option from [" + option_list + "]");
+        if((min_option == 1) && (max_option == 1) && (used > 1)) {
+            return RequiredError("Exactly 1 option from [" + option_list + "] is required and " + std::to_string(used) +
+                                     " were given",
+                                 ExitCodes::RequiredError);
+        }
+        if((min_option == 1) && (used == 0))
+            return RequiredError("At least 1 option from [" + option_list + "]");
+        if(used < min_option) {
+            return RequiredError("Requires at least " + std::to_string(min_option) + " options used and only " +
+                                     std::to_string(used) + "were given from [" + option_list + "]",
+                                 ExitCodes::RequiredError);
+        }
+        if(max_option == 1)
+            return RequiredError("Requires at most 1 options be given from [" + option_list + "]",
+                                 ExitCodes::RequiredError);
+
+        return RequiredError("Requires at most " + std::to_string(max_option) + " options be used and " +
+                                 std::to_string(used) + "were given from [" + option_list + "]",
+                             ExitCodes::RequiredError);
+    }
+};
+
+/// Thrown when the wrong number of arguments has been received
+class ArgumentMismatch : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ArgumentMismatch)
+    CLI11_ERROR_SIMPLE(ArgumentMismatch)
+    ArgumentMismatch(std::string name, int expected, std::size_t received)
+        : ArgumentMismatch(expected > 0 ? ("Expected exactly " + std::to_string(expected) + " arguments to " + name +
+                                           ", got " + std::to_string(received))
+                                        : ("Expected at least " + std::to_string(-expected) + " arguments to " + name +
+                                           ", got " + std::to_string(received)),
+                           ExitCodes::ArgumentMismatch) {}
+
+    static ArgumentMismatch AtLeast(std::string name, int num, std::size_t received) {
+        return ArgumentMismatch(name + ": At least " + std::to_string(num) + " required but received " +
+                                std::to_string(received));
+    }
+    static ArgumentMismatch AtMost(std::string name, int num, std::size_t received) {
+        return ArgumentMismatch(name + ": At Most " + std::to_string(num) + " required but received " +
+                                std::to_string(received));
+    }
+    static ArgumentMismatch TypedAtLeast(std::string name, int num, std::string type) {
+        return ArgumentMismatch(name + ": " + std::to_string(num) + " required " + type + " missing");
+    }
+    static ArgumentMismatch FlagOverride(std::string name) {
+        return ArgumentMismatch(name + " was given a disallowed flag override");
+    }
+};
+
+/// Thrown when a requires option is missing
+class RequiresError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, RequiresError)
+    RequiresError(std::string curname, std::string subname)
+        : RequiresError(curname + " requires " + subname, ExitCodes::RequiresError) {}
+};
+
+/// Thrown when an excludes option is present
+class ExcludesError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ExcludesError)
+    ExcludesError(std::string curname, std::string subname)
+        : ExcludesError(curname + " excludes " + subname, ExitCodes::ExcludesError) {}
+};
+
+/// Thrown when too many positionals or options are found
+class ExtrasError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ExtrasError)
+    explicit ExtrasError(std::vector<std::string> args)
+        : ExtrasError((args.size() > 1 ? "The following arguments were not expected: "
+                                       : "The following argument was not expected: ") +
+                          detail::rjoin(args, " "),
+                      ExitCodes::ExtrasError) {}
+    ExtrasError(const std::string &name, std::vector<std::string> args)
+        : ExtrasError(name,
+                      (args.size() > 1 ? "The following arguments were not expected: "
+                                       : "The following argument was not expected: ") +
+                          detail::rjoin(args, " "),
+                      ExitCodes::ExtrasError) {}
+};
+
+/// Thrown when extra values are found in an INI file
+class ConfigError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, ConfigError)
+    CLI11_ERROR_SIMPLE(ConfigError)
+    static ConfigError Extras(std::string item) { return ConfigError("INI was not able to parse " + item); }
+    static ConfigError NotConfigurable(std::string item) {
+        return ConfigError(item + ": This option is not allowed in a configuration file");
+    }
+};
+
+/// Thrown when validation fails before parsing
+class InvalidError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, InvalidError)
+    explicit InvalidError(std::string name)
+        : InvalidError(name + ": Too many positional arguments with unlimited expected args", ExitCodes::InvalidError) {
+    }
+};
+
+/// This is just a safety check to verify selection and parsing match - you should not ever see it
+/// Strings are directly added to this error, but again, it should never be seen.
+class HorribleError : public ParseError {
+    CLI11_ERROR_DEF(ParseError, HorribleError)
+    CLI11_ERROR_SIMPLE(HorribleError)
+};
+
+// After parsing
+
+/// Thrown when counting a non-existent option
+class OptionNotFound : public Error {
+    CLI11_ERROR_DEF(Error, OptionNotFound)
+    explicit OptionNotFound(std::string name) : OptionNotFound(name + " not found", ExitCodes::OptionNotFound) {}
+};
+
+#undef CLI11_ERROR_DEF
+#undef CLI11_ERROR_SIMPLE
+
+/// @}
+
+// [CLI11:error_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/Formatter.hpp b/src/phasicFlow/commandLine/CLI/Formatter.hpp
new file mode 100644
index 00000000..e45aa25d
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Formatter.hpp
@@ -0,0 +1,292 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <algorithm>
+#include <string>
+#include <vector>
+// [CLI11:public_includes:end]
+
+#include "App.hpp"
+#include "FormatterFwd.hpp"
+
+namespace CLI {
+// [CLI11:formatter_hpp:verbatim]
+
+inline std::string
+Formatter::make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const {
+    std::stringstream out;
+
+    out << "\n" << group << ":\n";
+    for(const Option *opt : opts) {
+        out << make_option(opt, is_positional);
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_positionals(const App *app) const {
+    std::vector<const Option *> opts =
+        app->get_options([](const Option *opt) { return !opt->get_group().empty() && opt->get_positional(); });
+
+    if(opts.empty())
+        return std::string();
+
+    return make_group(get_label("Positionals"), true, opts);
+}
+
+inline std::string Formatter::make_groups(const App *app, AppFormatMode mode) const {
+    std::stringstream out;
+    std::vector<std::string> groups = app->get_groups();
+
+    // Options
+    for(const std::string &group : groups) {
+        std::vector<const Option *> opts = app->get_options([app, mode, &group](const Option *opt) {
+            return opt->get_group() == group                     // Must be in the right group
+                   && opt->nonpositional()                       // Must not be a positional
+                   && (mode != AppFormatMode::Sub                // If mode is Sub, then
+                       || (app->get_help_ptr() != opt            // Ignore help pointer
+                           && app->get_help_all_ptr() != opt));  // Ignore help all pointer
+        });
+        if(!group.empty() && !opts.empty()) {
+            out << make_group(group, false, opts);
+
+            if(group != groups.back())
+                out << "\n";
+        }
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_description(const App *app) const {
+    std::string desc = app->get_description();
+    auto min_options = app->get_require_option_min();
+    auto max_options = app->get_require_option_max();
+    if(app->get_required()) {
+        desc += " REQUIRED ";
+    }
+    if((max_options == min_options) && (min_options > 0)) {
+        if(min_options == 1) {
+            desc += " \n[Exactly 1 of the following options is required]";
+        } else {
+            desc += " \n[Exactly " + std::to_string(min_options) + "options from the following list are required]";
+        }
+    } else if(max_options > 0) {
+        if(min_options > 0) {
+            desc += " \n[Between " + std::to_string(min_options) + " and " + std::to_string(max_options) +
+                    " of the follow options are required]";
+        } else {
+            desc += " \n[At most " + std::to_string(max_options) + " of the following options are allowed]";
+        }
+    } else if(min_options > 0) {
+        desc += " \n[At least " + std::to_string(min_options) + " of the following options are required]";
+    }
+    return (!desc.empty()) ? desc + "\n" : std::string{};
+}
+
+inline std::string Formatter::make_usage(const App *app, std::string name) const {
+    std::stringstream out;
+
+    out << get_label("Usage") << ":" << (name.empty() ? "" : " ") << name;
+
+    std::vector<std::string> groups = app->get_groups();
+
+    // Print an Options badge if any options exist
+    std::vector<const Option *> non_pos_options =
+        app->get_options([](const Option *opt) { return opt->nonpositional(); });
+    if(!non_pos_options.empty())
+        out << " [" << get_label("OPTIONS") << "]";
+
+    // Positionals need to be listed here
+    std::vector<const Option *> positionals = app->get_options([](const Option *opt) { return opt->get_positional(); });
+
+    // Print out positionals if any are left
+    if(!positionals.empty()) {
+        // Convert to help names
+        std::vector<std::string> positional_names(positionals.size());
+        std::transform(positionals.begin(), positionals.end(), positional_names.begin(), [this](const Option *opt) {
+            return make_option_usage(opt);
+        });
+
+        out << " " << detail::join(positional_names, " ");
+    }
+
+    // Add a marker if subcommands are expected or optional
+    if(!app->get_subcommands(
+               [](const CLI::App *subc) { return ((!subc->get_disabled()) && (!subc->get_name().empty())); })
+            .empty()) {
+        out << " " << (app->get_require_subcommand_min() == 0 ? "[" : "")
+            << get_label(app->get_require_subcommand_max() < 2 || app->get_require_subcommand_min() > 1 ? "SUBCOMMAND"
+                                                                                                        : "SUBCOMMANDS")
+            << (app->get_require_subcommand_min() == 0 ? "]" : "");
+    }
+
+    out << std::endl;
+
+    return out.str();
+}
+
+inline std::string Formatter::make_footer(const App *app) const {
+    std::string footer = app->get_footer();
+    if(footer.empty()) {
+        return std::string{};
+    }
+    return footer + "\n";
+}
+
+inline std::string Formatter::make_help(const App *app, std::string name, AppFormatMode mode) const {
+
+    // This immediately forwards to the make_expanded method. This is done this way so that subcommands can
+    // have overridden formatters
+    if(mode == AppFormatMode::Sub)
+        return make_expanded(app);
+
+    std::stringstream out;
+    if((app->get_name().empty()) && (app->get_parent() != nullptr)) {
+        if(app->get_group() != "Subcommands") {
+            out << app->get_group() << ':';
+        }
+    }
+
+    out << make_description(app);
+    out << make_usage(app, name);
+    out << make_positionals(app);
+    out << make_groups(app, mode);
+    out << make_subcommands(app, mode);
+    out << '\n' << make_footer(app);
+
+    return out.str();
+}
+
+inline std::string Formatter::make_subcommands(const App *app, AppFormatMode mode) const {
+    std::stringstream out;
+
+    std::vector<const App *> subcommands = app->get_subcommands({});
+
+    // Make a list in definition order of the groups seen
+    std::vector<std::string> subcmd_groups_seen;
+    for(const App *com : subcommands) {
+        if(com->get_name().empty()) {
+            if(!com->get_group().empty()) {
+                out << make_expanded(com);
+            }
+            continue;
+        }
+        std::string group_key = com->get_group();
+        if(!group_key.empty() &&
+           std::find_if(subcmd_groups_seen.begin(), subcmd_groups_seen.end(), [&group_key](std::string a) {
+               return detail::to_lower(a) == detail::to_lower(group_key);
+           }) == subcmd_groups_seen.end())
+            subcmd_groups_seen.push_back(group_key);
+    }
+
+    // For each group, filter out and print subcommands
+    for(const std::string &group : subcmd_groups_seen) {
+        out << "\n" << group << ":\n";
+        std::vector<const App *> subcommands_group = app->get_subcommands(
+            [&group](const App *sub_app) { return detail::to_lower(sub_app->get_group()) == detail::to_lower(group); });
+        for(const App *new_com : subcommands_group) {
+            if(new_com->get_name().empty())
+                continue;
+            if(mode != AppFormatMode::All) {
+                out << make_subcommand(new_com);
+            } else {
+                out << new_com->help(new_com->get_name(), AppFormatMode::Sub);
+                out << "\n";
+            }
+        }
+    }
+
+    return out.str();
+}
+
+inline std::string Formatter::make_subcommand(const App *sub) const {
+    std::stringstream out;
+    detail::format_help(out, sub->get_display_name(true), sub->get_description(), column_width_);
+    return out.str();
+}
+
+inline std::string Formatter::make_expanded(const App *sub) const {
+    std::stringstream out;
+    out << sub->get_display_name(true) << "\n";
+
+    out << make_description(sub);
+    if(sub->get_name().empty() && !sub->get_aliases().empty()) {
+        detail::format_aliases(out, sub->get_aliases(), column_width_ + 2);
+    }
+    out << make_positionals(sub);
+    out << make_groups(sub, AppFormatMode::Sub);
+    out << make_subcommands(sub, AppFormatMode::Sub);
+
+    // Drop blank spaces
+    std::string tmp = detail::find_and_replace(out.str(), "\n\n", "\n");
+    tmp = tmp.substr(0, tmp.size() - 1);  // Remove the final '\n'
+
+    // Indent all but the first line (the name)
+    return detail::find_and_replace(tmp, "\n", "\n  ") + "\n";
+}
+
+inline std::string Formatter::make_option_name(const Option *opt, bool is_positional) const {
+    if(is_positional)
+        return opt->get_name(true, false);
+
+    return opt->get_name(false, true);
+}
+
+inline std::string Formatter::make_option_opts(const Option *opt) const {
+    std::stringstream out;
+
+    if(!opt->get_option_text().empty()) {
+        out << " " << opt->get_option_text();
+    } else {
+        if(opt->get_type_size() != 0) {
+            if(!opt->get_type_name().empty())
+                out << " " << get_label(opt->get_type_name());
+            if(!opt->get_default_str().empty())
+                out << "=" << opt->get_default_str();
+            if(opt->get_expected_max() == detail::expected_max_vector_size)
+                out << " ...";
+            else if(opt->get_expected_min() > 1)
+                out << " x " << opt->get_expected();
+
+            if(opt->get_required())
+                out << " " << get_label("REQUIRED");
+        }
+        if(!opt->get_envname().empty())
+            out << " (" << get_label("Env") << ":" << opt->get_envname() << ")";
+        if(!opt->get_needs().empty()) {
+            out << " " << get_label("Needs") << ":";
+            for(const Option *op : opt->get_needs())
+                out << " " << op->get_name();
+        }
+        if(!opt->get_excludes().empty()) {
+            out << " " << get_label("Excludes") << ":";
+            for(const Option *op : opt->get_excludes())
+                out << " " << op->get_name();
+        }
+    }
+    return out.str();
+}
+
+inline std::string Formatter::make_option_desc(const Option *opt) const { return opt->get_description(); }
+
+inline std::string Formatter::make_option_usage(const Option *opt) const {
+    // Note that these are positionals usages
+    std::stringstream out;
+    out << make_option_name(opt, true);
+    if(opt->get_expected_max() >= detail::expected_max_vector_size)
+        out << "...";
+    else if(opt->get_expected_max() > 1)
+        out << "(" << opt->get_expected() << "x)";
+
+    return opt->get_required() ? out.str() : "[" + out.str() + "]";
+}
+
+// [CLI11:formatter_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/FormatterFwd.hpp b/src/phasicFlow/commandLine/CLI/FormatterFwd.hpp
new file mode 100644
index 00000000..728926c0
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/FormatterFwd.hpp
@@ -0,0 +1,184 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:end]
+
+#include "StringTools.hpp"
+
+namespace CLI {
+// [CLI11:formatter_fwd_hpp:verbatim]
+
+class Option;
+class App;
+
+/// This enum signifies the type of help requested
+///
+/// This is passed in by App; all user classes must accept this as
+/// the second argument.
+
+enum class AppFormatMode {
+    Normal,  ///< The normal, detailed help
+    All,     ///< A fully expanded help
+    Sub,     ///< Used when printed as part of expanded subcommand
+};
+
+/// This is the minimum requirements to run a formatter.
+///
+/// A user can subclass this is if they do not care at all
+/// about the structure in CLI::Formatter.
+class FormatterBase {
+  protected:
+    /// @name Options
+    ///@{
+
+    /// The width of the first column
+    std::size_t column_width_{30};
+
+    /// @brief The required help printout labels (user changeable)
+    /// Values are Needs, Excludes, etc.
+    std::map<std::string, std::string> labels_{};
+
+    ///@}
+    /// @name Basic
+    ///@{
+
+  public:
+    FormatterBase() = default;
+    FormatterBase(const FormatterBase &) = default;
+    FormatterBase(FormatterBase &&) = default;
+
+    /// Adding a destructor in this form to work around bug in GCC 4.7
+    virtual ~FormatterBase() noexcept {}  // NOLINT(modernize-use-equals-default)
+
+    /// This is the key method that puts together help
+    virtual std::string make_help(const App *, std::string, AppFormatMode) const = 0;
+
+    ///@}
+    /// @name Setters
+    ///@{
+
+    /// Set the "REQUIRED" label
+    void label(std::string key, std::string val) { labels_[key] = val; }
+
+    /// Set the column width
+    void column_width(std::size_t val) { column_width_ = val; }
+
+    ///@}
+    /// @name Getters
+    ///@{
+
+    /// Get the current value of a name (REQUIRED, etc.)
+    std::string get_label(std::string key) const {
+        if(labels_.find(key) == labels_.end())
+            return key;
+        else
+            return labels_.at(key);
+    }
+
+    /// Get the current column width
+    std::size_t get_column_width() const { return column_width_; }
+
+    ///@}
+};
+
+/// This is a specialty override for lambda functions
+class FormatterLambda final : public FormatterBase {
+    using funct_t = std::function<std::string(const App *, std::string, AppFormatMode)>;
+
+    /// The lambda to hold and run
+    funct_t lambda_;
+
+  public:
+    /// Create a FormatterLambda with a lambda function
+    explicit FormatterLambda(funct_t funct) : lambda_(std::move(funct)) {}
+
+    /// Adding a destructor (mostly to make GCC 4.7 happy)
+    ~FormatterLambda() noexcept override {}  // NOLINT(modernize-use-equals-default)
+
+    /// This will simply call the lambda function
+    std::string make_help(const App *app, std::string name, AppFormatMode mode) const override {
+        return lambda_(app, name, mode);
+    }
+};
+
+/// This is the default Formatter for CLI11. It pretty prints help output, and is broken into quite a few
+/// overridable methods, to be highly customizable with minimal effort.
+class Formatter : public FormatterBase {
+  public:
+    Formatter() = default;
+    Formatter(const Formatter &) = default;
+    Formatter(Formatter &&) = default;
+
+    /// @name Overridables
+    ///@{
+
+    /// This prints out a group of options with title
+    ///
+    virtual std::string make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const;
+
+    /// This prints out just the positionals "group"
+    virtual std::string make_positionals(const App *app) const;
+
+    /// This prints out all the groups of options
+    std::string make_groups(const App *app, AppFormatMode mode) const;
+
+    /// This prints out all the subcommands
+    virtual std::string make_subcommands(const App *app, AppFormatMode mode) const;
+
+    /// This prints out a subcommand
+    virtual std::string make_subcommand(const App *sub) const;
+
+    /// This prints out a subcommand in help-all
+    virtual std::string make_expanded(const App *sub) const;
+
+    /// This prints out all the groups of options
+    virtual std::string make_footer(const App *app) const;
+
+    /// This displays the description line
+    virtual std::string make_description(const App *app) const;
+
+    /// This displays the usage line
+    virtual std::string make_usage(const App *app, std::string name) const;
+
+    /// This puts everything together
+    std::string make_help(const App * /*app*/, std::string, AppFormatMode) const override;
+
+    ///@}
+    /// @name Options
+    ///@{
+
+    /// This prints out an option help line, either positional or optional form
+    virtual std::string make_option(const Option *opt, bool is_positional) const {
+        std::stringstream out;
+        detail::format_help(
+            out, make_option_name(opt, is_positional) + make_option_opts(opt), make_option_desc(opt), column_width_);
+        return out.str();
+    }
+
+    /// @brief This is the name part of an option, Default: left column
+    virtual std::string make_option_name(const Option *, bool) const;
+
+    /// @brief This is the options part of the name, Default: combined into left column
+    virtual std::string make_option_opts(const Option *) const;
+
+    /// @brief This is the description. Default: Right column, on new line if left column too large
+    virtual std::string make_option_desc(const Option *) const;
+
+    /// @brief This is used to print the name on the USAGE line
+    virtual std::string make_option_usage(const Option *opt) const;
+
+    ///@}
+};
+
+// [CLI11:formatter_fwd_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/LICENSE b/src/phasicFlow/commandLine/CLI/LICENSE
new file mode 100644
index 00000000..17739d11
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/LICENSE
@@ -0,0 +1,25 @@
+CLI11 1.8 Copyright (c) 2017-2019 University of Cincinnati, developed by Henry
+Schreiner under NSF AWARD 1414736. All rights reserved.
+
+Redistribution and use in source and binary forms of CLI11, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/phasicFlow/commandLine/CLI/Macros.hpp b/src/phasicFlow/commandLine/CLI/Macros.hpp
new file mode 100644
index 00000000..f228c918
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Macros.hpp
@@ -0,0 +1,44 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:macros_hpp:verbatim]
+
+// The following version macro is very similar to the one in pybind11
+#if !(defined(_MSC_VER) && __cplusplus == 199711L) && !defined(__INTEL_COMPILER)
+#if __cplusplus >= 201402L
+#define CLI11_CPP14
+#if __cplusplus >= 201703L
+#define CLI11_CPP17
+#if __cplusplus > 201703L
+#define CLI11_CPP20
+#endif
+#endif
+#endif
+#elif defined(_MSC_VER) && __cplusplus == 199711L
+// MSVC sets _MSVC_LANG rather than __cplusplus (supposedly until the standard is fully implemented)
+// Unless you use the /Zc:__cplusplus flag on Visual Studio 2017 15.7 Preview 3 or newer
+#if _MSVC_LANG >= 201402L
+#define CLI11_CPP14
+#if _MSVC_LANG > 201402L && _MSC_VER >= 1910
+#define CLI11_CPP17
+#if __MSVC_LANG > 201703L && _MSC_VER >= 1910
+#define CLI11_CPP20
+#endif
+#endif
+#endif
+#endif
+
+#if defined(CLI11_CPP14)
+#define CLI11_DEPRECATED(reason) [[deprecated(reason)]]
+#elif defined(_MSC_VER)
+#define CLI11_DEPRECATED(reason) __declspec(deprecated(reason))
+#else
+#define CLI11_DEPRECATED(reason) __attribute__((deprecated(reason)))
+#endif
+
+// [CLI11:macros_hpp:end]
diff --git a/src/phasicFlow/commandLine/CLI/Option.hpp b/src/phasicFlow/commandLine/CLI/Option.hpp
new file mode 100644
index 00000000..25a67605
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Option.hpp
@@ -0,0 +1,1348 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <set>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:end]
+
+#include "Error.hpp"
+#include "Macros.hpp"
+#include "Split.hpp"
+#include "StringTools.hpp"
+#include "Validators.hpp"
+
+namespace CLI {
+// [CLI11:option_hpp:verbatim]
+
+using results_t = std::vector<std::string>;
+/// callback function definition
+using callback_t = std::function<bool(const results_t &)>;
+
+class Option;
+class App;
+
+using Option_p = std::unique_ptr<Option>;
+/// Enumeration of the multiOption Policy selection
+enum class MultiOptionPolicy : char {
+    Throw,      //!< Throw an error if any extra arguments were given
+    TakeLast,   //!< take only the last Expected number of arguments
+    TakeFirst,  //!< take only the first Expected number of arguments
+    Join,       //!< merge all the arguments together into a single string via the delimiter character default('\n')
+    TakeAll     //!< just get all the passed argument regardless
+};
+
+/// This is the CRTP base class for Option and OptionDefaults. It was designed this way
+/// to share parts of the class; an OptionDefaults can copy to an Option.
+template <typename CRTP> class OptionBase {
+    friend App;
+
+  protected:
+    /// The group membership
+    std::string group_ = std::string("Options");
+
+    /// True if this is a required option
+    bool required_{false};
+
+    /// Ignore the case when matching (option, not value)
+    bool ignore_case_{false};
+
+    /// Ignore underscores when matching (option, not value)
+    bool ignore_underscore_{false};
+
+    /// Allow this option to be given in a configuration file
+    bool configurable_{true};
+
+    /// Disable overriding flag values with '=value'
+    bool disable_flag_override_{false};
+
+    /// Specify a delimiter character for vector arguments
+    char delimiter_{'\0'};
+
+    /// Automatically capture default value
+    bool always_capture_default_{false};
+
+    /// Policy for handling multiple arguments beyond the expected Max
+    MultiOptionPolicy multi_option_policy_{MultiOptionPolicy::Throw};
+
+    /// Copy the contents to another similar class (one based on OptionBase)
+    template <typename T> void copy_to(T *other) const {
+        other->group(group_);
+        other->required(required_);
+        other->ignore_case(ignore_case_);
+        other->ignore_underscore(ignore_underscore_);
+        other->configurable(configurable_);
+        other->disable_flag_override(disable_flag_override_);
+        other->delimiter(delimiter_);
+        other->always_capture_default(always_capture_default_);
+        other->multi_option_policy(multi_option_policy_);
+    }
+
+  public:
+    // setters
+
+    /// Changes the group membership
+    CRTP *group(const std::string &name) {
+        if(!detail::valid_alias_name_string(name)) {
+            throw IncorrectConstruction("Group names may not contain newlines or null characters");
+        }
+        group_ = name;
+        return static_cast<CRTP *>(this);
+    }
+
+    /// Set the option as required
+    CRTP *required(bool value = true) {
+        required_ = value;
+        return static_cast<CRTP *>(this);
+    }
+
+    /// Support Plumbum term
+    CRTP *mandatory(bool value = true) { return required(value); }
+
+    CRTP *always_capture_default(bool value = true) {
+        always_capture_default_ = value;
+        return static_cast<CRTP *>(this);
+    }
+
+    // Getters
+
+    /// Get the group of this option
+    const std::string &get_group() const { return group_; }
+
+    /// True if this is a required option
+    bool get_required() const { return required_; }
+
+    /// The status of ignore case
+    bool get_ignore_case() const { return ignore_case_; }
+
+    /// The status of ignore_underscore
+    bool get_ignore_underscore() const { return ignore_underscore_; }
+
+    /// The status of configurable
+    bool get_configurable() const { return configurable_; }
+
+    /// The status of configurable
+    bool get_disable_flag_override() const { return disable_flag_override_; }
+
+    /// Get the current delimiter char
+    char get_delimiter() const { return delimiter_; }
+
+    /// Return true if this will automatically capture the default value for help printing
+    bool get_always_capture_default() const { return always_capture_default_; }
+
+    /// The status of the multi option policy
+    MultiOptionPolicy get_multi_option_policy() const { return multi_option_policy_; }
+
+    // Shortcuts for multi option policy
+
+    /// Set the multi option policy to take last
+    CRTP *take_last() {
+        auto self = static_cast<CRTP *>(this);
+        self->multi_option_policy(MultiOptionPolicy::TakeLast);
+        return self;
+    }
+
+    /// Set the multi option policy to take last
+    CRTP *take_first() {
+        auto self = static_cast<CRTP *>(this);
+        self->multi_option_policy(MultiOptionPolicy::TakeFirst);
+        return self;
+    }
+
+    /// Set the multi option policy to take all arguments
+    CRTP *take_all() {
+        auto self = static_cast<CRTP *>(this);
+        self->multi_option_policy(MultiOptionPolicy::TakeAll);
+        return self;
+    }
+
+    /// Set the multi option policy to join
+    CRTP *join() {
+        auto self = static_cast<CRTP *>(this);
+        self->multi_option_policy(MultiOptionPolicy::Join);
+        return self;
+    }
+
+    /// Set the multi option policy to join with a specific delimiter
+    CRTP *join(char delim) {
+        auto self = static_cast<CRTP *>(this);
+        self->delimiter_ = delim;
+        self->multi_option_policy(MultiOptionPolicy::Join);
+        return self;
+    }
+
+    /// Allow in a configuration file
+    CRTP *configurable(bool value = true) {
+        configurable_ = value;
+        return static_cast<CRTP *>(this);
+    }
+
+    /// Allow in a configuration file
+    CRTP *delimiter(char value = '\0') {
+        delimiter_ = value;
+        return static_cast<CRTP *>(this);
+    }
+};
+
+/// This is a version of OptionBase that only supports setting values,
+/// for defaults. It is stored as the default option in an App.
+class OptionDefaults : public OptionBase<OptionDefaults> {
+  public:
+    OptionDefaults() = default;
+
+    // Methods here need a different implementation if they are Option vs. OptionDefault
+
+    /// Take the last argument if given multiple times
+    OptionDefaults *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
+        multi_option_policy_ = value;
+        return this;
+    }
+
+    /// Ignore the case of the option name
+    OptionDefaults *ignore_case(bool value = true) {
+        ignore_case_ = value;
+        return this;
+    }
+
+    /// Ignore underscores in the option name
+    OptionDefaults *ignore_underscore(bool value = true) {
+        ignore_underscore_ = value;
+        return this;
+    }
+
+    /// Disable overriding flag values with an '=<value>' segment
+    OptionDefaults *disable_flag_override(bool value = true) {
+        disable_flag_override_ = value;
+        return this;
+    }
+
+    /// set a delimiter character to split up single arguments to treat as multiple inputs
+    OptionDefaults *delimiter(char value = '\0') {
+        delimiter_ = value;
+        return this;
+    }
+};
+
+class Option : public OptionBase<Option> {
+    friend App;
+
+  protected:
+    /// @name Names
+    ///@{
+
+    /// A list of the short names (`-a`) without the leading dashes
+    std::vector<std::string> snames_{};
+
+    /// A list of the long names (`--long`) without the leading dashes
+    std::vector<std::string> lnames_{};
+
+    /// A list of the flag names with the appropriate default value, the first part of the pair should be duplicates of
+    /// what is in snames or lnames but will trigger a particular response on a flag
+    std::vector<std::pair<std::string, std::string>> default_flag_values_{};
+
+    /// a list of flag names with specified default values;
+    std::vector<std::string> fnames_{};
+
+    /// A positional name
+    std::string pname_{};
+
+    /// If given, check the environment for this option
+    std::string envname_{};
+
+    ///@}
+    /// @name Help
+    ///@{
+
+    /// The description for help strings
+    std::string description_{};
+
+    /// A human readable default value, either manually set, captured, or captured by default
+    std::string default_str_{};
+
+    /// If given, replace the text that describes the option type and usage in the help text
+    std::string option_text_{};
+
+    /// A human readable type value, set when App creates this
+    ///
+    /// This is a lambda function so "types" can be dynamic, such as when a set prints its contents.
+    std::function<std::string()> type_name_{[]() { return std::string(); }};
+
+    /// Run this function to capture a default (ignore if empty)
+    std::function<std::string()> default_function_{};
+
+    ///@}
+    /// @name Configuration
+    ///@{
+
+    /// The number of arguments that make up one option. max is the nominal type size, min is the minimum number of
+    /// strings
+    int type_size_max_{1};
+    /// The minimum number of arguments an option should be expecting
+    int type_size_min_{1};
+
+    /// The minimum number of expected values
+    int expected_min_{1};
+    /// The maximum number of expected values
+    int expected_max_{1};
+
+    /// A list of Validators to run on each value parsed
+    std::vector<Validator> validators_{};
+
+    /// A list of options that are required with this option
+    std::set<Option *> needs_{};
+
+    /// A list of options that are excluded with this option
+    std::set<Option *> excludes_{};
+
+    ///@}
+    /// @name Other
+    ///@{
+
+    /// link back up to the parent App for fallthrough
+    App *parent_{nullptr};
+
+    /// Options store a callback to do all the work
+    callback_t callback_{};
+
+    ///@}
+    /// @name Parsing results
+    ///@{
+
+    /// complete Results of parsing
+    results_t results_{};
+    /// results after reduction
+    results_t proc_results_{};
+    /// enumeration for the option state machine
+    enum class option_state : char {
+        parsing = 0,       //!< The option is currently collecting parsed results
+        validated = 2,     //!< the results have been validated
+        reduced = 4,       //!< a subset of results has been generated
+        callback_run = 6,  //!< the callback has been executed
+    };
+    /// Whether the callback has run (needed for INI parsing)
+    option_state current_option_state_{option_state::parsing};
+    /// Specify that extra args beyond type_size_max should be allowed
+    bool allow_extra_args_{false};
+    /// Specify that the option should act like a flag vs regular option
+    bool flag_like_{false};
+    /// Control option to run the callback to set the default
+    bool run_callback_for_default_{false};
+    /// flag indicating a separator needs to be injected after each argument call
+    bool inject_separator_{false};
+    /// flag indicating that the option should trigger the validation and callback chain on each result when loaded
+    bool trigger_on_result_{false};
+    /// flag indicating that the option should force the callback regardless if any results present
+    bool force_callback_{false};
+    ///@}
+
+    /// Making an option by hand is not defined, it must be made by the App class
+    Option(std::string option_name, std::string option_description, callback_t callback, App *parent)
+        : description_(std::move(option_description)), parent_(parent), callback_(std::move(callback)) {
+        std::tie(snames_, lnames_, pname_) = detail::get_names(detail::split_names(option_name));
+    }
+
+  public:
+    /// @name Basic
+    ///@{
+
+    Option(const Option &) = delete;
+    Option &operator=(const Option &) = delete;
+
+    /// Count the total number of times an option was passed
+    std::size_t count() const { return results_.size(); }
+
+    /// True if the option was not passed
+    bool empty() const { return results_.empty(); }
+
+    /// This bool operator returns true if any arguments were passed or the option callback is forced
+    explicit operator bool() const { return !empty() || force_callback_; }
+
+    /// Clear the parsed results (mostly for testing)
+    void clear() {
+        results_.clear();
+        current_option_state_ = option_state::parsing;
+    }
+
+    ///@}
+    /// @name Setting options
+    ///@{
+
+    /// Set the number of expected arguments
+    Option *expected(int value) {
+        if(value < 0) {
+            expected_min_ = -value;
+            if(expected_max_ < expected_min_) {
+                expected_max_ = expected_min_;
+            }
+            allow_extra_args_ = true;
+            flag_like_ = false;
+        } else if(value == detail::expected_max_vector_size) {
+            expected_min_ = 1;
+            expected_max_ = detail::expected_max_vector_size;
+            allow_extra_args_ = true;
+            flag_like_ = false;
+        } else {
+            expected_min_ = value;
+            expected_max_ = value;
+            flag_like_ = (expected_min_ == 0);
+        }
+        return this;
+    }
+
+    /// Set the range of expected arguments
+    Option *expected(int value_min, int value_max) {
+        if(value_min < 0) {
+            value_min = -value_min;
+        }
+
+        if(value_max < 0) {
+            value_max = detail::expected_max_vector_size;
+        }
+        if(value_max < value_min) {
+            expected_min_ = value_max;
+            expected_max_ = value_min;
+        } else {
+            expected_max_ = value_max;
+            expected_min_ = value_min;
+        }
+
+        return this;
+    }
+    /// Set the value of allow_extra_args which allows extra value arguments on the flag or option to be included
+    /// with each instance
+    Option *allow_extra_args(bool value = true) {
+        allow_extra_args_ = value;
+        return this;
+    }
+    /// Get the current value of allow extra args
+    bool get_allow_extra_args() const { return allow_extra_args_; }
+    /// Set the value of trigger_on_parse which specifies that the option callback should be triggered on every parse
+    Option *trigger_on_parse(bool value = true) {
+        trigger_on_result_ = value;
+        return this;
+    }
+    /// The status of trigger on parse
+    bool get_trigger_on_parse() const { return trigger_on_result_; }
+
+    /// Set the value of force_callback
+    Option *force_callback(bool value = true) {
+        force_callback_ = value;
+        return this;
+    }
+    /// The status of force_callback
+    bool get_force_callback() const { return force_callback_; }
+
+    /// Set the value of run_callback_for_default which controls whether the callback function should be called to set
+    /// the default This is controlled automatically but could be manipulated by the user.
+    Option *run_callback_for_default(bool value = true) {
+        run_callback_for_default_ = value;
+        return this;
+    }
+    /// Get the current value of run_callback_for_default
+    bool get_run_callback_for_default() const { return run_callback_for_default_; }
+
+    /// Adds a Validator with a built in type name
+    Option *check(Validator validator, const std::string &validator_name = "") {
+        validator.non_modifying();
+        validators_.push_back(std::move(validator));
+        if(!validator_name.empty())
+            validators_.back().name(validator_name);
+        return this;
+    }
+
+    /// Adds a Validator. Takes a const string& and returns an error message (empty if conversion/check is okay).
+    Option *check(std::function<std::string(const std::string &)> Validator,
+                  std::string Validator_description = "",
+                  std::string Validator_name = "") {
+        validators_.emplace_back(Validator, std::move(Validator_description), std::move(Validator_name));
+        validators_.back().non_modifying();
+        return this;
+    }
+
+    /// Adds a transforming Validator with a built in type name
+    Option *transform(Validator Validator, const std::string &Validator_name = "") {
+        validators_.insert(validators_.begin(), std::move(Validator));
+        if(!Validator_name.empty())
+            validators_.front().name(Validator_name);
+        return this;
+    }
+
+    /// Adds a Validator-like function that can change result
+    Option *transform(const std::function<std::string(std::string)> &func,
+                      std::string transform_description = "",
+                      std::string transform_name = "") {
+        validators_.insert(validators_.begin(),
+                           Validator(
+                               [func](std::string &val) {
+                                   val = func(val);
+                                   return std::string{};
+                               },
+                               std::move(transform_description),
+                               std::move(transform_name)));
+
+        return this;
+    }
+
+    /// Adds a user supplied function to run on each item passed in (communicate though lambda capture)
+    Option *each(const std::function<void(std::string)> &func) {
+        validators_.emplace_back(
+            [func](std::string &inout) {
+                func(inout);
+                return std::string{};
+            },
+            std::string{});
+        return this;
+    }
+    /// Get a named Validator
+    Validator *get_validator(const std::string &Validator_name = "") {
+        for(auto &Validator : validators_) {
+            if(Validator_name == Validator.get_name()) {
+                return &Validator;
+            }
+        }
+        if((Validator_name.empty()) && (!validators_.empty())) {
+            return &(validators_.front());
+        }
+        throw OptionNotFound(std::string{"Validator "} + Validator_name + " Not Found");
+    }
+
+    /// Get a Validator by index NOTE: this may not be the order of definition
+    Validator *get_validator(int index) {
+        // This is an signed int so that it is not equivalent to a pointer.
+        if(index >= 0 && index < static_cast<int>(validators_.size())) {
+            return &(validators_[static_cast<decltype(validators_)::size_type>(index)]);
+        }
+        throw OptionNotFound("Validator index is not valid");
+    }
+
+    /// Sets required options
+    Option *needs(Option *opt) {
+        if(opt != this) {
+            needs_.insert(opt);
+        }
+        return this;
+    }
+
+    /// Can find a string if needed
+    template <typename T = App> Option *needs(std::string opt_name) {
+        auto opt = static_cast<T *>(parent_)->get_option_no_throw(opt_name);
+        if(opt == nullptr) {
+            throw IncorrectConstruction::MissingOption(opt_name);
+        }
+        return needs(opt);
+    }
+
+    /// Any number supported, any mix of string and Opt
+    template <typename A, typename B, typename... ARG> Option *needs(A opt, B opt1, ARG... args) {
+        needs(opt);
+        return needs(opt1, args...);
+    }
+
+    /// Remove needs link from an option. Returns true if the option really was in the needs list.
+    bool remove_needs(Option *opt) {
+        auto iterator = std::find(std::begin(needs_), std::end(needs_), opt);
+
+        if(iterator == std::end(needs_)) {
+            return false;
+        }
+        needs_.erase(iterator);
+        return true;
+    }
+
+    /// Sets excluded options
+    Option *excludes(Option *opt) {
+        if(opt == this) {
+            throw(IncorrectConstruction("and option cannot exclude itself"));
+        }
+        excludes_.insert(opt);
+
+        // Help text should be symmetric - excluding a should exclude b
+        opt->excludes_.insert(this);
+
+        // Ignoring the insert return value, excluding twice is now allowed.
+        // (Mostly to allow both directions to be excluded by user, even though the library does it for you.)
+
+        return this;
+    }
+
+    /// Can find a string if needed
+    template <typename T = App> Option *excludes(std::string opt_name) {
+        auto opt = static_cast<T *>(parent_)->get_option_no_throw(opt_name);
+        if(opt == nullptr) {
+            throw IncorrectConstruction::MissingOption(opt_name);
+        }
+        return excludes(opt);
+    }
+
+    /// Any number supported, any mix of string and Opt
+    template <typename A, typename B, typename... ARG> Option *excludes(A opt, B opt1, ARG... args) {
+        excludes(opt);
+        return excludes(opt1, args...);
+    }
+
+    /// Remove needs link from an option. Returns true if the option really was in the needs list.
+    bool remove_excludes(Option *opt) {
+        auto iterator = std::find(std::begin(excludes_), std::end(excludes_), opt);
+
+        if(iterator == std::end(excludes_)) {
+            return false;
+        }
+        excludes_.erase(iterator);
+        return true;
+    }
+
+    /// Sets environment variable to read if no option given
+    Option *envname(std::string name) {
+        envname_ = std::move(name);
+        return this;
+    }
+
+    /// Ignore case
+    ///
+    /// The template hides the fact that we don't have the definition of App yet.
+    /// You are never expected to add an argument to the template here.
+    template <typename T = App> Option *ignore_case(bool value = true) {
+        if(!ignore_case_ && value) {
+            ignore_case_ = value;
+            auto *parent = static_cast<T *>(parent_);
+            for(const Option_p &opt : parent->options_) {
+                if(opt.get() == this) {
+                    continue;
+                }
+                auto &omatch = opt->matching_name(*this);
+                if(!omatch.empty()) {
+                    ignore_case_ = false;
+                    throw OptionAlreadyAdded("adding ignore case caused a name conflict with " + omatch);
+                }
+            }
+        } else {
+            ignore_case_ = value;
+        }
+        return this;
+    }
+
+    /// Ignore underscores in the option names
+    ///
+    /// The template hides the fact that we don't have the definition of App yet.
+    /// You are never expected to add an argument to the template here.
+    template <typename T = App> Option *ignore_underscore(bool value = true) {
+
+        if(!ignore_underscore_ && value) {
+            ignore_underscore_ = value;
+            auto *parent = static_cast<T *>(parent_);
+            for(const Option_p &opt : parent->options_) {
+                if(opt.get() == this) {
+                    continue;
+                }
+                auto &omatch = opt->matching_name(*this);
+                if(!omatch.empty()) {
+                    ignore_underscore_ = false;
+                    throw OptionAlreadyAdded("adding ignore underscore caused a name conflict with " + omatch);
+                }
+            }
+        } else {
+            ignore_underscore_ = value;
+        }
+        return this;
+    }
+
+    /// Take the last argument if given multiple times (or another policy)
+    Option *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
+        if(value != multi_option_policy_) {
+            if(multi_option_policy_ == MultiOptionPolicy::Throw && expected_max_ == detail::expected_max_vector_size &&
+               expected_min_ > 1) {  // this bizarre condition is to maintain backwards compatibility
+                                     // with the previous behavior of expected_ with vectors
+                expected_max_ = expected_min_;
+            }
+            multi_option_policy_ = value;
+            current_option_state_ = option_state::parsing;
+        }
+        return this;
+    }
+
+    /// Disable flag overrides values, e.g. --flag=<value> is not allowed
+    Option *disable_flag_override(bool value = true) {
+        disable_flag_override_ = value;
+        return this;
+    }
+    ///@}
+    /// @name Accessors
+    ///@{
+
+    /// The number of arguments the option expects
+    int get_type_size() const { return type_size_min_; }
+
+    /// The minimum number of arguments the option expects
+    int get_type_size_min() const { return type_size_min_; }
+    /// The maximum number of arguments the option expects
+    int get_type_size_max() const { return type_size_max_; }
+
+    /// Return the inject_separator flag
+    int get_inject_separator() const { return inject_separator_; }
+
+    /// The environment variable associated to this value
+    std::string get_envname() const { return envname_; }
+
+    /// The set of options needed
+    std::set<Option *> get_needs() const { return needs_; }
+
+    /// The set of options excluded
+    std::set<Option *> get_excludes() const { return excludes_; }
+
+    /// The default value (for help printing)
+    std::string get_default_str() const { return default_str_; }
+
+    /// Get the callback function
+    callback_t get_callback() const { return callback_; }
+
+    /// Get the long names
+    const std::vector<std::string> &get_lnames() const { return lnames_; }
+
+    /// Get the short names
+    const std::vector<std::string> &get_snames() const { return snames_; }
+
+    /// Get the flag names with specified default values
+    const std::vector<std::string> &get_fnames() const { return fnames_; }
+    /// Get a single name for the option, first of lname, pname, sname, envname
+    const std::string &get_single_name() const {
+        if(!lnames_.empty()) {
+            return lnames_[0];
+        }
+        if(!pname_.empty()) {
+            return pname_;
+        }
+        if(!snames_.empty()) {
+            return snames_[0];
+        }
+        return envname_;
+    }
+    /// The number of times the option expects to be included
+    int get_expected() const { return expected_min_; }
+
+    /// The number of times the option expects to be included
+    int get_expected_min() const { return expected_min_; }
+    /// The max number of times the option expects to be included
+    int get_expected_max() const { return expected_max_; }
+
+    /// The total min number of expected  string values to be used
+    int get_items_expected_min() const { return type_size_min_ * expected_min_; }
+
+    /// Get the maximum number of items expected to be returned and used for the callback
+    int get_items_expected_max() const {
+        int t = type_size_max_;
+        return detail::checked_multiply(t, expected_max_) ? t : detail::expected_max_vector_size;
+    }
+    /// The total min number of expected  string values to be used
+    int get_items_expected() const { return get_items_expected_min(); }
+
+    /// True if the argument can be given directly
+    bool get_positional() const { return pname_.length() > 0; }
+
+    /// True if option has at least one non-positional name
+    bool nonpositional() const { return (snames_.size() + lnames_.size()) > 0; }
+
+    /// True if option has description
+    bool has_description() const { return description_.length() > 0; }
+
+    /// Get the description
+    const std::string &get_description() const { return description_; }
+
+    /// Set the description
+    Option *description(std::string option_description) {
+        description_ = std::move(option_description);
+        return this;
+    }
+
+    Option *option_text(std::string text) {
+        option_text_ = std::move(text);
+        return this;
+    }
+
+    const std::string &get_option_text() const { return option_text_; }
+
+    ///@}
+    /// @name Help tools
+    ///@{
+
+    /// \brief Gets a comma separated list of names.
+    /// Will include / prefer the positional name if positional is true.
+    /// If all_options is false, pick just the most descriptive name to show.
+    /// Use `get_name(true)` to get the positional name (replaces `get_pname`)
+    std::string get_name(bool positional = false,  ///< Show the positional name
+                         bool all_options = false  ///< Show every option
+    ) const {
+        if(get_group().empty())
+            return {};  // Hidden
+
+        if(all_options) {
+
+            std::vector<std::string> name_list;
+
+            /// The all list will never include a positional unless asked or that's the only name.
+            if((positional && (!pname_.empty())) || (snames_.empty() && lnames_.empty())) {
+                name_list.push_back(pname_);
+            }
+            if((get_items_expected() == 0) && (!fnames_.empty())) {
+                for(const std::string &sname : snames_) {
+                    name_list.push_back("-" + sname);
+                    if(check_fname(sname)) {
+                        name_list.back() += "{" + get_flag_value(sname, "") + "}";
+                    }
+                }
+
+                for(const std::string &lname : lnames_) {
+                    name_list.push_back("--" + lname);
+                    if(check_fname(lname)) {
+                        name_list.back() += "{" + get_flag_value(lname, "") + "}";
+                    }
+                }
+            } else {
+                for(const std::string &sname : snames_)
+                    name_list.push_back("-" + sname);
+
+                for(const std::string &lname : lnames_)
+                    name_list.push_back("--" + lname);
+            }
+
+            return detail::join(name_list);
+        }
+
+        // This returns the positional name no matter what
+        if(positional)
+            return pname_;
+
+        // Prefer long name
+        if(!lnames_.empty())
+            return std::string(2, '-') + lnames_[0];
+
+        // Or short name if no long name
+        if(!snames_.empty())
+            return std::string(1, '-') + snames_[0];
+
+        // If positional is the only name, it's okay to use that
+        return pname_;
+    }
+
+    ///@}
+    /// @name Parser tools
+    ///@{
+
+    /// Process the callback
+    void run_callback() {
+        if(force_callback_ && results_.empty()) {
+            add_result(default_str_);
+        }
+        if(current_option_state_ == option_state::parsing) {
+            _validate_results(results_);
+            current_option_state_ = option_state::validated;
+        }
+
+        if(current_option_state_ < option_state::reduced) {
+            _reduce_results(proc_results_, results_);
+            current_option_state_ = option_state::reduced;
+        }
+        if(current_option_state_ >= option_state::reduced) {
+            current_option_state_ = option_state::callback_run;
+            if(!(callback_)) {
+                return;
+            }
+            const results_t &send_results = proc_results_.empty() ? results_ : proc_results_;
+            bool local_result = callback_(send_results);
+
+            if(!local_result)
+                throw ConversionError(get_name(), results_);
+        }
+    }
+
+    /// If options share any of the same names, find it
+    const std::string &matching_name(const Option &other) const {
+        static const std::string estring;
+        for(const std::string &sname : snames_)
+            if(other.check_sname(sname))
+                return sname;
+        for(const std::string &lname : lnames_)
+            if(other.check_lname(lname))
+                return lname;
+
+        if(ignore_case_ ||
+           ignore_underscore_) {  // We need to do the inverse, in case we are ignore_case or ignore underscore
+            for(const std::string &sname : other.snames_)
+                if(check_sname(sname))
+                    return sname;
+            for(const std::string &lname : other.lnames_)
+                if(check_lname(lname))
+                    return lname;
+        }
+        return estring;
+    }
+    /// If options share any of the same names, they are equal (not counting positional)
+    bool operator==(const Option &other) const { return !matching_name(other).empty(); }
+
+    /// Check a name. Requires "-" or "--" for short / long, supports positional name
+    bool check_name(const std::string &name) const {
+
+        if(name.length() > 2 && name[0] == '-' && name[1] == '-')
+            return check_lname(name.substr(2));
+        if(name.length() > 1 && name.front() == '-')
+            return check_sname(name.substr(1));
+        if(!pname_.empty()) {
+            std::string local_pname = pname_;
+            std::string local_name = name;
+            if(ignore_underscore_) {
+                local_pname = detail::remove_underscore(local_pname);
+                local_name = detail::remove_underscore(local_name);
+            }
+            if(ignore_case_) {
+                local_pname = detail::to_lower(local_pname);
+                local_name = detail::to_lower(local_name);
+            }
+            if(local_name == local_pname) {
+                return true;
+            }
+        }
+
+        if(!envname_.empty()) {
+            // this needs to be the original since envname_ shouldn't match on case insensitivity
+            return (name == envname_);
+        }
+        return false;
+    }
+
+    /// Requires "-" to be removed from string
+    bool check_sname(std::string name) const {
+        return (detail::find_member(std::move(name), snames_, ignore_case_) >= 0);
+    }
+
+    /// Requires "--" to be removed from string
+    bool check_lname(std::string name) const {
+        return (detail::find_member(std::move(name), lnames_, ignore_case_, ignore_underscore_) >= 0);
+    }
+
+    /// Requires "--" to be removed from string
+    bool check_fname(std::string name) const {
+        if(fnames_.empty()) {
+            return false;
+        }
+        return (detail::find_member(std::move(name), fnames_, ignore_case_, ignore_underscore_) >= 0);
+    }
+
+    /// Get the value that goes for a flag, nominally gets the default value but allows for overrides if not
+    /// disabled
+    std::string get_flag_value(const std::string &name, std::string input_value) const {
+        static const std::string trueString{"true"};
+        static const std::string falseString{"false"};
+        static const std::string emptyString{"{}"};
+        // check for disable flag override_
+        if(disable_flag_override_) {
+            if(!((input_value.empty()) || (input_value == emptyString))) {
+                auto default_ind = detail::find_member(name, fnames_, ignore_case_, ignore_underscore_);
+                if(default_ind >= 0) {
+                    // We can static cast this to std::size_t because it is more than 0 in this block
+                    if(default_flag_values_[static_cast<std::size_t>(default_ind)].second != input_value) {
+                        throw(ArgumentMismatch::FlagOverride(name));
+                    }
+                } else {
+                    if(input_value != trueString) {
+                        throw(ArgumentMismatch::FlagOverride(name));
+                    }
+                }
+            }
+        }
+        auto ind = detail::find_member(name, fnames_, ignore_case_, ignore_underscore_);
+        if((input_value.empty()) || (input_value == emptyString)) {
+            if(flag_like_) {
+                return (ind < 0) ? trueString : default_flag_values_[static_cast<std::size_t>(ind)].second;
+            } else {
+                return (ind < 0) ? default_str_ : default_flag_values_[static_cast<std::size_t>(ind)].second;
+            }
+        }
+        if(ind < 0) {
+            return input_value;
+        }
+        if(default_flag_values_[static_cast<std::size_t>(ind)].second == falseString) {
+            try {
+                auto val = detail::to_flag_value(input_value);
+                return (val == 1) ? falseString : (val == (-1) ? trueString : std::to_string(-val));
+            } catch(const std::invalid_argument &) {
+                return input_value;
+            }
+        } else {
+            return input_value;
+        }
+    }
+
+    /// Puts a result at the end
+    Option *add_result(std::string s) {
+        _add_result(std::move(s), results_);
+        current_option_state_ = option_state::parsing;
+        return this;
+    }
+
+    /// Puts a result at the end and get a count of the number of arguments actually added
+    Option *add_result(std::string s, int &results_added) {
+        results_added = _add_result(std::move(s), results_);
+        current_option_state_ = option_state::parsing;
+        return this;
+    }
+
+    /// Puts a result at the end
+    Option *add_result(std::vector<std::string> s) {
+        current_option_state_ = option_state::parsing;
+        for(auto &str : s) {
+            _add_result(std::move(str), results_);
+        }
+        return this;
+    }
+
+    /// Get the current complete results set
+    const results_t &results() const { return results_; }
+
+    /// Get a copy of the results
+    results_t reduced_results() const {
+        results_t res = proc_results_.empty() ? results_ : proc_results_;
+        if(current_option_state_ < option_state::reduced) {
+            if(current_option_state_ == option_state::parsing) {
+                res = results_;
+                _validate_results(res);
+            }
+            if(!res.empty()) {
+                results_t extra;
+                _reduce_results(extra, res);
+                if(!extra.empty()) {
+                    res = std::move(extra);
+                }
+            }
+        }
+        return res;
+    }
+
+    /// Get the results as a specified type
+    template <typename T> void results(T &output) const {
+        bool retval;
+        if(current_option_state_ >= option_state::reduced || (results_.size() == 1 && validators_.empty())) {
+            const results_t &res = (proc_results_.empty()) ? results_ : proc_results_;
+            retval = detail::lexical_conversion<T, T>(res, output);
+        } else {
+            results_t res;
+            if(results_.empty()) {
+                if(!default_str_.empty()) {
+                    // _add_results takes an rvalue only
+                    _add_result(std::string(default_str_), res);
+                    _validate_results(res);
+                    results_t extra;
+                    _reduce_results(extra, res);
+                    if(!extra.empty()) {
+                        res = std::move(extra);
+                    }
+                } else {
+                    res.emplace_back();
+                }
+            } else {
+                res = reduced_results();
+            }
+            retval = detail::lexical_conversion<T, T>(res, output);
+        }
+        if(!retval) {
+            throw ConversionError(get_name(), results_);
+        }
+    }
+
+    /// Return the results as the specified type
+    template <typename T> T as() const {
+        T output;
+        results(output);
+        return output;
+    }
+
+    /// See if the callback has been run already
+    bool get_callback_run() const { return (current_option_state_ == option_state::callback_run); }
+
+    ///@}
+    /// @name Custom options
+    ///@{
+
+    /// Set the type function to run when displayed on this option
+    Option *type_name_fn(std::function<std::string()> typefun) {
+        type_name_ = std::move(typefun);
+        return this;
+    }
+
+    /// Set a custom option typestring
+    Option *type_name(std::string typeval) {
+        type_name_fn([typeval]() { return typeval; });
+        return this;
+    }
+
+    /// Set a custom option size
+    Option *type_size(int option_type_size) {
+        if(option_type_size < 0) {
+            // this section is included for backwards compatibility
+            type_size_max_ = -option_type_size;
+            type_size_min_ = -option_type_size;
+            expected_max_ = detail::expected_max_vector_size;
+        } else {
+            type_size_max_ = option_type_size;
+            if(type_size_max_ < detail::expected_max_vector_size) {
+                type_size_min_ = option_type_size;
+            } else {
+                inject_separator_ = true;
+            }
+            if(type_size_max_ == 0)
+                required_ = false;
+        }
+        return this;
+    }
+    /// Set a custom option type size range
+    Option *type_size(int option_type_size_min, int option_type_size_max) {
+        if(option_type_size_min < 0 || option_type_size_max < 0) {
+            // this section is included for backwards compatibility
+            expected_max_ = detail::expected_max_vector_size;
+            option_type_size_min = (std::abs)(option_type_size_min);
+            option_type_size_max = (std::abs)(option_type_size_max);
+        }
+
+        if(option_type_size_min > option_type_size_max) {
+            type_size_max_ = option_type_size_min;
+            type_size_min_ = option_type_size_max;
+        } else {
+            type_size_min_ = option_type_size_min;
+            type_size_max_ = option_type_size_max;
+        }
+        if(type_size_max_ == 0) {
+            required_ = false;
+        }
+        if(type_size_max_ >= detail::expected_max_vector_size) {
+            inject_separator_ = true;
+        }
+        return this;
+    }
+
+    /// Set the value of the separator injection flag
+    void inject_separator(bool value = true) { inject_separator_ = value; }
+
+    /// Set a capture function for the default. Mostly used by App.
+    Option *default_function(const std::function<std::string()> &func) {
+        default_function_ = func;
+        return this;
+    }
+
+    /// Capture the default value from the original value (if it can be captured)
+    Option *capture_default_str() {
+        if(default_function_) {
+            default_str_ = default_function_();
+        }
+        return this;
+    }
+
+    /// Set the default value string representation (does not change the contained value)
+    Option *default_str(std::string val) {
+        default_str_ = std::move(val);
+        return this;
+    }
+
+    /// Set the default value and validate the results and run the callback if appropriate to set the value into the
+    /// bound value only available for types that can be converted to a string
+    template <typename X> Option *default_val(const X &val) {
+        std::string val_str = detail::to_string(val);
+        auto old_option_state = current_option_state_;
+        results_t old_results{std::move(results_)};
+        results_.clear();
+        try {
+            add_result(val_str);
+            // if trigger_on_result_ is set the callback already ran
+            if(run_callback_for_default_ && !trigger_on_result_) {
+                run_callback();  // run callback sets the state we need to reset it again
+                current_option_state_ = option_state::parsing;
+            } else {
+                _validate_results(results_);
+                current_option_state_ = old_option_state;
+            }
+        } catch(const CLI::Error &) {
+            // this should be done
+            results_ = std::move(old_results);
+            current_option_state_ = old_option_state;
+            throw;
+        }
+        results_ = std::move(old_results);
+        default_str_ = std::move(val_str);
+        return this;
+    }
+
+    /// Get the full typename for this option
+    std::string get_type_name() const {
+        std::string full_type_name = type_name_();
+        if(!validators_.empty()) {
+            for(auto &Validator : validators_) {
+                std::string vtype = Validator.get_description();
+                if(!vtype.empty()) {
+                    full_type_name += ":" + vtype;
+                }
+            }
+        }
+        return full_type_name;
+    }
+
+  private:
+    /// Run the results through the Validators
+    void _validate_results(results_t &res) const {
+        // Run the Validators (can change the string)
+        if(!validators_.empty()) {
+            if(type_size_max_ > 1) {  // in this context index refers to the index in the type
+                int index = 0;
+                if(get_items_expected_max() < static_cast<int>(res.size()) &&
+                   multi_option_policy_ == CLI::MultiOptionPolicy::TakeLast) {
+                    // create a negative index for the earliest ones
+                    index = get_items_expected_max() - static_cast<int>(res.size());
+                }
+
+                for(std::string &result : res) {
+                    if(detail::is_separator(result) && type_size_max_ != type_size_min_ && index >= 0) {
+                        index = 0;  // reset index for variable size chunks
+                        continue;
+                    }
+                    auto err_msg = _validate(result, (index >= 0) ? (index % type_size_max_) : index);
+                    if(!err_msg.empty())
+                        throw ValidationError(get_name(), err_msg);
+                    ++index;
+                }
+            } else {
+                int index = 0;
+                if(expected_max_ < static_cast<int>(res.size()) &&
+                   multi_option_policy_ == CLI::MultiOptionPolicy::TakeLast) {
+                    // create a negative index for the earliest ones
+                    index = expected_max_ - static_cast<int>(res.size());
+                }
+                for(std::string &result : res) {
+                    auto err_msg = _validate(result, index);
+                    ++index;
+                    if(!err_msg.empty())
+                        throw ValidationError(get_name(), err_msg);
+                }
+            }
+        }
+    }
+
+    /** reduce the results in accordance with the MultiOptionPolicy
+    @param[out] res results are assigned to res if there if they are different
+    */
+    void _reduce_results(results_t &res, const results_t &original) const {
+
+        // max num items expected or length of vector, always at least 1
+        // Only valid for a trimming policy
+
+        res.clear();
+        // Operation depends on the policy setting
+        switch(multi_option_policy_) {
+        case MultiOptionPolicy::TakeAll:
+            break;
+        case MultiOptionPolicy::TakeLast: {
+            // Allow multi-option sizes (including 0)
+            std::size_t trim_size = std::min<std::size_t>(
+                static_cast<std::size_t>(std::max<int>(get_items_expected_max(), 1)), original.size());
+            if(original.size() != trim_size) {
+                res.assign(original.end() - static_cast<results_t::difference_type>(trim_size), original.end());
+            }
+        } break;
+        case MultiOptionPolicy::TakeFirst: {
+            std::size_t trim_size = std::min<std::size_t>(
+                static_cast<std::size_t>(std::max<int>(get_items_expected_max(), 1)), original.size());
+            if(original.size() != trim_size) {
+                res.assign(original.begin(), original.begin() + static_cast<results_t::difference_type>(trim_size));
+            }
+        } break;
+        case MultiOptionPolicy::Join:
+            if(results_.size() > 1) {
+                res.push_back(detail::join(original, std::string(1, (delimiter_ == '\0') ? '\n' : delimiter_)));
+            }
+            break;
+        case MultiOptionPolicy::Throw:
+        default: {
+            auto num_min = static_cast<std::size_t>(get_items_expected_min());
+            auto num_max = static_cast<std::size_t>(get_items_expected_max());
+            if(num_min == 0) {
+                num_min = 1;
+            }
+            if(num_max == 0) {
+                num_max = 1;
+            }
+            if(original.size() < num_min) {
+                throw ArgumentMismatch::AtLeast(get_name(), static_cast<int>(num_min), original.size());
+            }
+            if(original.size() > num_max) {
+                throw ArgumentMismatch::AtMost(get_name(), static_cast<int>(num_max), original.size());
+            }
+            break;
+        }
+        }
+    }
+
+    // Run a result through the Validators
+    std::string _validate(std::string &result, int index) const {
+        std::string err_msg;
+        if(result.empty() && expected_min_ == 0) {
+            // an empty with nothing expected is allowed
+            return err_msg;
+        }
+        for(const auto &vali : validators_) {
+            auto v = vali.get_application_index();
+            if(v == -1 || v == index) {
+                try {
+                    err_msg = vali(result);
+                } catch(const ValidationError &err) {
+                    err_msg = err.what();
+                }
+                if(!err_msg.empty())
+                    break;
+            }
+        }
+
+        return err_msg;
+    }
+
+    /// Add a single result to the result set, taking into account delimiters
+    int _add_result(std::string &&result, std::vector<std::string> &res) const {
+        int result_count = 0;
+        if(allow_extra_args_ && !result.empty() && result.front() == '[' &&
+           result.back() == ']') {  // this is now a vector string likely from the default or user entry
+            result.pop_back();
+
+            for(auto &var : CLI::detail::split(result.substr(1), ',')) {
+                if(!var.empty()) {
+                    result_count += _add_result(std::move(var), res);
+                }
+            }
+            return result_count;
+        }
+        if(delimiter_ == '\0') {
+            res.push_back(std::move(result));
+            ++result_count;
+        } else {
+            if((result.find_first_of(delimiter_) != std::string::npos)) {
+                for(const auto &var : CLI::detail::split(result, delimiter_)) {
+                    if(!var.empty()) {
+                        res.push_back(var);
+                        ++result_count;
+                    }
+                }
+            } else {
+                res.push_back(std::move(result));
+                ++result_count;
+            }
+        }
+        return result_count;
+    }
+};  // namespace CLI
+
+// [CLI11:option_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/Split.hpp b/src/phasicFlow/commandLine/CLI/Split.hpp
new file mode 100644
index 00000000..83ef572c
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Split.hpp
@@ -0,0 +1,143 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:end]
+
+#include "Error.hpp"
+#include "StringTools.hpp"
+
+namespace CLI {
+// [CLI11:split_hpp:verbatim]
+
+namespace detail {
+
+// Returns false if not a short option. Otherwise, sets opt name and rest and returns true
+inline bool split_short(const std::string &current, std::string &name, std::string &rest) {
+    if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {
+        name = current.substr(1, 1);
+        rest = current.substr(2);
+        return true;
+    }
+    return false;
+}
+
+// Returns false if not a long option. Otherwise, sets opt name and other side of = and returns true
+inline bool split_long(const std::string &current, std::string &name, std::string &value) {
+    if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
+        auto loc = current.find_first_of('=');
+        if(loc != std::string::npos) {
+            name = current.substr(2, loc - 2);
+            value = current.substr(loc + 1);
+        } else {
+            name = current.substr(2);
+            value = "";
+        }
+        return true;
+    }
+    return false;
+}
+
+// Returns false if not a windows style option. Otherwise, sets opt name and value and returns true
+inline bool split_windows_style(const std::string &current, std::string &name, std::string &value) {
+    if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {
+        auto loc = current.find_first_of(':');
+        if(loc != std::string::npos) {
+            name = current.substr(1, loc - 1);
+            value = current.substr(loc + 1);
+        } else {
+            name = current.substr(1);
+            value = "";
+        }
+        return true;
+    }
+    return false;
+}
+
+// Splits a string into multiple long and short names
+inline std::vector<std::string> split_names(std::string current) {
+    std::vector<std::string> output;
+    std::size_t val;
+    while((val = current.find(",")) != std::string::npos) {
+        output.push_back(trim_copy(current.substr(0, val)));
+        current = current.substr(val + 1);
+    }
+    output.push_back(trim_copy(current));
+    return output;
+}
+
+/// extract default flag values either {def} or starting with a !
+inline std::vector<std::pair<std::string, std::string>> get_default_flag_values(const std::string &str) {
+    std::vector<std::string> flags = split_names(str);
+    flags.erase(std::remove_if(flags.begin(),
+                               flags.end(),
+                               [](const std::string &name) {
+                                   return ((name.empty()) || (!(((name.find_first_of('{') != std::string::npos) &&
+                                                                 (name.back() == '}')) ||
+                                                                (name[0] == '!'))));
+                               }),
+                flags.end());
+    std::vector<std::pair<std::string, std::string>> output;
+    output.reserve(flags.size());
+    for(auto &flag : flags) {
+        auto def_start = flag.find_first_of('{');
+        std::string defval = "false";
+        if((def_start != std::string::npos) && (flag.back() == '}')) {
+            defval = flag.substr(def_start + 1);
+            defval.pop_back();
+            flag.erase(def_start, std::string::npos);
+        }
+        flag.erase(0, flag.find_first_not_of("-!"));
+        output.emplace_back(flag, defval);
+    }
+    return output;
+}
+
+/// Get a vector of short names, one of long names, and a single name
+inline std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>
+get_names(const std::vector<std::string> &input) {
+
+    std::vector<std::string> short_names;
+    std::vector<std::string> long_names;
+    std::string pos_name;
+
+    for(std::string name : input) {
+        if(name.length() == 0) {
+            continue;
+        }
+        if(name.length() > 1 && name[0] == '-' && name[1] != '-') {
+            if(name.length() == 2 && valid_first_char(name[1]))
+                short_names.emplace_back(1, name[1]);
+            else
+                throw BadNameString::OneCharName(name);
+        } else if(name.length() > 2 && name.substr(0, 2) == "--") {
+            name = name.substr(2);
+            if(valid_name_string(name))
+                long_names.push_back(name);
+            else
+                throw BadNameString::BadLongName(name);
+        } else if(name == "-" || name == "--") {
+            throw BadNameString::DashesOnly(name);
+        } else {
+            if(pos_name.length() > 0)
+                throw BadNameString::MultiPositionalNames(name);
+            pos_name = name;
+        }
+    }
+
+    return std::tuple<std::vector<std::string>, std::vector<std::string>, std::string>(
+        short_names, long_names, pos_name);
+}
+
+}  // namespace detail
+// [CLI11:split_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/StringTools.hpp b/src/phasicFlow/commandLine/CLI/StringTools.hpp
new file mode 100644
index 00000000..4718aedd
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/StringTools.hpp
@@ -0,0 +1,430 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <algorithm>
+#include <iomanip>
+#include <locale>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+// [CLI11:public_includes:end]
+
+namespace CLI {
+
+// [CLI11:string_tools_hpp:verbatim]
+
+/// Include the items in this namespace to get free conversion of enums to/from streams.
+/// (This is available inside CLI as well, so CLI11 will use this without a using statement).
+namespace enums {
+
+/// output streaming for enumerations
+template <typename T, typename = typename std::enable_if<std::is_enum<T>::value>::type>
+std::ostream &operator<<(std::ostream &in, const T &item) {
+    // make sure this is out of the detail namespace otherwise it won't be found when needed
+    return in << static_cast<typename std::underlying_type<T>::type>(item);
+}
+
+}  // namespace enums
+
+/// Export to CLI namespace
+using enums::operator<<;
+
+namespace detail {
+/// a constant defining an expected max vector size defined to be a big number that could be multiplied by 4 and not
+/// produce overflow for some expected uses
+constexpr int expected_max_vector_size{1 << 29};
+// Based on http://stackoverflow.com/questions/236129/split-a-string-in-c
+/// Split a string by a delim
+inline std::vector<std::string> split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    // Check to see if empty string, give consistent result
+    if(s.empty()) {
+        elems.emplace_back();
+    } else {
+        std::stringstream ss;
+        ss.str(s);
+        std::string item;
+        while(std::getline(ss, item, delim)) {
+            elems.push_back(item);
+        }
+    }
+    return elems;
+}
+
+/// Simple function to join a string
+template <typename T> std::string join(const T &v, std::string delim = ",") {
+    std::ostringstream s;
+    auto beg = std::begin(v);
+    auto end = std::end(v);
+    if(beg != end)
+        s << *beg++;
+    while(beg != end) {
+        s << delim << *beg++;
+    }
+    return s.str();
+}
+
+/// Simple function to join a string from processed elements
+template <typename T,
+          typename Callable,
+          typename = typename std::enable_if<!std::is_constructible<std::string, Callable>::value>::type>
+std::string join(const T &v, Callable func, std::string delim = ",") {
+    std::ostringstream s;
+    auto beg = std::begin(v);
+    auto end = std::end(v);
+    auto loc = s.tellp();
+    while(beg != end) {
+        auto nloc = s.tellp();
+        if(nloc > loc) {
+            s << delim;
+            loc = nloc;
+        }
+        s << func(*beg++);
+    }
+    return s.str();
+}
+
+/// Join a string in reverse order
+template <typename T> std::string rjoin(const T &v, std::string delim = ",") {
+    std::ostringstream s;
+    for(std::size_t start = 0; start < v.size(); start++) {
+        if(start > 0)
+            s << delim;
+        s << v[v.size() - start - 1];
+    }
+    return s.str();
+}
+
+// Based roughly on http://stackoverflow.com/questions/25829143/c-trim-whitespace-from-a-string
+
+/// Trim whitespace from left of string
+inline std::string &ltrim(std::string &str) {
+    auto it = std::find_if(str.begin(), str.end(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
+    str.erase(str.begin(), it);
+    return str;
+}
+
+/// Trim anything from left of string
+inline std::string &ltrim(std::string &str, const std::string &filter) {
+    auto it = std::find_if(str.begin(), str.end(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
+    str.erase(str.begin(), it);
+    return str;
+}
+
+/// Trim whitespace from right of string
+inline std::string &rtrim(std::string &str) {
+    auto it = std::find_if(str.rbegin(), str.rend(), [](char ch) { return !std::isspace<char>(ch, std::locale()); });
+    str.erase(it.base(), str.end());
+    return str;
+}
+
+/// Trim anything from right of string
+inline std::string &rtrim(std::string &str, const std::string &filter) {
+    auto it =
+        std::find_if(str.rbegin(), str.rend(), [&filter](char ch) { return filter.find(ch) == std::string::npos; });
+    str.erase(it.base(), str.end());
+    return str;
+}
+
+/// Trim whitespace from string
+inline std::string &trim(std::string &str) { return ltrim(rtrim(str)); }
+
+/// Trim anything from string
+inline std::string &trim(std::string &str, const std::string filter) { return ltrim(rtrim(str, filter), filter); }
+
+/// Make a copy of the string and then trim it
+inline std::string trim_copy(const std::string &str) {
+    std::string s = str;
+    return trim(s);
+}
+
+/// remove quotes at the front and back of a string either '"' or '\''
+inline std::string &remove_quotes(std::string &str) {
+    if(str.length() > 1 && (str.front() == '"' || str.front() == '\'')) {
+        if(str.front() == str.back()) {
+            str.pop_back();
+            str.erase(str.begin(), str.begin() + 1);
+        }
+    }
+    return str;
+}
+
+/// Add a leader to the beginning of all new lines (nothing is added
+/// at the start of the first line). `"; "` would be for ini files
+///
+/// Can't use Regex, or this would be a subs.
+inline std::string fix_newlines(const std::string &leader, std::string input) {
+    std::string::size_type n = 0;
+    while(n != std::string::npos && n < input.size()) {
+        n = input.find('\n', n);
+        if(n != std::string::npos) {
+            input = input.substr(0, n + 1) + leader + input.substr(n + 1);
+            n += leader.size();
+        }
+    }
+    return input;
+}
+
+/// Make a copy of the string and then trim it, any filter string can be used (any char in string is filtered)
+inline std::string trim_copy(const std::string &str, const std::string &filter) {
+    std::string s = str;
+    return trim(s, filter);
+}
+/// Print a two part "help" string
+inline std::ostream &format_help(std::ostream &out, std::string name, const std::string &description, std::size_t wid) {
+    name = "  " + name;
+    out << std::setw(static_cast<int>(wid)) << std::left << name;
+    if(!description.empty()) {
+        if(name.length() >= wid)
+            out << "\n" << std::setw(static_cast<int>(wid)) << "";
+        for(const char c : description) {
+            out.put(c);
+            if(c == '\n') {
+                out << std::setw(static_cast<int>(wid)) << "";
+            }
+        }
+    }
+    out << "\n";
+    return out;
+}
+
+/// Print subcommand aliases
+inline std::ostream &format_aliases(std::ostream &out, const std::vector<std::string> &aliases, std::size_t wid) {
+    if(!aliases.empty()) {
+        out << std::setw(static_cast<int>(wid)) << "     aliases: ";
+        bool front = true;
+        for(const auto &alias : aliases) {
+            if(!front) {
+                out << ", ";
+            } else {
+                front = false;
+            }
+            out << detail::fix_newlines("              ", alias);
+        }
+        out << "\n";
+    }
+    return out;
+}
+
+/// Verify the first character of an option
+/// - is a trigger character, ! has special meaning and new lines would just be annoying to deal with
+template <typename T> bool valid_first_char(T c) { return ((c != '-') && (c != '!') && (c != ' ') && c != '\n'); }
+
+/// Verify following characters of an option
+template <typename T> bool valid_later_char(T c) {
+    // = and : are value separators, { has special meaning for option defaults,
+    // and \n would just be annoying to deal with in many places allowing space here has too much potential for
+    // inadvertent entry errors and bugs
+    return ((c != '=') && (c != ':') && (c != '{') && (c != ' ') && c != '\n');
+}
+
+/// Verify an option/subcommand name
+inline bool valid_name_string(const std::string &str) {
+    if(str.empty() || !valid_first_char(str[0])) {
+        return false;
+    }
+    auto e = str.end();
+    for(auto c = str.begin() + 1; c != e; ++c)
+        if(!valid_later_char(*c))
+            return false;
+    return true;
+}
+
+/// Verify an app name
+inline bool valid_alias_name_string(const std::string &str) {
+    static const std::string badChars(std::string("\n") + '\0');
+    return (str.find_first_of(badChars) == std::string::npos);
+}
+
+/// check if a string is a container segment separator (empty or "%%")
+inline bool is_separator(const std::string &str) {
+    static const std::string sep("%%");
+    return (str.empty() || str == sep);
+}
+
+/// Verify that str consists of letters only
+inline bool isalpha(const std::string &str) {
+    return std::all_of(str.begin(), str.end(), [](char c) { return std::isalpha(c, std::locale()); });
+}
+
+/// Return a lower case version of a string
+inline std::string to_lower(std::string str) {
+    std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
+        return std::tolower(x, std::locale());
+    });
+    return str;
+}
+
+/// remove underscores from a string
+inline std::string remove_underscore(std::string str) {
+    str.erase(std::remove(std::begin(str), std::end(str), '_'), std::end(str));
+    return str;
+}
+
+/// Find and replace a substring with another substring
+inline std::string find_and_replace(std::string str, std::string from, std::string to) {
+
+    std::size_t start_pos = 0;
+
+    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
+        str.replace(start_pos, from.length(), to);
+        start_pos += to.length();
+    }
+
+    return str;
+}
+
+/// check if the flag definitions has possible false flags
+inline bool has_default_flag_values(const std::string &flags) {
+    return (flags.find_first_of("{!") != std::string::npos);
+}
+
+inline void remove_default_flag_values(std::string &flags) {
+    auto loc = flags.find_first_of('{', 2);
+    while(loc != std::string::npos) {
+        auto finish = flags.find_first_of("},", loc + 1);
+        if((finish != std::string::npos) && (flags[finish] == '}')) {
+            flags.erase(flags.begin() + static_cast<std::ptrdiff_t>(loc),
+                        flags.begin() + static_cast<std::ptrdiff_t>(finish) + 1);
+        }
+        loc = flags.find_first_of('{', loc + 1);
+    }
+    flags.erase(std::remove(flags.begin(), flags.end(), '!'), flags.end());
+}
+
+/// Check if a string is a member of a list of strings and optionally ignore case or ignore underscores
+inline std::ptrdiff_t find_member(std::string name,
+                                  const std::vector<std::string> names,
+                                  bool ignore_case = false,
+                                  bool ignore_underscore = false) {
+    auto it = std::end(names);
+    if(ignore_case) {
+        if(ignore_underscore) {
+            name = detail::to_lower(detail::remove_underscore(name));
+            it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
+                return detail::to_lower(detail::remove_underscore(local_name)) == name;
+            });
+        } else {
+            name = detail::to_lower(name);
+            it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
+                return detail::to_lower(local_name) == name;
+            });
+        }
+
+    } else if(ignore_underscore) {
+        name = detail::remove_underscore(name);
+        it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
+            return detail::remove_underscore(local_name) == name;
+        });
+    } else {
+        it = std::find(std::begin(names), std::end(names), name);
+    }
+
+    return (it != std::end(names)) ? (it - std::begin(names)) : (-1);
+}
+
+/// Find a trigger string and call a modify callable function that takes the current string and starting position of the
+/// trigger and returns the position in the string to search for the next trigger string
+template <typename Callable> inline std::string find_and_modify(std::string str, std::string trigger, Callable modify) {
+    std::size_t start_pos = 0;
+    while((start_pos = str.find(trigger, start_pos)) != std::string::npos) {
+        start_pos = modify(str, start_pos);
+    }
+    return str;
+}
+
+/// Split a string '"one two" "three"' into 'one two', 'three'
+/// Quote characters can be ` ' or "
+inline std::vector<std::string> split_up(std::string str, char delimiter = '\0') {
+
+    const std::string delims("\'\"`");
+    auto find_ws = [delimiter](char ch) {
+        return (delimiter == '\0') ? (std::isspace<char>(ch, std::locale()) != 0) : (ch == delimiter);
+    };
+    trim(str);
+
+    std::vector<std::string> output;
+    bool embeddedQuote = false;
+    char keyChar = ' ';
+    while(!str.empty()) {
+        if(delims.find_first_of(str[0]) != std::string::npos) {
+            keyChar = str[0];
+            auto end = str.find_first_of(keyChar, 1);
+            while((end != std::string::npos) && (str[end - 1] == '\\')) {  // deal with escaped quotes
+                end = str.find_first_of(keyChar, end + 1);
+                embeddedQuote = true;
+            }
+            if(end != std::string::npos) {
+                output.push_back(str.substr(1, end - 1));
+                if(end + 2 < str.size()) {
+                    str = str.substr(end + 2);
+                } else {
+                    str.clear();
+                }
+
+            } else {
+                output.push_back(str.substr(1));
+                str = "";
+            }
+        } else {
+            auto it = std::find_if(std::begin(str), std::end(str), find_ws);
+            if(it != std::end(str)) {
+                std::string value = std::string(str.begin(), it);
+                output.push_back(value);
+                str = std::string(it + 1, str.end());
+            } else {
+                output.push_back(str);
+                str = "";
+            }
+        }
+        // transform any embedded quotes into the regular character
+        if(embeddedQuote) {
+            output.back() = find_and_replace(output.back(), std::string("\\") + keyChar, std::string(1, keyChar));
+            embeddedQuote = false;
+        }
+        trim(str);
+    }
+    return output;
+}
+
+/// This function detects an equal or colon followed by an escaped quote after an argument
+/// then modifies the string to replace the equality with a space.  This is needed
+/// to allow the split up function to work properly and is intended to be used with the find_and_modify function
+/// the return value is the offset+1 which is required by the find_and_modify function.
+inline std::size_t escape_detect(std::string &str, std::size_t offset) {
+    auto next = str[offset + 1];
+    if((next == '\"') || (next == '\'') || (next == '`')) {
+        auto astart = str.find_last_of("-/ \"\'`", offset - 1);
+        if(astart != std::string::npos) {
+            if(str[astart] == ((str[offset] == '=') ? '-' : '/'))
+                str[offset] = ' ';  // interpret this as a space so the split_up works properly
+        }
+    }
+    return offset + 1;
+}
+
+/// Add quotes if the string contains spaces
+inline std::string &add_quotes_if_needed(std::string &str) {
+    if((str.front() != '"' && str.front() != '\'') || str.front() != str.back()) {
+        char quote = str.find('"') < str.find('\'') ? '\'' : '"';
+        if(str.find(' ') != std::string::npos) {
+            str.insert(0, 1, quote);
+            str.append(1, quote);
+        }
+    }
+    return str;
+}
+
+}  // namespace detail
+
+// [CLI11:string_tools_hpp:end]
+
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/Timer.hpp b/src/phasicFlow/commandLine/CLI/Timer.hpp
new file mode 100644
index 00000000..429ca026
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Timer.hpp
@@ -0,0 +1,134 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// On GCC < 4.8, the following define is often missing. Due to the
+// fact that this library only uses sleep_for, this should be safe
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5 && __GNUC_MINOR__ < 8
+#define _GLIBCXX_USE_NANOSLEEP
+#endif
+
+#include <array>
+#include <chrono>
+#include <functional>
+#include <iostream>
+#include <string>
+#include <utility>
+
+namespace CLI {
+
+/// This is a simple timer with pretty printing. Creating the timer starts counting.
+class Timer {
+  protected:
+    /// This is a typedef to make clocks easier to use
+    using clock = std::chrono::steady_clock;
+
+    /// This typedef is for points in time
+    using time_point = std::chrono::time_point<clock>;
+
+    /// This is the type of a printing function, you can make your own
+    using time_print_t = std::function<std::string(std::string, std::string)>;
+
+    /// This is the title of the timer
+    std::string title_;
+
+    /// This is the function that is used to format most of the timing message
+    time_print_t time_print_;
+
+    /// This is the starting point (when the timer was created)
+    time_point start_;
+
+    /// This is the number of times cycles (print divides by this number)
+    std::size_t cycles{1};
+
+  public:
+    /// Standard print function, this one is set by default
+    static std::string Simple(std::string title, std::string time) { return title + ": " + time; }
+
+    /// This is a fancy print function with --- headers
+    static std::string Big(std::string title, std::string time) {
+        return std::string("-----------------------------------------\n") + "| " + title + " | Time = " + time + "\n" +
+               "-----------------------------------------";
+    }
+
+  public:
+    /// Standard constructor, can set title and print function
+    explicit Timer(std::string title = "Timer", time_print_t time_print = Simple)
+        : title_(std::move(title)), time_print_(std::move(time_print)), start_(clock::now()) {}
+
+    /// Time a function by running it multiple times. Target time is the len to target.
+    std::string time_it(std::function<void()> f, double target_time = 1) {
+        time_point start = start_;
+        double total_time;
+
+        start_ = clock::now();
+        std::size_t n = 0;
+        do {
+            f();
+            std::chrono::duration<double> elapsed = clock::now() - start_;
+            total_time = elapsed.count();
+        } while(n++ < 100u && total_time < target_time);
+
+        std::string out = make_time_str(total_time / static_cast<double>(n)) + " for " + std::to_string(n) + " tries";
+        start_ = start;
+        return out;
+    }
+
+    /// This formats the numerical value for the time string
+    std::string make_time_str() const {
+        time_point stop = clock::now();
+        std::chrono::duration<double> elapsed = stop - start_;
+        double time = elapsed.count() / static_cast<double>(cycles);
+        return make_time_str(time);
+    }
+
+    // LCOV_EXCL_START
+    /// This prints out a time string from a time
+    std::string make_time_str(double time) const {
+        auto print_it = [](double x, std::string unit) {
+            const unsigned int buffer_length = 50;
+            std::array<char, buffer_length> buffer;
+            std::snprintf(buffer.data(), buffer_length, "%.5g", x);
+            return buffer.data() + std::string(" ") + unit;
+        };
+
+        if(time < .000001)
+            return print_it(time * 1000000000, "ns");
+        else if(time < .001)
+            return print_it(time * 1000000, "us");
+        else if(time < 1)
+            return print_it(time * 1000, "ms");
+        else
+            return print_it(time, "s");
+    }
+    // LCOV_EXCL_STOP
+
+    /// This is the main function, it creates a string
+    std::string to_string() const { return time_print_(title_, make_time_str()); }
+
+    /// Division sets the number of cycles to divide by (no graphical change)
+    Timer &operator/(std::size_t val) {
+        cycles = val;
+        return *this;
+    }
+};
+
+/// This class prints out the time upon destruction
+class AutoTimer : public Timer {
+  public:
+    /// Reimplementing the constructor is required in GCC 4.7
+    explicit AutoTimer(std::string title = "Timer", time_print_t time_print = Simple) : Timer(title, time_print) {}
+    // GCC 4.7 does not support using inheriting constructors.
+
+    /// This destructor prints the string
+    ~AutoTimer() { std::cout << to_string() << std::endl; }
+};
+
+}  // namespace CLI
+
+/// This prints out the time if shifted into a std::cout like stream.
+inline std::ostream &operator<<(std::ostream &in, const CLI::Timer &timer) { return in << timer.to_string(); }
diff --git a/src/phasicFlow/commandLine/CLI/TypeTools.hpp b/src/phasicFlow/commandLine/CLI/TypeTools.hpp
new file mode 100644
index 00000000..2b87ec60
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/TypeTools.hpp
@@ -0,0 +1,1548 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:public_includes:set]
+#include <cstdint>
+#include <exception>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:end]
+
+#include "StringTools.hpp"
+
+namespace CLI {
+// [CLI11:type_tools_hpp:verbatim]
+
+// Type tools
+
+// Utilities for type enabling
+namespace detail {
+// Based generally on https://rmf.io/cxx11/almost-static-if
+/// Simple empty scoped class
+enum class enabler {};
+
+/// An instance to use in EnableIf
+constexpr enabler dummy = {};
+}  // namespace detail
+
+/// A copy of enable_if_t from C++14, compatible with C++11.
+///
+/// We could check to see if C++14 is being used, but it does not hurt to redefine this
+/// (even Google does this: https://github.com/google/skia/blob/master/include/private/SkTLogic.h)
+/// It is not in the std namespace anyway, so no harm done.
+template <bool B, class T = void> using enable_if_t = typename std::enable_if<B, T>::type;
+
+/// A copy of std::void_t from C++17 (helper for C++11 and C++14)
+template <typename... Ts> struct make_void { using type = void; };
+
+/// A copy of std::void_t from C++17 - same reasoning as enable_if_t, it does not hurt to redefine
+template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+
+/// A copy of std::conditional_t from C++14 - same reasoning as enable_if_t, it does not hurt to redefine
+template <bool B, class T, class F> using conditional_t = typename std::conditional<B, T, F>::type;
+
+/// Check to see if something is bool (fail check by default)
+template <typename T> struct is_bool : std::false_type {};
+
+/// Check to see if something is bool (true if actually a bool)
+template <> struct is_bool<bool> : std::true_type {};
+
+/// Check to see if something is a shared pointer
+template <typename T> struct is_shared_ptr : std::false_type {};
+
+/// Check to see if something is a shared pointer (True if really a shared pointer)
+template <typename T> struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+
+/// Check to see if something is a shared pointer (True if really a shared pointer)
+template <typename T> struct is_shared_ptr<const std::shared_ptr<T>> : std::true_type {};
+
+/// Check to see if something is copyable pointer
+template <typename T> struct is_copyable_ptr {
+    static bool const value = is_shared_ptr<T>::value || std::is_pointer<T>::value;
+};
+
+/// This can be specialized to override the type deduction for IsMember.
+template <typename T> struct IsMemberType { using type = T; };
+
+/// The main custom type needed here is const char * should be a string.
+template <> struct IsMemberType<const char *> { using type = std::string; };
+
+namespace detail {
+
+// These are utilities for IsMember and other transforming objects
+
+/// Handy helper to access the element_type generically. This is not part of is_copyable_ptr because it requires that
+/// pointer_traits<T> be valid.
+
+/// not a pointer
+template <typename T, typename Enable = void> struct element_type { using type = T; };
+
+template <typename T> struct element_type<T, typename std::enable_if<is_copyable_ptr<T>::value>::type> {
+    using type = typename std::pointer_traits<T>::element_type;
+};
+
+/// Combination of the element type and value type - remove pointer (including smart pointers) and get the value_type of
+/// the container
+template <typename T> struct element_value_type { using type = typename element_type<T>::type::value_type; };
+
+/// Adaptor for set-like structure: This just wraps a normal container in a few utilities that do almost nothing.
+template <typename T, typename _ = void> struct pair_adaptor : std::false_type {
+    using value_type = typename T::value_type;
+    using first_type = typename std::remove_const<value_type>::type;
+    using second_type = typename std::remove_const<value_type>::type;
+
+    /// Get the first value (really just the underlying value)
+    template <typename Q> static auto first(Q &&pair_value) -> decltype(std::forward<Q>(pair_value)) {
+        return std::forward<Q>(pair_value);
+    }
+    /// Get the second value (really just the underlying value)
+    template <typename Q> static auto second(Q &&pair_value) -> decltype(std::forward<Q>(pair_value)) {
+        return std::forward<Q>(pair_value);
+    }
+};
+
+/// Adaptor for map-like structure (true version, must have key_type and mapped_type).
+/// This wraps a mapped container in a few utilities access it in a general way.
+template <typename T>
+struct pair_adaptor<
+    T,
+    conditional_t<false, void_t<typename T::value_type::first_type, typename T::value_type::second_type>, void>>
+    : std::true_type {
+    using value_type = typename T::value_type;
+    using first_type = typename std::remove_const<typename value_type::first_type>::type;
+    using second_type = typename std::remove_const<typename value_type::second_type>::type;
+
+    /// Get the first value (really just the underlying value)
+    template <typename Q> static auto first(Q &&pair_value) -> decltype(std::get<0>(std::forward<Q>(pair_value))) {
+        return std::get<0>(std::forward<Q>(pair_value));
+    }
+    /// Get the second value (really just the underlying value)
+    template <typename Q> static auto second(Q &&pair_value) -> decltype(std::get<1>(std::forward<Q>(pair_value))) {
+        return std::get<1>(std::forward<Q>(pair_value));
+    }
+};
+
+// Warning is suppressed due to "bug" in gcc<5.0 and gcc 7.0 with c++17 enabled that generates a Wnarrowing warning
+// in the unevaluated context even if the function that was using this wasn't used.  The standard says narrowing in
+// brace initialization shouldn't be allowed but for backwards compatibility gcc allows it in some contexts.  It is a
+// little fuzzy what happens in template constructs and I think that was something GCC took a little while to work out.
+// But regardless some versions of gcc generate a warning when they shouldn't from the following code so that should be
+// suppressed
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnarrowing"
+#endif
+// check for constructibility from a specific type and copy assignable used in the parse detection
+template <typename T, typename C> class is_direct_constructible {
+    template <typename TT, typename CC>
+    static auto test(int, std::true_type) -> decltype(
+// NVCC warns about narrowing conversions here
+#ifdef __CUDACC__
+#pragma diag_suppress 2361
+#endif
+        TT { std::declval<CC>() }
+#ifdef __CUDACC__
+#pragma diag_default 2361
+#endif
+        ,
+        std::is_move_assignable<TT>());
+
+    template <typename TT, typename CC> static auto test(int, std::false_type) -> std::false_type;
+
+    template <typename, typename> static auto test(...) -> std::false_type;
+
+  public:
+    static constexpr bool value = decltype(test<T, C>(0, typename std::is_constructible<T, C>::type()))::value;
+};
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+// Check for output streamability
+// Based on https://stackoverflow.com/questions/22758291/how-can-i-detect-if-a-type-can-be-streamed-to-an-stdostream
+
+template <typename T, typename S = std::ostringstream> class is_ostreamable {
+    template <typename TT, typename SS>
+    static auto test(int) -> decltype(std::declval<SS &>() << std::declval<TT>(), std::true_type());
+
+    template <typename, typename> static auto test(...) -> std::false_type;
+
+  public:
+    static constexpr bool value = decltype(test<T, S>(0))::value;
+};
+
+/// Check for input streamability
+template <typename T, typename S = std::istringstream> class is_istreamable {
+    template <typename TT, typename SS>
+    static auto test(int) -> decltype(std::declval<SS &>() >> std::declval<TT &>(), std::true_type());
+
+    template <typename, typename> static auto test(...) -> std::false_type;
+
+  public:
+    static constexpr bool value = decltype(test<T, S>(0))::value;
+};
+
+/// Check for complex
+template <typename T> class is_complex {
+    template <typename TT>
+    static auto test(int) -> decltype(std::declval<TT>().real(), std::declval<TT>().imag(), std::true_type());
+
+    template <typename> static auto test(...) -> std::false_type;
+
+  public:
+    static constexpr bool value = decltype(test<T>(0))::value;
+};
+
+/// Templated operation to get a value from a stream
+template <typename T, enable_if_t<is_istreamable<T>::value, detail::enabler> = detail::dummy>
+bool from_stream(const std::string &istring, T &obj) {
+    std::istringstream is;
+    is.str(istring);
+    is >> obj;
+    return !is.fail() && !is.rdbuf()->in_avail();
+}
+
+template <typename T, enable_if_t<!is_istreamable<T>::value, detail::enabler> = detail::dummy>
+bool from_stream(const std::string & /*istring*/, T & /*obj*/) {
+    return false;
+}
+
+// check to see if an object is a mutable container (fail by default)
+template <typename T, typename _ = void> struct is_mutable_container : std::false_type {};
+
+/// type trait to test if a type is a mutable container meaning it has a value_type, it has an iterator, a clear, and
+/// end methods and an insert function.  And for our purposes we exclude std::string and types that can be constructed
+/// from a std::string
+template <typename T>
+struct is_mutable_container<
+    T,
+    conditional_t<false,
+                  void_t<typename T::value_type,
+                         decltype(std::declval<T>().end()),
+                         decltype(std::declval<T>().clear()),
+                         decltype(std::declval<T>().insert(std::declval<decltype(std::declval<T>().end())>(),
+                                                           std::declval<const typename T::value_type &>()))>,
+                  void>>
+    : public conditional_t<std::is_constructible<T, std::string>::value, std::false_type, std::true_type> {};
+
+// check to see if an object is a mutable container (fail by default)
+template <typename T, typename _ = void> struct is_readable_container : std::false_type {};
+
+/// type trait to test if a type is a container meaning it has a value_type, it has an iterator, a clear, and an end
+/// methods and an insert function.  And for our purposes we exclude std::string and types that can be constructed from
+/// a std::string
+template <typename T>
+struct is_readable_container<
+    T,
+    conditional_t<false, void_t<decltype(std::declval<T>().end()), decltype(std::declval<T>().begin())>, void>>
+    : public std::true_type {};
+
+// check to see if an object is a wrapper (fail by default)
+template <typename T, typename _ = void> struct is_wrapper : std::false_type {};
+
+// check if an object is a wrapper (it has a value_type defined)
+template <typename T>
+struct is_wrapper<T, conditional_t<false, void_t<typename T::value_type>, void>> : public std::true_type {};
+
+// Check for tuple like types, as in classes with a tuple_size type trait
+template <typename S> class is_tuple_like {
+    template <typename SS>
+    // static auto test(int)
+    //     -> decltype(std::conditional<(std::tuple_size<SS>::value > 0), std::true_type, std::false_type>::type());
+    static auto test(int) -> decltype(std::tuple_size<typename std::decay<SS>::type>::value, std::true_type{});
+    template <typename> static auto test(...) -> std::false_type;
+
+  public:
+    static constexpr bool value = decltype(test<S>(0))::value;
+};
+
+/// Convert an object to a string (directly forward if this can become a string)
+template <typename T, enable_if_t<std::is_convertible<T, std::string>::value, detail::enabler> = detail::dummy>
+auto to_string(T &&value) -> decltype(std::forward<T>(value)) {
+    return std::forward<T>(value);
+}
+
+/// Construct a string from the object
+template <typename T,
+          enable_if_t<std::is_constructible<std::string, T>::value && !std::is_convertible<T, std::string>::value,
+                      detail::enabler> = detail::dummy>
+std::string to_string(const T &value) {
+    return std::string(value);
+}
+
+/// Convert an object to a string (streaming must be supported for that type)
+template <typename T,
+          enable_if_t<!std::is_convertible<std::string, T>::value && !std::is_constructible<std::string, T>::value &&
+                          is_ostreamable<T>::value,
+                      detail::enabler> = detail::dummy>
+std::string to_string(T &&value) {
+    std::stringstream stream;
+    stream << value;
+    return stream.str();
+}
+
+/// If conversion is not supported, return an empty string (streaming is not supported for that type)
+template <typename T,
+          enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
+                          !is_readable_container<typename std::remove_const<T>::type>::value,
+                      detail::enabler> = detail::dummy>
+std::string to_string(T &&) {
+    return std::string{};
+}
+
+/// convert a readable container to a string
+template <typename T,
+          enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
+                          is_readable_container<T>::value,
+                      detail::enabler> = detail::dummy>
+std::string to_string(T &&variable) {
+    std::vector<std::string> defaults;
+    auto cval = variable.begin();
+    auto end = variable.end();
+    while(cval != end) {
+        defaults.emplace_back(CLI::detail::to_string(*cval));
+        ++cval;
+    }
+    return std::string("[" + detail::join(defaults) + "]");
+}
+
+/// special template overload
+template <typename T1,
+          typename T2,
+          typename T,
+          enable_if_t<std::is_same<T1, T2>::value, detail::enabler> = detail::dummy>
+auto checked_to_string(T &&value) -> decltype(to_string(std::forward<T>(value))) {
+    return to_string(std::forward<T>(value));
+}
+
+/// special template overload
+template <typename T1,
+          typename T2,
+          typename T,
+          enable_if_t<!std::is_same<T1, T2>::value, detail::enabler> = detail::dummy>
+std::string checked_to_string(T &&) {
+    return std::string{};
+}
+/// get a string as a convertible value for arithmetic types
+template <typename T, enable_if_t<std::is_arithmetic<T>::value, detail::enabler> = detail::dummy>
+std::string value_string(const T &value) {
+    return std::to_string(value);
+}
+/// get a string as a convertible value for enumerations
+template <typename T, enable_if_t<std::is_enum<T>::value, detail::enabler> = detail::dummy>
+std::string value_string(const T &value) {
+    return std::to_string(static_cast<typename std::underlying_type<T>::type>(value));
+}
+/// for other types just use the regular to_string function
+template <typename T,
+          enable_if_t<!std::is_enum<T>::value && !std::is_arithmetic<T>::value, detail::enabler> = detail::dummy>
+auto value_string(const T &value) -> decltype(to_string(value)) {
+    return to_string(value);
+}
+
+/// template to get the underlying value type if it exists or use a default
+template <typename T, typename def, typename Enable = void> struct wrapped_type { using type = def; };
+
+/// Type size for regular object types that do not look like a tuple
+template <typename T, typename def> struct wrapped_type<T, def, typename std::enable_if<is_wrapper<T>::value>::type> {
+    using type = typename T::value_type;
+};
+
+/// This will only trigger for actual void type
+template <typename T, typename Enable = void> struct type_count_base { static const int value{0}; };
+
+/// Type size for regular object types that do not look like a tuple
+template <typename T>
+struct type_count_base<T,
+                       typename std::enable_if<!is_tuple_like<T>::value && !is_mutable_container<T>::value &&
+                                               !std::is_void<T>::value>::type> {
+    static constexpr int value{1};
+};
+
+/// the base tuple size
+template <typename T>
+struct type_count_base<T, typename std::enable_if<is_tuple_like<T>::value && !is_mutable_container<T>::value>::type> {
+    static constexpr int value{std::tuple_size<T>::value};
+};
+
+/// Type count base for containers is the type_count_base of the individual element
+template <typename T> struct type_count_base<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr int value{type_count_base<typename T::value_type>::value};
+};
+
+/// Set of overloads to get the type size of an object
+
+/// forward declare the subtype_count structure
+template <typename T> struct subtype_count;
+
+/// forward declare the subtype_count_min structure
+template <typename T> struct subtype_count_min;
+
+/// This will only trigger for actual void type
+template <typename T, typename Enable = void> struct type_count { static const int value{0}; };
+
+/// Type size for regular object types that do not look like a tuple
+template <typename T>
+struct type_count<T,
+                  typename std::enable_if<!is_wrapper<T>::value && !is_tuple_like<T>::value && !is_complex<T>::value &&
+                                          !std::is_void<T>::value>::type> {
+    static constexpr int value{1};
+};
+
+/// Type size for complex since it sometimes looks like a wrapper
+template <typename T> struct type_count<T, typename std::enable_if<is_complex<T>::value>::type> {
+    static constexpr int value{2};
+};
+
+/// Type size of types that are wrappers,except complex and tuples(which can also be wrappers sometimes)
+template <typename T> struct type_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr int value{subtype_count<typename T::value_type>::value};
+};
+
+/// Type size of types that are wrappers,except containers complex and tuples(which can also be wrappers sometimes)
+template <typename T>
+struct type_count<T,
+                  typename std::enable_if<is_wrapper<T>::value && !is_complex<T>::value && !is_tuple_like<T>::value &&
+                                          !is_mutable_container<T>::value>::type> {
+    static constexpr int value{type_count<typename T::value_type>::value};
+};
+
+/// 0 if the index > tuple size
+template <typename T, std::size_t I>
+constexpr typename std::enable_if<I == type_count_base<T>::value, int>::type tuple_type_size() {
+    return 0;
+}
+
+/// Recursively generate the tuple type name
+template <typename T, std::size_t I>
+    constexpr typename std::enable_if < I<type_count_base<T>::value, int>::type tuple_type_size() {
+    return subtype_count<typename std::tuple_element<I, T>::type>::value + tuple_type_size<T, I + 1>();
+}
+
+/// Get the type size of the sum of type sizes for all the individual tuple types
+template <typename T> struct type_count<T, typename std::enable_if<is_tuple_like<T>::value>::type> {
+    static constexpr int value{tuple_type_size<T, 0>()};
+};
+
+/// definition of subtype count
+template <typename T> struct subtype_count {
+    static constexpr int value{is_mutable_container<T>::value ? expected_max_vector_size : type_count<T>::value};
+};
+
+/// This will only trigger for actual void type
+template <typename T, typename Enable = void> struct type_count_min { static const int value{0}; };
+
+/// Type size for regular object types that do not look like a tuple
+template <typename T>
+struct type_count_min<
+    T,
+    typename std::enable_if<!is_mutable_container<T>::value && !is_tuple_like<T>::value && !is_wrapper<T>::value &&
+                            !is_complex<T>::value && !std::is_void<T>::value>::type> {
+    static constexpr int value{type_count<T>::value};
+};
+
+/// Type size for complex since it sometimes looks like a wrapper
+template <typename T> struct type_count_min<T, typename std::enable_if<is_complex<T>::value>::type> {
+    static constexpr int value{1};
+};
+
+/// Type size min of types that are wrappers,except complex and tuples(which can also be wrappers sometimes)
+template <typename T>
+struct type_count_min<
+    T,
+    typename std::enable_if<is_wrapper<T>::value && !is_complex<T>::value && !is_tuple_like<T>::value>::type> {
+    static constexpr int value{subtype_count_min<typename T::value_type>::value};
+};
+
+/// 0 if the index > tuple size
+template <typename T, std::size_t I>
+constexpr typename std::enable_if<I == type_count_base<T>::value, int>::type tuple_type_size_min() {
+    return 0;
+}
+
+/// Recursively generate the tuple type name
+template <typename T, std::size_t I>
+    constexpr typename std::enable_if < I<type_count_base<T>::value, int>::type tuple_type_size_min() {
+    return subtype_count_min<typename std::tuple_element<I, T>::type>::value + tuple_type_size_min<T, I + 1>();
+}
+
+/// Get the type size of the sum of type sizes for all the individual tuple types
+template <typename T> struct type_count_min<T, typename std::enable_if<is_tuple_like<T>::value>::type> {
+    static constexpr int value{tuple_type_size_min<T, 0>()};
+};
+
+/// definition of subtype count
+template <typename T> struct subtype_count_min {
+    static constexpr int value{is_mutable_container<T>::value
+                                   ? ((type_count<T>::value < expected_max_vector_size) ? type_count<T>::value : 0)
+                                   : type_count_min<T>::value};
+};
+
+/// This will only trigger for actual void type
+template <typename T, typename Enable = void> struct expected_count { static const int value{0}; };
+
+/// For most types the number of expected items is 1
+template <typename T>
+struct expected_count<T,
+                      typename std::enable_if<!is_mutable_container<T>::value && !is_wrapper<T>::value &&
+                                              !std::is_void<T>::value>::type> {
+    static constexpr int value{1};
+};
+/// number of expected items in a vector
+template <typename T> struct expected_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr int value{expected_max_vector_size};
+};
+
+/// number of expected items in a vector
+template <typename T>
+struct expected_count<T, typename std::enable_if<!is_mutable_container<T>::value && is_wrapper<T>::value>::type> {
+    static constexpr int value{expected_count<typename T::value_type>::value};
+};
+
+// Enumeration of the different supported categorizations of objects
+enum class object_category : int {
+    char_value = 1,
+    integral_value = 2,
+    unsigned_integral = 4,
+    enumeration = 6,
+    boolean_value = 8,
+    floating_point = 10,
+    number_constructible = 12,
+    double_constructible = 14,
+    integer_constructible = 16,
+    // string like types
+    string_assignable = 23,
+    string_constructible = 24,
+    other = 45,
+    // special wrapper or container types
+    wrapper_value = 50,
+    complex_number = 60,
+    tuple_value = 70,
+    container_value = 80,
+
+};
+
+/// Set of overloads to classify an object according to type
+
+/// some type that is not otherwise recognized
+template <typename T, typename Enable = void> struct classify_object {
+    static constexpr object_category value{object_category::other};
+};
+
+/// Signed integers
+template <typename T>
+struct classify_object<
+    T,
+    typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, char>::value && std::is_signed<T>::value &&
+                            !is_bool<T>::value && !std::is_enum<T>::value>::type> {
+    static constexpr object_category value{object_category::integral_value};
+};
+
+/// Unsigned integers
+template <typename T>
+struct classify_object<T,
+                       typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value &&
+                                               !std::is_same<T, char>::value && !is_bool<T>::value>::type> {
+    static constexpr object_category value{object_category::unsigned_integral};
+};
+
+/// single character values
+template <typename T>
+struct classify_object<T, typename std::enable_if<std::is_same<T, char>::value && !std::is_enum<T>::value>::type> {
+    static constexpr object_category value{object_category::char_value};
+};
+
+/// Boolean values
+template <typename T> struct classify_object<T, typename std::enable_if<is_bool<T>::value>::type> {
+    static constexpr object_category value{object_category::boolean_value};
+};
+
+/// Floats
+template <typename T> struct classify_object<T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
+    static constexpr object_category value{object_category::floating_point};
+};
+
+/// String and similar direct assignment
+template <typename T>
+struct classify_object<T,
+                       typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
+                                               std::is_assignable<T &, std::string>::value>::type> {
+    static constexpr object_category value{object_category::string_assignable};
+};
+
+/// String and similar constructible and copy assignment
+template <typename T>
+struct classify_object<
+    T,
+    typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
+                            !std::is_assignable<T &, std::string>::value && (type_count<T>::value == 1) &&
+                            std::is_constructible<T, std::string>::value>::type> {
+    static constexpr object_category value{object_category::string_constructible};
+};
+
+/// Enumerations
+template <typename T> struct classify_object<T, typename std::enable_if<std::is_enum<T>::value>::type> {
+    static constexpr object_category value{object_category::enumeration};
+};
+
+template <typename T> struct classify_object<T, typename std::enable_if<is_complex<T>::value>::type> {
+    static constexpr object_category value{object_category::complex_number};
+};
+
+/// Handy helper to contain a bunch of checks that rule out many common types (integers, string like, floating point,
+/// vectors, and enumerations
+template <typename T> struct uncommon_type {
+    using type = typename std::conditional<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
+                                               !std::is_assignable<T &, std::string>::value &&
+                                               !std::is_constructible<T, std::string>::value && !is_complex<T>::value &&
+                                               !is_mutable_container<T>::value && !std::is_enum<T>::value,
+                                           std::true_type,
+                                           std::false_type>::type;
+    static constexpr bool value = type::value;
+};
+
+/// wrapper type
+template <typename T>
+struct classify_object<T,
+                       typename std::enable_if<(!is_mutable_container<T>::value && is_wrapper<T>::value &&
+                                                !is_tuple_like<T>::value && uncommon_type<T>::value)>::type> {
+    static constexpr object_category value{object_category::wrapper_value};
+};
+
+/// Assignable from double or int
+template <typename T>
+struct classify_object<T,
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
+                                               !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
+                                               is_direct_constructible<T, int>::value>::type> {
+    static constexpr object_category value{object_category::number_constructible};
+};
+
+/// Assignable from int
+template <typename T>
+struct classify_object<T,
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
+                                               !is_wrapper<T>::value && !is_direct_constructible<T, double>::value &&
+                                               is_direct_constructible<T, int>::value>::type> {
+    static constexpr object_category value{object_category::integer_constructible};
+};
+
+/// Assignable from double
+template <typename T>
+struct classify_object<T,
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
+                                               !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
+                                               !is_direct_constructible<T, int>::value>::type> {
+    static constexpr object_category value{object_category::double_constructible};
+};
+
+/// Tuple type
+template <typename T>
+struct classify_object<
+    T,
+    typename std::enable_if<is_tuple_like<T>::value &&
+                            ((type_count<T>::value >= 2 && !is_wrapper<T>::value) ||
+                             (uncommon_type<T>::value && !is_direct_constructible<T, double>::value &&
+                              !is_direct_constructible<T, int>::value))>::type> {
+    static constexpr object_category value{object_category::tuple_value};
+    // the condition on this class requires it be like a tuple, but on some compilers (like Xcode) tuples can be
+    // constructed from just the first element so tuples of <string, int,int> can be constructed from a string, which
+    // could lead to issues so there are two variants of the condition, the first isolates things with a type size >=2
+    // mainly to get tuples on Xcode with the exception of wrappers, the second is the main one and just separating out
+    // those cases that are caught by other object classifications
+};
+
+/// container type
+template <typename T> struct classify_object<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr object_category value{object_category::container_value};
+};
+
+// Type name print
+
+/// Was going to be based on
+///  http://stackoverflow.com/questions/1055452/c-get-name-of-type-in-template
+/// But this is cleaner and works better in this case
+
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::char_value, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "CHAR";
+}
+
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::integral_value ||
+                          classify_object<T>::value == object_category::integer_constructible,
+                      detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "INT";
+}
+
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::unsigned_integral, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "UINT";
+}
+
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::floating_point ||
+                          classify_object<T>::value == object_category::number_constructible ||
+                          classify_object<T>::value == object_category::double_constructible,
+                      detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "FLOAT";
+}
+
+/// Print name for enumeration types
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::enumeration, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "ENUM";
+}
+
+/// Print name for enumeration types
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::boolean_value, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "BOOLEAN";
+}
+
+/// Print name for enumeration types
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::complex_number, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "COMPLEX";
+}
+
+/// Print for all other types
+template <typename T,
+          enable_if_t<classify_object<T>::value >= object_category::string_assignable &&
+                          classify_object<T>::value <= object_category::other,
+                      detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "TEXT";
+}
+/// typename for tuple value
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count_base<T>::value >= 2,
+                      detail::enabler> = detail::dummy>
+std::string type_name();  // forward declaration
+
+/// Generate type name for a wrapper or container value
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::container_value ||
+                          classify_object<T>::value == object_category::wrapper_value,
+                      detail::enabler> = detail::dummy>
+std::string type_name();  // forward declaration
+
+/// Print name for single element tuple types
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count_base<T>::value == 1,
+                      detail::enabler> = detail::dummy>
+inline std::string type_name() {
+    return type_name<typename std::decay<typename std::tuple_element<0, T>::type>::type>();
+}
+
+/// Empty string if the index > tuple size
+template <typename T, std::size_t I>
+inline typename std::enable_if<I == type_count_base<T>::value, std::string>::type tuple_name() {
+    return std::string{};
+}
+
+/// Recursively generate the tuple type name
+template <typename T, std::size_t I>
+inline typename std::enable_if<(I < type_count_base<T>::value), std::string>::type tuple_name() {
+    std::string str = std::string(type_name<typename std::decay<typename std::tuple_element<I, T>::type>::type>()) +
+                      ',' + tuple_name<T, I + 1>();
+    if(str.back() == ',')
+        str.pop_back();
+    return str;
+}
+
+/// Print type name for tuples with 2 or more elements
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count_base<T>::value >= 2,
+                      detail::enabler>>
+inline std::string type_name() {
+    auto tname = std::string(1, '[') + tuple_name<T, 0>();
+    tname.push_back(']');
+    return tname;
+}
+
+/// get the type name for a type that has a value_type member
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::container_value ||
+                          classify_object<T>::value == object_category::wrapper_value,
+                      detail::enabler>>
+inline std::string type_name() {
+    return type_name<typename T::value_type>();
+}
+
+// Lexical cast
+
+/// Convert to an unsigned integral
+template <typename T, enable_if_t<std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+bool integral_conversion(const std::string &input, T &output) noexcept {
+    if(input.empty()) {
+        return false;
+    }
+    char *val = nullptr;
+    std::uint64_t output_ll = std::strtoull(input.c_str(), &val, 0);
+    output = static_cast<T>(output_ll);
+    return val == (input.c_str() + input.size()) && static_cast<std::uint64_t>(output) == output_ll;
+}
+
+/// Convert to a signed integral
+template <typename T, enable_if_t<std::is_signed<T>::value, detail::enabler> = detail::dummy>
+bool integral_conversion(const std::string &input, T &output) noexcept {
+    if(input.empty()) {
+        return false;
+    }
+    char *val = nullptr;
+    std::int64_t output_ll = std::strtoll(input.c_str(), &val, 0);
+    output = static_cast<T>(output_ll);
+    return val == (input.c_str() + input.size()) && static_cast<std::int64_t>(output) == output_ll;
+}
+
+/// Convert a flag into an integer value  typically binary flags
+inline std::int64_t to_flag_value(std::string val) {
+    static const std::string trueString("true");
+    static const std::string falseString("false");
+    if(val == trueString) {
+        return 1;
+    }
+    if(val == falseString) {
+        return -1;
+    }
+    val = detail::to_lower(val);
+    std::int64_t ret;
+    if(val.size() == 1) {
+        if(val[0] >= '1' && val[0] <= '9') {
+            return (static_cast<std::int64_t>(val[0]) - '0');
+        }
+        switch(val[0]) {
+        case '0':
+        case 'f':
+        case 'n':
+        case '-':
+            ret = -1;
+            break;
+        case 't':
+        case 'y':
+        case '+':
+            ret = 1;
+            break;
+        default:
+            throw std::invalid_argument("unrecognized character");
+        }
+        return ret;
+    }
+    if(val == trueString || val == "on" || val == "yes" || val == "enable") {
+        ret = 1;
+    } else if(val == falseString || val == "off" || val == "no" || val == "disable") {
+        ret = -1;
+    } else {
+        ret = std::stoll(val);
+    }
+    return ret;
+}
+
+/// Integer conversion
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::integral_value ||
+                          classify_object<T>::value == object_category::unsigned_integral,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    return integral_conversion(input, output);
+}
+
+/// char values
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::char_value, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    if(input.size() == 1) {
+        output = static_cast<T>(input[0]);
+        return true;
+    }
+    return integral_conversion(input, output);
+}
+
+/// Boolean values
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::boolean_value, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    try {
+        auto out = to_flag_value(input);
+        output = (out > 0);
+        return true;
+    } catch(const std::invalid_argument &) {
+        return false;
+    } catch(const std::out_of_range &) {
+        // if the number is out of the range of a 64 bit value then it is still a number and for this purpose is still
+        // valid all we care about the sign
+        output = (input[0] != '-');
+        return true;
+    }
+}
+
+/// Floats
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::floating_point, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    if(input.empty()) {
+        return false;
+    }
+    char *val = nullptr;
+    auto output_ld = std::strtold(input.c_str(), &val);
+    output = static_cast<T>(output_ld);
+    return val == (input.c_str() + input.size());
+}
+
+/// complex
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::complex_number, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    using XC = typename wrapped_type<T, double>::type;
+    XC x{0.0}, y{0.0};
+    auto str1 = input;
+    bool worked = false;
+    auto nloc = str1.find_last_of("+-");
+    if(nloc != std::string::npos && nloc > 0) {
+        worked = detail::lexical_cast(str1.substr(0, nloc), x);
+        str1 = str1.substr(nloc);
+        if(str1.back() == 'i' || str1.back() == 'j')
+            str1.pop_back();
+        worked = worked && detail::lexical_cast(str1, y);
+    } else {
+        if(str1.back() == 'i' || str1.back() == 'j') {
+            str1.pop_back();
+            worked = detail::lexical_cast(str1, y);
+            x = XC{0};
+        } else {
+            worked = detail::lexical_cast(str1, x);
+            y = XC{0};
+        }
+    }
+    if(worked) {
+        output = T{x, y};
+        return worked;
+    }
+    return from_stream(input, output);
+}
+
+/// String and similar direct assignment
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::string_assignable, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    output = input;
+    return true;
+}
+
+/// String and similar constructible and copy assignment
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::string_constructible, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    output = T(input);
+    return true;
+}
+
+/// Enumerations
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::enumeration, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    typename std::underlying_type<T>::type val;
+    if(!integral_conversion(input, val)) {
+        return false;
+    }
+    output = static_cast<T>(val);
+    return true;
+}
+
+/// wrapper types
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::wrapper_value &&
+                          std::is_assignable<T &, typename T::value_type>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    typename T::value_type val;
+    if(lexical_cast(input, val)) {
+        output = val;
+        return true;
+    }
+    return from_stream(input, output);
+}
+
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::wrapper_value &&
+                          !std::is_assignable<T &, typename T::value_type>::value && std::is_assignable<T &, T>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    typename T::value_type val;
+    if(lexical_cast(input, val)) {
+        output = T{val};
+        return true;
+    }
+    return from_stream(input, output);
+}
+
+/// Assignable from double or int
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::number_constructible, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    int val;
+    if(integral_conversion(input, val)) {
+        output = T(val);
+        return true;
+    } else {
+        double dval;
+        if(lexical_cast(input, dval)) {
+            output = T{dval};
+            return true;
+        }
+    }
+    return from_stream(input, output);
+}
+
+/// Assignable from int
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::integer_constructible, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    int val;
+    if(integral_conversion(input, val)) {
+        output = T(val);
+        return true;
+    }
+    return from_stream(input, output);
+}
+
+/// Assignable from double
+template <
+    typename T,
+    enable_if_t<classify_object<T>::value == object_category::double_constructible, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    double val;
+    if(lexical_cast(input, val)) {
+        output = T{val};
+        return true;
+    }
+    return from_stream(input, output);
+}
+
+/// Non-string convertible from an int
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::other && std::is_assignable<T &, int>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    int val;
+    if(integral_conversion(input, val)) {
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4800)
+#endif
+        // with Atomic<XX> this could produce a warning due to the conversion but if atomic gets here it is an old style
+        // so will most likely still work
+        output = val;
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+        return true;
+    }
+    // LCOV_EXCL_START
+    // This version of cast is only used for odd cases in an older compilers the fail over
+    // from_stream is tested elsewhere an not relevant for coverage here
+    return from_stream(input, output);
+    // LCOV_EXCL_STOP
+}
+
+/// Non-string parsable by a stream
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::other && !std::is_assignable<T &, int>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    static_assert(is_istreamable<T>::value,
+                  "option object type must have a lexical cast overload or streaming input operator(>>) defined, if it "
+                  "is convertible from another type use the add_option<T, XC>(...) with XC being the known type");
+    return from_stream(input, output);
+}
+
+/// Assign a value through lexical cast operations
+/// Strings can be empty so we need to do a little different
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<std::is_same<AssignTo, ConvertTo>::value &&
+                          (classify_object<AssignTo>::value == object_category::string_assignable ||
+                           classify_object<AssignTo>::value == object_category::string_constructible),
+                      detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    return lexical_cast(input, output);
+}
+
+/// Assign a value through lexical cast operations
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<std::is_same<AssignTo, ConvertTo>::value && std::is_assignable<AssignTo &, AssignTo>::value &&
+                          classify_object<AssignTo>::value != object_category::string_assignable &&
+                          classify_object<AssignTo>::value != object_category::string_constructible,
+                      detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    if(input.empty()) {
+        output = AssignTo{};
+        return true;
+    }
+
+    return lexical_cast(input, output);
+}
+
+/// Assign a value through lexical cast operations
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<std::is_same<AssignTo, ConvertTo>::value && !std::is_assignable<AssignTo &, AssignTo>::value &&
+                          classify_object<AssignTo>::value == object_category::wrapper_value,
+                      detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    if(input.empty()) {
+        typename AssignTo::value_type emptyVal{};
+        output = emptyVal;
+        return true;
+    }
+    return lexical_cast(input, output);
+}
+
+/// Assign a value through lexical cast operations for int compatible values
+/// mainly for atomic operations on some compilers
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<std::is_same<AssignTo, ConvertTo>::value && !std::is_assignable<AssignTo &, AssignTo>::value &&
+                          classify_object<AssignTo>::value != object_category::wrapper_value &&
+                          std::is_assignable<AssignTo &, int>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    if(input.empty()) {
+        output = 0;
+        return true;
+    }
+    int val;
+    if(lexical_cast(input, val)) {
+        output = val;
+        return true;
+    }
+    return false;
+}
+
+/// Assign a value converted from a string in lexical cast to the output value directly
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<!std::is_same<AssignTo, ConvertTo>::value && std::is_assignable<AssignTo &, ConvertTo &>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    ConvertTo val{};
+    bool parse_result = (!input.empty()) ? lexical_cast<ConvertTo>(input, val) : true;
+    if(parse_result) {
+        output = val;
+    }
+    return parse_result;
+}
+
+/// Assign a value from a lexical cast through constructing a value and move assigning it
+template <
+    typename AssignTo,
+    typename ConvertTo,
+    enable_if_t<!std::is_same<AssignTo, ConvertTo>::value && !std::is_assignable<AssignTo &, ConvertTo &>::value &&
+                    std::is_move_assignable<AssignTo>::value,
+                detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    ConvertTo val{};
+    bool parse_result = input.empty() ? true : lexical_cast<ConvertTo>(input, val);
+    if(parse_result) {
+        output = AssignTo(val);  // use () form of constructor to allow some implicit conversions
+    }
+    return parse_result;
+}
+
+/// primary lexical conversion operation, 1 string to 1 type of some kind
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<classify_object<ConvertTo>::value <= object_category::other &&
+                          classify_object<AssignTo>::value <= object_category::wrapper_value,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    return lexical_assign<AssignTo, ConvertTo>(strings[0], output);
+}
+
+/// Lexical conversion if there is only one element but the conversion type is for two, then call a two element
+/// constructor
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<(type_count<AssignTo>::value <= 2) && expected_count<AssignTo>::value == 1 &&
+                          is_tuple_like<ConvertTo>::value && type_count_base<ConvertTo>::value == 2,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    // the remove const is to handle pair types coming from a container
+    typename std::remove_const<typename std::tuple_element<0, ConvertTo>::type>::type v1;
+    typename std::tuple_element<1, ConvertTo>::type v2;
+    bool retval = lexical_assign<decltype(v1), decltype(v1)>(strings[0], v1);
+    if(strings.size() > 1) {
+        retval = retval && lexical_assign<decltype(v2), decltype(v2)>(strings[1], v2);
+    }
+    if(retval) {
+        output = AssignTo{v1, v2};
+    }
+    return retval;
+}
+
+/// Lexical conversion of a container types of single elements
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count<ConvertTo>::value == 1,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    output.erase(output.begin(), output.end());
+    for(const auto &elem : strings) {
+        typename AssignTo::value_type out;
+        bool retval = lexical_assign<typename AssignTo::value_type, typename ConvertTo::value_type>(elem, out);
+        if(!retval) {
+            return false;
+        }
+        output.insert(output.end(), std::move(out));
+    }
+    return (!output.empty());
+}
+
+/// Lexical conversion for complex types
+template <class AssignTo, class ConvertTo, enable_if_t<is_complex<ConvertTo>::value, detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output) {
+
+    if(strings.size() >= 2 && !strings[1].empty()) {
+        using XC2 = typename wrapped_type<ConvertTo, double>::type;
+        XC2 x{0.0}, y{0.0};
+        auto str1 = strings[1];
+        if(str1.back() == 'i' || str1.back() == 'j') {
+            str1.pop_back();
+        }
+        auto worked = detail::lexical_cast(strings[0], x) && detail::lexical_cast(str1, y);
+        if(worked) {
+            output = ConvertTo{x, y};
+        }
+        return worked;
+    } else {
+        return lexical_assign<AssignTo, ConvertTo>(strings[0], output);
+    }
+}
+
+/// Conversion to a vector type using a particular single type as the conversion type
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && (expected_count<ConvertTo>::value == 1) &&
+                          (type_count<ConvertTo>::value == 1),
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    bool retval = true;
+    output.clear();
+    output.reserve(strings.size());
+    for(const auto &elem : strings) {
+
+        output.emplace_back();
+        retval = retval && lexical_assign<typename AssignTo::value_type, ConvertTo>(elem, output.back());
+    }
+    return (!output.empty()) && retval;
+}
+
+// forward declaration
+
+/// Lexical conversion of a container types with conversion type of two elements
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value == 2,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(std::vector<std::string> strings, AssignTo &output);
+
+/// Lexical conversion of a vector types with type_size >2 forward declaration
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value != 2 &&
+                          ((type_count<ConvertTo>::value > 2) ||
+                           (type_count<ConvertTo>::value > type_count_base<ConvertTo>::value)),
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output);
+
+/// Conversion for tuples
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_tuple_like<AssignTo>::value && is_tuple_like<ConvertTo>::value &&
+                          (type_count_base<ConvertTo>::value != type_count<ConvertTo>::value ||
+                           type_count<ConvertTo>::value > 2),
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output);  // forward declaration
+
+/// Conversion for operations where the assigned type is some class but the conversion is a mutable container or large
+/// tuple
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<!is_tuple_like<AssignTo>::value && !is_mutable_container<AssignTo>::value &&
+                          classify_object<ConvertTo>::value != object_category::wrapper_value &&
+                          (is_mutable_container<ConvertTo>::value || type_count<ConvertTo>::value > 2),
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+
+    if(strings.size() > 1 || (!strings.empty() && !(strings.front().empty()))) {
+        ConvertTo val;
+        auto retval = lexical_conversion<ConvertTo, ConvertTo>(strings, val);
+        output = AssignTo{val};
+        return retval;
+    }
+    output = AssignTo{};
+    return true;
+}
+
+/// function template for converting tuples if the static Index is greater than the tuple size
+template <class AssignTo, class ConvertTo, std::size_t I>
+inline typename std::enable_if<(I >= type_count_base<AssignTo>::value), bool>::type
+tuple_conversion(const std::vector<std::string> &, AssignTo &) {
+    return true;
+}
+
+/// Conversion of a tuple element where the type size ==1 and not a mutable container
+template <class AssignTo, class ConvertTo>
+inline typename std::enable_if<!is_mutable_container<ConvertTo>::value && type_count<ConvertTo>::value == 1, bool>::type
+tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
+    auto retval = lexical_assign<AssignTo, ConvertTo>(strings[0], output);
+    strings.erase(strings.begin());
+    return retval;
+}
+
+/// Conversion of a tuple element where the type size !=1 but the size is fixed and not a mutable container
+template <class AssignTo, class ConvertTo>
+inline typename std::enable_if<!is_mutable_container<ConvertTo>::value && (type_count<ConvertTo>::value > 1) &&
+                                   type_count<ConvertTo>::value == type_count_min<ConvertTo>::value,
+                               bool>::type
+tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
+    auto retval = lexical_conversion<AssignTo, ConvertTo>(strings, output);
+    strings.erase(strings.begin(), strings.begin() + type_count<ConvertTo>::value);
+    return retval;
+}
+
+/// Conversion of a tuple element where the type is a mutable container or a type with different min and max type sizes
+template <class AssignTo, class ConvertTo>
+inline typename std::enable_if<is_mutable_container<ConvertTo>::value ||
+                                   type_count<ConvertTo>::value != type_count_min<ConvertTo>::value,
+                               bool>::type
+tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
+
+    std::size_t index{subtype_count_min<ConvertTo>::value};
+    const std::size_t mx_count{subtype_count<ConvertTo>::value};
+    const std::size_t mx{(std::max)(mx_count, strings.size())};
+
+    while(index < mx) {
+        if(is_separator(strings[index])) {
+            break;
+        }
+        ++index;
+    }
+    bool retval = lexical_conversion<AssignTo, ConvertTo>(
+        std::vector<std::string>(strings.begin(), strings.begin() + static_cast<std::ptrdiff_t>(index)), output);
+    strings.erase(strings.begin(), strings.begin() + static_cast<std::ptrdiff_t>(index) + 1);
+    return retval;
+}
+
+/// Tuple conversion operation
+template <class AssignTo, class ConvertTo, std::size_t I>
+inline typename std::enable_if<(I < type_count_base<AssignTo>::value), bool>::type
+tuple_conversion(std::vector<std::string> strings, AssignTo &output) {
+    bool retval = true;
+    using ConvertToElement = typename std::
+        conditional<is_tuple_like<ConvertTo>::value, typename std::tuple_element<I, ConvertTo>::type, ConvertTo>::type;
+    if(!strings.empty()) {
+        retval = retval && tuple_type_conversion<typename std::tuple_element<I, AssignTo>::type, ConvertToElement>(
+                               strings, std::get<I>(output));
+    }
+    retval = retval && tuple_conversion<AssignTo, ConvertTo, I + 1>(std::move(strings), output);
+    return retval;
+}
+
+/// Lexical conversion of a container types with tuple elements of size 2
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value == 2,
+                      detail::enabler>>
+bool lexical_conversion(std::vector<std::string> strings, AssignTo &output) {
+    output.clear();
+    while(!strings.empty()) {
+
+        typename std::remove_const<typename std::tuple_element<0, typename ConvertTo::value_type>::type>::type v1;
+        typename std::tuple_element<1, typename ConvertTo::value_type>::type v2;
+        bool retval = tuple_type_conversion<decltype(v1), decltype(v1)>(strings, v1);
+        if(!strings.empty()) {
+            retval = retval && tuple_type_conversion<decltype(v2), decltype(v2)>(strings, v2);
+        }
+        if(retval) {
+            output.insert(output.end(), typename AssignTo::value_type{v1, v2});
+        } else {
+            return false;
+        }
+    }
+    return (!output.empty());
+}
+
+/// lexical conversion of tuples with type count>2 or tuples of types of some element with a type size>=2
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_tuple_like<AssignTo>::value && is_tuple_like<ConvertTo>::value &&
+                          (type_count_base<ConvertTo>::value != type_count<ConvertTo>::value ||
+                           type_count<ConvertTo>::value > 2),
+                      detail::enabler>>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    static_assert(
+        !is_tuple_like<ConvertTo>::value || type_count_base<AssignTo>::value == type_count_base<ConvertTo>::value,
+        "if the conversion type is defined as a tuple it must be the same size as the type you are converting to");
+    return tuple_conversion<AssignTo, ConvertTo, 0>(strings, output);
+}
+
+/// Lexical conversion of a vector types for everything but tuples of two elements and types of size 1
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value != 2 &&
+                          ((type_count<ConvertTo>::value > 2) ||
+                           (type_count<ConvertTo>::value > type_count_base<ConvertTo>::value)),
+                      detail::enabler>>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    bool retval = true;
+    output.clear();
+    std::vector<std::string> temp;
+    std::size_t ii{0};
+    std::size_t icount{0};
+    std::size_t xcm{type_count<ConvertTo>::value};
+    auto ii_max = strings.size();
+    while(ii < ii_max) {
+        temp.push_back(strings[ii]);
+        ++ii;
+        ++icount;
+        if(icount == xcm || is_separator(temp.back()) || ii == ii_max) {
+            if(static_cast<int>(xcm) > type_count_min<ConvertTo>::value && is_separator(temp.back())) {
+                temp.pop_back();
+            }
+            typename AssignTo::value_type temp_out;
+            retval = retval &&
+                     lexical_conversion<typename AssignTo::value_type, typename ConvertTo::value_type>(temp, temp_out);
+            temp.clear();
+            if(!retval) {
+                return false;
+            }
+            output.insert(output.end(), std::move(temp_out));
+            icount = 0;
+        }
+    }
+    return retval;
+}
+
+/// conversion for wrapper types
+template <typename AssignTo,
+          class ConvertTo,
+          enable_if_t<classify_object<ConvertTo>::value == object_category::wrapper_value &&
+                          std::is_assignable<ConvertTo &, ConvertTo>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output) {
+    if(strings.empty() || strings.front().empty()) {
+        output = ConvertTo{};
+        return true;
+    }
+    typename ConvertTo::value_type val;
+    if(lexical_conversion<typename ConvertTo::value_type, typename ConvertTo::value_type>(strings, val)) {
+        output = ConvertTo{val};
+        return true;
+    }
+    return false;
+}
+
+/// conversion for wrapper types
+template <typename AssignTo,
+          class ConvertTo,
+          enable_if_t<classify_object<ConvertTo>::value == object_category::wrapper_value &&
+                          !std::is_assignable<AssignTo &, ConvertTo>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output) {
+    using ConvertType = typename ConvertTo::value_type;
+    if(strings.empty() || strings.front().empty()) {
+        output = ConvertType{};
+        return true;
+    }
+    ConvertType val;
+    if(lexical_conversion<typename ConvertTo::value_type, typename ConvertTo::value_type>(strings, val)) {
+        output = val;
+        return true;
+    }
+    return false;
+}
+
+/// Sum a vector of flag representations
+/// The flag vector produces a series of strings in a vector,  simple true is represented by a "1",  simple false is
+/// by
+/// "-1" an if numbers are passed by some fashion they are captured as well so the function just checks for the most
+/// common true and false strings then uses stoll to convert the rest for summing
+template <typename T, enable_if_t<std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
+    std::int64_t count{0};
+    for(auto &flag : flags) {
+        count += detail::to_flag_value(flag);
+    }
+    output = (count > 0) ? static_cast<T>(count) : T{0};
+}
+
+/// Sum a vector of flag representations
+/// The flag vector produces a series of strings in a vector,  simple true is represented by a "1",  simple false is
+/// by
+/// "-1" an if numbers are passed by some fashion they are captured as well so the function just checks for the most
+/// common true and false strings then uses stoll to convert the rest for summing
+template <typename T, enable_if_t<std::is_signed<T>::value, detail::enabler> = detail::dummy>
+void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
+    std::int64_t count{0};
+    for(auto &flag : flags) {
+        count += detail::to_flag_value(flag);
+    }
+    output = static_cast<T>(count);
+}
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4800)
+#endif
+// with Atomic<XX> this could produce a warning due to the conversion but if atomic gets here it is an old style so will
+// most likely still work
+
+/// Sum a vector of flag representations
+/// The flag vector produces a series of strings in a vector,  simple true is represented by a "1",  simple false is
+/// by
+/// "-1" an if numbers are passed by some fashion they are captured as well so the function just checks for the most
+/// common true and false strings then uses stoll to convert the rest for summing
+template <typename T,
+          enable_if_t<!std::is_signed<T>::value && !std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
+    std::int64_t count{0};
+    for(auto &flag : flags) {
+        count += detail::to_flag_value(flag);
+    }
+    std::string out = detail::to_string(count);
+    lexical_cast(out, output);
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+}  // namespace detail
+// [CLI11:type_tools_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/Validators.hpp b/src/phasicFlow/commandLine/CLI/Validators.hpp
new file mode 100644
index 00000000..03eb77b6
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Validators.hpp
@@ -0,0 +1,1142 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+#include "Macros.hpp"
+#include "StringTools.hpp"
+#include "TypeTools.hpp"
+
+// [CLI11:public_includes:set]
+#include <cmath>
+#include <cstdint>
+#include <functional>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+// [CLI11:public_includes:end]
+
+// [CLI11:validators_hpp_filesystem:verbatim]
+
+// C standard library
+// Only needed for existence checking
+#if defined CLI11_CPP17 && defined __has_include && !defined CLI11_HAS_FILESYSTEM
+#if __has_include(<filesystem>)
+// Filesystem cannot be used if targeting macOS < 10.15
+#if defined __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500
+#define CLI11_HAS_FILESYSTEM 0
+#else
+#include <filesystem>
+#if defined __cpp_lib_filesystem && __cpp_lib_filesystem >= 201703
+#if defined _GLIBCXX_RELEASE && _GLIBCXX_RELEASE >= 9
+#define CLI11_HAS_FILESYSTEM 1
+#elif defined(__GLIBCXX__)
+// if we are using gcc and Version <9 default to no filesystem
+#define CLI11_HAS_FILESYSTEM 0
+#else
+#define CLI11_HAS_FILESYSTEM 1
+#endif
+#else
+#define CLI11_HAS_FILESYSTEM 0
+#endif
+#endif
+#endif
+#endif
+
+#if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0
+#include <filesystem>  // NOLINT(build/include)
+#else
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+// [CLI11:validators_hpp_filesystem:end]
+
+namespace CLI {
+// [CLI11:validators_hpp:verbatim]
+
+class Option;
+
+/// @defgroup validator_group Validators
+
+/// @brief Some validators that are provided
+///
+/// These are simple `std::string(const std::string&)` validators that are useful. They return
+/// a string if the validation fails. A custom struct is provided, as well, with the same user
+/// semantics, but with the ability to provide a new type name.
+/// @{
+
+///
+class Validator {
+  protected:
+    /// This is the description function, if empty the description_ will be used
+    std::function<std::string()> desc_function_{[]() { return std::string{}; }};
+
+    /// This is the base function that is to be called.
+    /// Returns a string error message if validation fails.
+    std::function<std::string(std::string &)> func_{[](std::string &) { return std::string{}; }};
+    /// The name for search purposes of the Validator
+    std::string name_{};
+    /// A Validator will only apply to an indexed value (-1 is all elements)
+    int application_index_ = -1;
+    /// Enable for Validator to allow it to be disabled if need be
+    bool active_{true};
+    /// specify that a validator should not modify the input
+    bool non_modifying_{false};
+
+  public:
+    Validator() = default;
+    /// Construct a Validator with just the description string
+    explicit Validator(std::string validator_desc) : desc_function_([validator_desc]() { return validator_desc; }) {}
+    /// Construct Validator from basic information
+    Validator(std::function<std::string(std::string &)> op, std::string validator_desc, std::string validator_name = "")
+        : desc_function_([validator_desc]() { return validator_desc; }), func_(std::move(op)),
+          name_(std::move(validator_name)) {}
+    /// Set the Validator operation function
+    Validator &operation(std::function<std::string(std::string &)> op) {
+        func_ = std::move(op);
+        return *this;
+    }
+    /// This is the required operator for a Validator - provided to help
+    /// users (CLI11 uses the member `func` directly)
+    std::string operator()(std::string &str) const {
+        std::string retstring;
+        if(active_) {
+            if(non_modifying_) {
+                std::string value = str;
+                retstring = func_(value);
+            } else {
+                retstring = func_(str);
+            }
+        }
+        return retstring;
+    }
+
+    /// This is the required operator for a Validator - provided to help
+    /// users (CLI11 uses the member `func` directly)
+    std::string operator()(const std::string &str) const {
+        std::string value = str;
+        return (active_) ? func_(value) : std::string{};
+    }
+
+    /// Specify the type string
+    Validator &description(std::string validator_desc) {
+        desc_function_ = [validator_desc]() { return validator_desc; };
+        return *this;
+    }
+    /// Specify the type string
+    Validator description(std::string validator_desc) const {
+        Validator newval(*this);
+        newval.desc_function_ = [validator_desc]() { return validator_desc; };
+        return newval;
+    }
+    /// Generate type description information for the Validator
+    std::string get_description() const {
+        if(active_) {
+            return desc_function_();
+        }
+        return std::string{};
+    }
+    /// Specify the type string
+    Validator &name(std::string validator_name) {
+        name_ = std::move(validator_name);
+        return *this;
+    }
+    /// Specify the type string
+    Validator name(std::string validator_name) const {
+        Validator newval(*this);
+        newval.name_ = std::move(validator_name);
+        return newval;
+    }
+    /// Get the name of the Validator
+    const std::string &get_name() const { return name_; }
+    /// Specify whether the Validator is active or not
+    Validator &active(bool active_val = true) {
+        active_ = active_val;
+        return *this;
+    }
+    /// Specify whether the Validator is active or not
+    Validator active(bool active_val = true) const {
+        Validator newval(*this);
+        newval.active_ = active_val;
+        return newval;
+    }
+
+    /// Specify whether the Validator can be modifying or not
+    Validator &non_modifying(bool no_modify = true) {
+        non_modifying_ = no_modify;
+        return *this;
+    }
+    /// Specify the application index of a validator
+    Validator &application_index(int app_index) {
+        application_index_ = app_index;
+        return *this;
+    }
+    /// Specify the application index of a validator
+    Validator application_index(int app_index) const {
+        Validator newval(*this);
+        newval.application_index_ = app_index;
+        return newval;
+    }
+    /// Get the current value of the application index
+    int get_application_index() const { return application_index_; }
+    /// Get a boolean if the validator is active
+    bool get_active() const { return active_; }
+
+    /// Get a boolean if the validator is allowed to modify the input returns true if it can modify the input
+    bool get_modifying() const { return !non_modifying_; }
+
+    /// Combining validators is a new validator. Type comes from left validator if function, otherwise only set if the
+    /// same.
+    Validator operator&(const Validator &other) const {
+        Validator newval;
+
+        newval._merge_description(*this, other, " AND ");
+
+        // Give references (will make a copy in lambda function)
+        const std::function<std::string(std::string & filename)> &f1 = func_;
+        const std::function<std::string(std::string & filename)> &f2 = other.func_;
+
+        newval.func_ = [f1, f2](std::string &input) {
+            std::string s1 = f1(input);
+            std::string s2 = f2(input);
+            if(!s1.empty() && !s2.empty())
+                return std::string("(") + s1 + ") AND (" + s2 + ")";
+            else
+                return s1 + s2;
+        };
+
+        newval.active_ = (active_ & other.active_);
+        newval.application_index_ = application_index_;
+        return newval;
+    }
+
+    /// Combining validators is a new validator. Type comes from left validator if function, otherwise only set if the
+    /// same.
+    Validator operator|(const Validator &other) const {
+        Validator newval;
+
+        newval._merge_description(*this, other, " OR ");
+
+        // Give references (will make a copy in lambda function)
+        const std::function<std::string(std::string &)> &f1 = func_;
+        const std::function<std::string(std::string &)> &f2 = other.func_;
+
+        newval.func_ = [f1, f2](std::string &input) {
+            std::string s1 = f1(input);
+            std::string s2 = f2(input);
+            if(s1.empty() || s2.empty())
+                return std::string();
+
+            return std::string("(") + s1 + ") OR (" + s2 + ")";
+        };
+        newval.active_ = (active_ & other.active_);
+        newval.application_index_ = application_index_;
+        return newval;
+    }
+
+    /// Create a validator that fails when a given validator succeeds
+    Validator operator!() const {
+        Validator newval;
+        const std::function<std::string()> &dfunc1 = desc_function_;
+        newval.desc_function_ = [dfunc1]() {
+            auto str = dfunc1();
+            return (!str.empty()) ? std::string("NOT ") + str : std::string{};
+        };
+        // Give references (will make a copy in lambda function)
+        const std::function<std::string(std::string & res)> &f1 = func_;
+
+        newval.func_ = [f1, dfunc1](std::string &test) -> std::string {
+            std::string s1 = f1(test);
+            if(s1.empty()) {
+                return std::string("check ") + dfunc1() + " succeeded improperly";
+            }
+            return std::string{};
+        };
+        newval.active_ = active_;
+        newval.application_index_ = application_index_;
+        return newval;
+    }
+
+  private:
+    void _merge_description(const Validator &val1, const Validator &val2, const std::string &merger) {
+
+        const std::function<std::string()> &dfunc1 = val1.desc_function_;
+        const std::function<std::string()> &dfunc2 = val2.desc_function_;
+
+        desc_function_ = [=]() {
+            std::string f1 = dfunc1();
+            std::string f2 = dfunc2();
+            if((f1.empty()) || (f2.empty())) {
+                return f1 + f2;
+            }
+            return std::string(1, '(') + f1 + ')' + merger + '(' + f2 + ')';
+        };
+    }
+};  // namespace CLI
+
+/// Class wrapping some of the accessors of Validator
+class CustomValidator : public Validator {
+  public:
+};
+// The implementation of the built in validators is using the Validator class;
+// the user is only expected to use the const (static) versions (since there's no setup).
+// Therefore, this is in detail.
+namespace detail {
+
+/// CLI enumeration of different file types
+enum class path_type { nonexistent, file, directory };
+
+#if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0
+/// get the type of the path from a file name
+inline path_type check_path(const char *file) noexcept {
+    std::error_code ec;
+    auto stat = std::filesystem::status(file, ec);
+    if(ec) {
+        return path_type::nonexistent;
+    }
+    switch(stat.type()) {
+    case std::filesystem::file_type::none:
+    case std::filesystem::file_type::not_found:
+        return path_type::nonexistent;
+    case std::filesystem::file_type::directory:
+        return path_type::directory;
+    case std::filesystem::file_type::symlink:
+    case std::filesystem::file_type::block:
+    case std::filesystem::file_type::character:
+    case std::filesystem::file_type::fifo:
+    case std::filesystem::file_type::socket:
+    case std::filesystem::file_type::regular:
+    case std::filesystem::file_type::unknown:
+    default:
+        return path_type::file;
+    }
+}
+#else
+/// get the type of the path from a file name
+inline path_type check_path(const char *file) noexcept {
+#if defined(_MSC_VER)
+    struct __stat64 buffer;
+    if(_stat64(file, &buffer) == 0) {
+        return ((buffer.st_mode & S_IFDIR) != 0) ? path_type::directory : path_type::file;
+    }
+#else
+    struct stat buffer;
+    if(stat(file, &buffer) == 0) {
+        return ((buffer.st_mode & S_IFDIR) != 0) ? path_type::directory : path_type::file;
+    }
+#endif
+    return path_type::nonexistent;
+}
+#endif
+/// Check for an existing file (returns error message if check fails)
+class ExistingFileValidator : public Validator {
+  public:
+    ExistingFileValidator() : Validator("FILE") {
+        func_ = [](std::string &filename) {
+            auto path_result = check_path(filename.c_str());
+            if(path_result == path_type::nonexistent) {
+                return "File does not exist: " + filename;
+            }
+            if(path_result == path_type::directory) {
+                return "File is actually a directory: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Check for an existing directory (returns error message if check fails)
+class ExistingDirectoryValidator : public Validator {
+  public:
+    ExistingDirectoryValidator() : Validator("DIR") {
+        func_ = [](std::string &filename) {
+            auto path_result = check_path(filename.c_str());
+            if(path_result == path_type::nonexistent) {
+                return "Directory does not exist: " + filename;
+            }
+            if(path_result == path_type::file) {
+                return "Directory is actually a file: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Check for an existing path
+class ExistingPathValidator : public Validator {
+  public:
+    ExistingPathValidator() : Validator("PATH(existing)") {
+        func_ = [](std::string &filename) {
+            auto path_result = check_path(filename.c_str());
+            if(path_result == path_type::nonexistent) {
+                return "Path does not exist: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Check for an non-existing path
+class NonexistentPathValidator : public Validator {
+  public:
+    NonexistentPathValidator() : Validator("PATH(non-existing)") {
+        func_ = [](std::string &filename) {
+            auto path_result = check_path(filename.c_str());
+            if(path_result != path_type::nonexistent) {
+                return "Path already exists: " + filename;
+            }
+            return std::string();
+        };
+    }
+};
+
+/// Validate the given string is a legal ipv4 address
+class IPV4Validator : public Validator {
+  public:
+    IPV4Validator() : Validator("IPV4") {
+        func_ = [](std::string &ip_addr) {
+            auto result = CLI::detail::split(ip_addr, '.');
+            if(result.size() != 4) {
+                return std::string("Invalid IPV4 address must have four parts (") + ip_addr + ')';
+            }
+            int num;
+            for(const auto &var : result) {
+                bool retval = detail::lexical_cast(var, num);
+                if(!retval) {
+                    return std::string("Failed parsing number (") + var + ')';
+                }
+                if(num < 0 || num > 255) {
+                    return std::string("Each IP number must be between 0 and 255 ") + var;
+                }
+            }
+            return std::string();
+        };
+    }
+};
+
+}  // namespace detail
+
+// Static is not needed here, because global const implies static.
+
+/// Check for existing file (returns error message if check fails)
+const detail::ExistingFileValidator ExistingFile;
+
+/// Check for an existing directory (returns error message if check fails)
+const detail::ExistingDirectoryValidator ExistingDirectory;
+
+/// Check for an existing path
+const detail::ExistingPathValidator ExistingPath;
+
+/// Check for an non-existing path
+const detail::NonexistentPathValidator NonexistentPath;
+
+/// Check for an IP4 address
+const detail::IPV4Validator ValidIPV4;
+
+/// Validate the input as a particular type
+template <typename DesiredType> class TypeValidator : public Validator {
+  public:
+    explicit TypeValidator(const std::string &validator_name) : Validator(validator_name) {
+        func_ = [](std::string &input_string) {
+            auto val = DesiredType();
+            if(!detail::lexical_cast(input_string, val)) {
+                return std::string("Failed parsing ") + input_string + " as a " + detail::type_name<DesiredType>();
+            }
+            return std::string();
+        };
+    }
+    TypeValidator() : TypeValidator(detail::type_name<DesiredType>()) {}
+};
+
+/// Check for a number
+const TypeValidator<double> Number("NUMBER");
+
+/// Produce a range (factory). Min and max are inclusive.
+class Range : public Validator {
+  public:
+    /// This produces a range with min and max inclusive.
+    ///
+    /// Note that the constructor is templated, but the struct is not, so C++17 is not
+    /// needed to provide nice syntax for Range(a,b).
+    template <typename T>
+    Range(T min_val, T max_val, const std::string &validator_name = std::string{}) : Validator(validator_name) {
+        if(validator_name.empty()) {
+            std::stringstream out;
+            out << detail::type_name<T>() << " in [" << min_val << " - " << max_val << "]";
+            description(out.str());
+        }
+
+        func_ = [min_val, max_val](std::string &input) {
+            T val;
+            bool converted = detail::lexical_cast(input, val);
+            if((!converted) || (val < min_val || val > max_val))
+                return std::string("Value ") + input + " not in range " + std::to_string(min_val) + " to " +
+                       std::to_string(max_val);
+
+            return std::string{};
+        };
+    }
+
+    /// Range of one value is 0 to value
+    template <typename T>
+    explicit Range(T max_val, const std::string &validator_name = std::string{})
+        : Range(static_cast<T>(0), max_val, validator_name) {}
+};
+
+/// Check for a non negative number
+const Range NonNegativeNumber((std::numeric_limits<double>::max)(), "NONNEGATIVE");
+
+/// Check for a positive valued number (val>0.0), min() her is the smallest positive number
+const Range PositiveNumber((std::numeric_limits<double>::min)(), (std::numeric_limits<double>::max)(), "POSITIVE");
+
+/// Produce a bounded range (factory). Min and max are inclusive.
+class Bound : public Validator {
+  public:
+    /// This bounds a value with min and max inclusive.
+    ///
+    /// Note that the constructor is templated, but the struct is not, so C++17 is not
+    /// needed to provide nice syntax for Range(a,b).
+    template <typename T> Bound(T min_val, T max_val) {
+        std::stringstream out;
+        out << detail::type_name<T>() << " bounded to [" << min_val << " - " << max_val << "]";
+        description(out.str());
+
+        func_ = [min_val, max_val](std::string &input) {
+            T val;
+            bool converted = detail::lexical_cast(input, val);
+            if(!converted) {
+                return std::string("Value ") + input + " could not be converted";
+            }
+            if(val < min_val)
+                input = detail::to_string(min_val);
+            else if(val > max_val)
+                input = detail::to_string(max_val);
+
+            return std::string{};
+        };
+    }
+
+    /// Range of one value is 0 to value
+    template <typename T> explicit Bound(T max_val) : Bound(static_cast<T>(0), max_val) {}
+};
+
+namespace detail {
+template <typename T,
+          enable_if_t<is_copyable_ptr<typename std::remove_reference<T>::type>::value, detail::enabler> = detail::dummy>
+auto smart_deref(T value) -> decltype(*value) {
+    return *value;
+}
+
+template <
+    typename T,
+    enable_if_t<!is_copyable_ptr<typename std::remove_reference<T>::type>::value, detail::enabler> = detail::dummy>
+typename std::remove_reference<T>::type &smart_deref(T &value) {
+    return value;
+}
+/// Generate a string representation of a set
+template <typename T> std::string generate_set(const T &set) {
+    using element_t = typename detail::element_type<T>::type;
+    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type;  // the type of the object pair
+    std::string out(1, '{');
+    out.append(detail::join(
+        detail::smart_deref(set),
+        [](const iteration_type_t &v) { return detail::pair_adaptor<element_t>::first(v); },
+        ","));
+    out.push_back('}');
+    return out;
+}
+
+/// Generate a string representation of a map
+template <typename T> std::string generate_map(const T &map, bool key_only = false) {
+    using element_t = typename detail::element_type<T>::type;
+    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type;  // the type of the object pair
+    std::string out(1, '{');
+    out.append(detail::join(
+        detail::smart_deref(map),
+        [key_only](const iteration_type_t &v) {
+            std::string res{detail::to_string(detail::pair_adaptor<element_t>::first(v))};
+
+            if(!key_only) {
+                res.append("->");
+                res += detail::to_string(detail::pair_adaptor<element_t>::second(v));
+            }
+            return res;
+        },
+        ","));
+    out.push_back('}');
+    return out;
+}
+
+template <typename C, typename V> struct has_find {
+    template <typename CC, typename VV>
+    static auto test(int) -> decltype(std::declval<CC>().find(std::declval<VV>()), std::true_type());
+    template <typename, typename> static auto test(...) -> decltype(std::false_type());
+
+    static const auto value = decltype(test<C, V>(0))::value;
+    using type = std::integral_constant<bool, value>;
+};
+
+/// A search function
+template <typename T, typename V, enable_if_t<!has_find<T, V>::value, detail::enabler> = detail::dummy>
+auto search(const T &set, const V &val) -> std::pair<bool, decltype(std::begin(detail::smart_deref(set)))> {
+    using element_t = typename detail::element_type<T>::type;
+    auto &setref = detail::smart_deref(set);
+    auto it = std::find_if(std::begin(setref), std::end(setref), [&val](decltype(*std::begin(setref)) v) {
+        return (detail::pair_adaptor<element_t>::first(v) == val);
+    });
+    return {(it != std::end(setref)), it};
+}
+
+/// A search function that uses the built in find function
+template <typename T, typename V, enable_if_t<has_find<T, V>::value, detail::enabler> = detail::dummy>
+auto search(const T &set, const V &val) -> std::pair<bool, decltype(std::begin(detail::smart_deref(set)))> {
+    auto &setref = detail::smart_deref(set);
+    auto it = setref.find(val);
+    return {(it != std::end(setref)), it};
+}
+
+/// A search function with a filter function
+template <typename T, typename V>
+auto search(const T &set, const V &val, const std::function<V(V)> &filter_function)
+    -> std::pair<bool, decltype(std::begin(detail::smart_deref(set)))> {
+    using element_t = typename detail::element_type<T>::type;
+    // do the potentially faster first search
+    auto res = search(set, val);
+    if((res.first) || (!(filter_function))) {
+        return res;
+    }
+    // if we haven't found it do the longer linear search with all the element translations
+    auto &setref = detail::smart_deref(set);
+    auto it = std::find_if(std::begin(setref), std::end(setref), [&](decltype(*std::begin(setref)) v) {
+        V a{detail::pair_adaptor<element_t>::first(v)};
+        a = filter_function(a);
+        return (a == val);
+    });
+    return {(it != std::end(setref)), it};
+}
+
+// the following suggestion was made by Nikita Ofitserov(@himikof)
+// done in templates to prevent compiler warnings on negation of unsigned numbers
+
+/// Do a check for overflow on signed numbers
+template <typename T>
+inline typename std::enable_if<std::is_signed<T>::value, T>::type overflowCheck(const T &a, const T &b) {
+    if((a > 0) == (b > 0)) {
+        return ((std::numeric_limits<T>::max)() / (std::abs)(a) < (std::abs)(b));
+    } else {
+        return ((std::numeric_limits<T>::min)() / (std::abs)(a) > -(std::abs)(b));
+    }
+}
+/// Do a check for overflow on unsigned numbers
+template <typename T>
+inline typename std::enable_if<!std::is_signed<T>::value, T>::type overflowCheck(const T &a, const T &b) {
+    return ((std::numeric_limits<T>::max)() / a < b);
+}
+
+/// Performs a *= b; if it doesn't cause integer overflow. Returns false otherwise.
+template <typename T> typename std::enable_if<std::is_integral<T>::value, bool>::type checked_multiply(T &a, T b) {
+    if(a == 0 || b == 0 || a == 1 || b == 1) {
+        a *= b;
+        return true;
+    }
+    if(a == (std::numeric_limits<T>::min)() || b == (std::numeric_limits<T>::min)()) {
+        return false;
+    }
+    if(overflowCheck(a, b)) {
+        return false;
+    }
+    a *= b;
+    return true;
+}
+
+/// Performs a *= b; if it doesn't equal infinity. Returns false otherwise.
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value, bool>::type checked_multiply(T &a, T b) {
+    T c = a * b;
+    if(std::isinf(c) && !std::isinf(a) && !std::isinf(b)) {
+        return false;
+    }
+    a = c;
+    return true;
+}
+
+}  // namespace detail
+/// Verify items are in a set
+class IsMember : public Validator {
+  public:
+    using filter_fn_t = std::function<std::string(std::string)>;
+
+    /// This allows in-place construction using an initializer list
+    template <typename T, typename... Args>
+    IsMember(std::initializer_list<T> values, Args &&...args)
+        : IsMember(std::vector<T>(values), std::forward<Args>(args)...) {}
+
+    /// This checks to see if an item is in a set (empty function)
+    template <typename T> explicit IsMember(T &&set) : IsMember(std::forward<T>(set), nullptr) {}
+
+    /// This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter
+    /// both sides of the comparison before computing the comparison.
+    template <typename T, typename F> explicit IsMember(T set, F filter_function) {
+
+        // Get the type of the contained item - requires a container have ::value_type
+        // if the type does not have first_type and second_type, these are both value_type
+        using element_t = typename detail::element_type<T>::type;             // Removes (smart) pointers if needed
+        using item_t = typename detail::pair_adaptor<element_t>::first_type;  // Is value_type if not a map
+
+        using local_item_t = typename IsMemberType<item_t>::type;  // This will convert bad types to good ones
+                                                                   // (const char * to std::string)
+
+        // Make a local copy of the filter function, using a std::function if not one already
+        std::function<local_item_t(local_item_t)> filter_fn = filter_function;
+
+        // This is the type name for help, it will take the current version of the set contents
+        desc_function_ = [set]() { return detail::generate_set(detail::smart_deref(set)); };
+
+        // This is the function that validates
+        // It stores a copy of the set pointer-like, so shared_ptr will stay alive
+        func_ = [set, filter_fn](std::string &input) {
+            local_item_t b;
+            if(!detail::lexical_cast(input, b)) {
+                throw ValidationError(input);  // name is added later
+            }
+            if(filter_fn) {
+                b = filter_fn(b);
+            }
+            auto res = detail::search(set, b, filter_fn);
+            if(res.first) {
+                // Make sure the version in the input string is identical to the one in the set
+                if(filter_fn) {
+                    input = detail::value_string(detail::pair_adaptor<element_t>::first(*(res.second)));
+                }
+
+                // Return empty error string (success)
+                return std::string{};
+            }
+
+            // If you reach this point, the result was not found
+            return input + " not in " + detail::generate_set(detail::smart_deref(set));
+        };
+    }
+
+    /// You can pass in as many filter functions as you like, they nest (string only currently)
+    template <typename T, typename... Args>
+    IsMember(T &&set, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&...other)
+        : IsMember(
+              std::forward<T>(set),
+              [filter_fn_1, filter_fn_2](std::string a) { return filter_fn_2(filter_fn_1(a)); },
+              other...) {}
+};
+
+/// definition of the default transformation object
+template <typename T> using TransformPairs = std::vector<std::pair<std::string, T>>;
+
+/// Translate named items to other or a value set
+class Transformer : public Validator {
+  public:
+    using filter_fn_t = std::function<std::string(std::string)>;
+
+    /// This allows in-place construction
+    template <typename... Args>
+    Transformer(std::initializer_list<std::pair<std::string, std::string>> values, Args &&...args)
+        : Transformer(TransformPairs<std::string>(values), std::forward<Args>(args)...) {}
+
+    /// direct map of std::string to std::string
+    template <typename T> explicit Transformer(T &&mapping) : Transformer(std::forward<T>(mapping), nullptr) {}
+
+    /// This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter
+    /// both sides of the comparison before computing the comparison.
+    template <typename T, typename F> explicit Transformer(T mapping, F filter_function) {
+
+        static_assert(detail::pair_adaptor<typename detail::element_type<T>::type>::value,
+                      "mapping must produce value pairs");
+        // Get the type of the contained item - requires a container have ::value_type
+        // if the type does not have first_type and second_type, these are both value_type
+        using element_t = typename detail::element_type<T>::type;             // Removes (smart) pointers if needed
+        using item_t = typename detail::pair_adaptor<element_t>::first_type;  // Is value_type if not a map
+        using local_item_t = typename IsMemberType<item_t>::type;             // Will convert bad types to good ones
+                                                                              // (const char * to std::string)
+
+        // Make a local copy of the filter function, using a std::function if not one already
+        std::function<local_item_t(local_item_t)> filter_fn = filter_function;
+
+        // This is the type name for help, it will take the current version of the set contents
+        desc_function_ = [mapping]() { return detail::generate_map(detail::smart_deref(mapping)); };
+
+        func_ = [mapping, filter_fn](std::string &input) {
+            local_item_t b;
+            if(!detail::lexical_cast(input, b)) {
+                return std::string();
+                // there is no possible way we can match anything in the mapping if we can't convert so just return
+            }
+            if(filter_fn) {
+                b = filter_fn(b);
+            }
+            auto res = detail::search(mapping, b, filter_fn);
+            if(res.first) {
+                input = detail::value_string(detail::pair_adaptor<element_t>::second(*res.second));
+            }
+            return std::string{};
+        };
+    }
+
+    /// You can pass in as many filter functions as you like, they nest
+    template <typename T, typename... Args>
+    Transformer(T &&mapping, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&...other)
+        : Transformer(
+              std::forward<T>(mapping),
+              [filter_fn_1, filter_fn_2](std::string a) { return filter_fn_2(filter_fn_1(a)); },
+              other...) {}
+};
+
+/// translate named items to other or a value set
+class CheckedTransformer : public Validator {
+  public:
+    using filter_fn_t = std::function<std::string(std::string)>;
+
+    /// This allows in-place construction
+    template <typename... Args>
+    CheckedTransformer(std::initializer_list<std::pair<std::string, std::string>> values, Args &&...args)
+        : CheckedTransformer(TransformPairs<std::string>(values), std::forward<Args>(args)...) {}
+
+    /// direct map of std::string to std::string
+    template <typename T> explicit CheckedTransformer(T mapping) : CheckedTransformer(std::move(mapping), nullptr) {}
+
+    /// This checks to see if an item is in a set: pointer or copy version. You can pass in a function that will filter
+    /// both sides of the comparison before computing the comparison.
+    template <typename T, typename F> explicit CheckedTransformer(T mapping, F filter_function) {
+
+        static_assert(detail::pair_adaptor<typename detail::element_type<T>::type>::value,
+                      "mapping must produce value pairs");
+        // Get the type of the contained item - requires a container have ::value_type
+        // if the type does not have first_type and second_type, these are both value_type
+        using element_t = typename detail::element_type<T>::type;             // Removes (smart) pointers if needed
+        using item_t = typename detail::pair_adaptor<element_t>::first_type;  // Is value_type if not a map
+        using local_item_t = typename IsMemberType<item_t>::type;             // Will convert bad types to good ones
+                                                                              // (const char * to std::string)
+        using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type;  // the type of the object pair
+
+        // Make a local copy of the filter function, using a std::function if not one already
+        std::function<local_item_t(local_item_t)> filter_fn = filter_function;
+
+        auto tfunc = [mapping]() {
+            std::string out("value in ");
+            out += detail::generate_map(detail::smart_deref(mapping)) + " OR {";
+            out += detail::join(
+                detail::smart_deref(mapping),
+                [](const iteration_type_t &v) { return detail::to_string(detail::pair_adaptor<element_t>::second(v)); },
+                ",");
+            out.push_back('}');
+            return out;
+        };
+
+        desc_function_ = tfunc;
+
+        func_ = [mapping, tfunc, filter_fn](std::string &input) {
+            local_item_t b;
+            bool converted = detail::lexical_cast(input, b);
+            if(converted) {
+                if(filter_fn) {
+                    b = filter_fn(b);
+                }
+                auto res = detail::search(mapping, b, filter_fn);
+                if(res.first) {
+                    input = detail::value_string(detail::pair_adaptor<element_t>::second(*res.second));
+                    return std::string{};
+                }
+            }
+            for(const auto &v : detail::smart_deref(mapping)) {
+                auto output_string = detail::value_string(detail::pair_adaptor<element_t>::second(v));
+                if(output_string == input) {
+                    return std::string();
+                }
+            }
+
+            return "Check " + input + " " + tfunc() + " FAILED";
+        };
+    }
+
+    /// You can pass in as many filter functions as you like, they nest
+    template <typename T, typename... Args>
+    CheckedTransformer(T &&mapping, filter_fn_t filter_fn_1, filter_fn_t filter_fn_2, Args &&...other)
+        : CheckedTransformer(
+              std::forward<T>(mapping),
+              [filter_fn_1, filter_fn_2](std::string a) { return filter_fn_2(filter_fn_1(a)); },
+              other...) {}
+};
+
+/// Helper function to allow ignore_case to be passed to IsMember or Transform
+inline std::string ignore_case(std::string item) { return detail::to_lower(item); }
+
+/// Helper function to allow ignore_underscore to be passed to IsMember or Transform
+inline std::string ignore_underscore(std::string item) { return detail::remove_underscore(item); }
+
+/// Helper function to allow checks to ignore spaces to be passed to IsMember or Transform
+inline std::string ignore_space(std::string item) {
+    item.erase(std::remove(std::begin(item), std::end(item), ' '), std::end(item));
+    item.erase(std::remove(std::begin(item), std::end(item), '\t'), std::end(item));
+    return item;
+}
+
+/// Multiply a number by a factor using given mapping.
+/// Can be used to write transforms for SIZE or DURATION inputs.
+///
+/// Example:
+///   With mapping = `{"b"->1, "kb"->1024, "mb"->1024*1024}`
+///   one can recognize inputs like "100", "12kb", "100 MB",
+///   that will be automatically transformed to 100, 14448, 104857600.
+///
+/// Output number type matches the type in the provided mapping.
+/// Therefore, if it is required to interpret real inputs like "0.42 s",
+/// the mapping should be of a type <string, float> or <string, double>.
+class AsNumberWithUnit : public Validator {
+  public:
+    /// Adjust AsNumberWithUnit behavior.
+    /// CASE_SENSITIVE/CASE_INSENSITIVE controls how units are matched.
+    /// UNIT_OPTIONAL/UNIT_REQUIRED throws ValidationError
+    ///   if UNIT_REQUIRED is set and unit literal is not found.
+    enum Options {
+        CASE_SENSITIVE = 0,
+        CASE_INSENSITIVE = 1,
+        UNIT_OPTIONAL = 0,
+        UNIT_REQUIRED = 2,
+        DEFAULT = CASE_INSENSITIVE | UNIT_OPTIONAL
+    };
+
+    template <typename Number>
+    explicit AsNumberWithUnit(std::map<std::string, Number> mapping,
+                              Options opts = DEFAULT,
+                              const std::string &unit_name = "UNIT") {
+        description(generate_description<Number>(unit_name, opts));
+        validate_mapping(mapping, opts);
+
+        // transform function
+        func_ = [mapping, opts](std::string &input) -> std::string {
+            Number num;
+
+            detail::rtrim(input);
+            if(input.empty()) {
+                throw ValidationError("Input is empty");
+            }
+
+            // Find split position between number and prefix
+            auto unit_begin = input.end();
+            while(unit_begin > input.begin() && std::isalpha(*(unit_begin - 1), std::locale())) {
+                --unit_begin;
+            }
+
+            std::string unit{unit_begin, input.end()};
+            input.resize(static_cast<std::size_t>(std::distance(input.begin(), unit_begin)));
+            detail::trim(input);
+
+            if(opts & UNIT_REQUIRED && unit.empty()) {
+                throw ValidationError("Missing mandatory unit");
+            }
+            if(opts & CASE_INSENSITIVE) {
+                unit = detail::to_lower(unit);
+            }
+            if(unit.empty()) {
+                if(!detail::lexical_cast(input, num)) {
+                    throw ValidationError(std::string("Value ") + input + " could not be converted to " +
+                                          detail::type_name<Number>());
+                }
+                // No need to modify input if no unit passed
+                return {};
+            }
+
+            // find corresponding factor
+            auto it = mapping.find(unit);
+            if(it == mapping.end()) {
+                throw ValidationError(unit +
+                                      " unit not recognized. "
+                                      "Allowed values: " +
+                                      detail::generate_map(mapping, true));
+            }
+
+            if(!input.empty()) {
+                bool converted = detail::lexical_cast(input, num);
+                if(!converted) {
+                    throw ValidationError(std::string("Value ") + input + " could not be converted to " +
+                                          detail::type_name<Number>());
+                }
+                // perform safe multiplication
+                bool ok = detail::checked_multiply(num, it->second);
+                if(!ok) {
+                    throw ValidationError(detail::to_string(num) + " multiplied by " + unit +
+                                          " factor would cause number overflow. Use smaller value.");
+                }
+            } else {
+                num = static_cast<Number>(it->second);
+            }
+
+            input = detail::to_string(num);
+
+            return {};
+        };
+    }
+
+  private:
+    /// Check that mapping contains valid units.
+    /// Update mapping for CASE_INSENSITIVE mode.
+    template <typename Number> static void validate_mapping(std::map<std::string, Number> &mapping, Options opts) {
+        for(auto &kv : mapping) {
+            if(kv.first.empty()) {
+                throw ValidationError("Unit must not be empty.");
+            }
+            if(!detail::isalpha(kv.first)) {
+                throw ValidationError("Unit must contain only letters.");
+            }
+        }
+
+        // make all units lowercase if CASE_INSENSITIVE
+        if(opts & CASE_INSENSITIVE) {
+            std::map<std::string, Number> lower_mapping;
+            for(auto &kv : mapping) {
+                auto s = detail::to_lower(kv.first);
+                if(lower_mapping.count(s)) {
+                    throw ValidationError(std::string("Several matching lowercase unit representations are found: ") +
+                                          s);
+                }
+                lower_mapping[detail::to_lower(kv.first)] = kv.second;
+            }
+            mapping = std::move(lower_mapping);
+        }
+    }
+
+    /// Generate description like this: NUMBER [UNIT]
+    template <typename Number> static std::string generate_description(const std::string &name, Options opts) {
+        std::stringstream out;
+        out << detail::type_name<Number>() << ' ';
+        if(opts & UNIT_REQUIRED) {
+            out << name;
+        } else {
+            out << '[' << name << ']';
+        }
+        return out.str();
+    }
+};
+
+/// Converts a human-readable size string (with unit literal) to uin64_t size.
+/// Example:
+///   "100" => 100
+///   "1 b" => 100
+///   "10Kb" => 10240 // you can configure this to be interpreted as kilobyte (*1000) or kibibyte (*1024)
+///   "10 KB" => 10240
+///   "10 kb" => 10240
+///   "10 kib" => 10240 // *i, *ib are always interpreted as *bibyte (*1024)
+///   "10kb" => 10240
+///   "2 MB" => 2097152
+///   "2 EiB" => 2^61 // Units up to exibyte are supported
+class AsSizeValue : public AsNumberWithUnit {
+  public:
+    using result_t = std::uint64_t;
+
+    /// If kb_is_1000 is true,
+    /// interpret 'kb', 'k' as 1000 and 'kib', 'ki' as 1024
+    /// (same applies to higher order units as well).
+    /// Otherwise, interpret all literals as factors of 1024.
+    /// The first option is formally correct, but
+    /// the second interpretation is more wide-spread
+    /// (see https://en.wikipedia.org/wiki/Binary_prefix).
+    explicit AsSizeValue(bool kb_is_1000) : AsNumberWithUnit(get_mapping(kb_is_1000)) {
+        if(kb_is_1000) {
+            description("SIZE [b, kb(=1000b), kib(=1024b), ...]");
+        } else {
+            description("SIZE [b, kb(=1024b), ...]");
+        }
+    }
+
+  private:
+    /// Get <size unit, factor> mapping
+    static std::map<std::string, result_t> init_mapping(bool kb_is_1000) {
+        std::map<std::string, result_t> m;
+        result_t k_factor = kb_is_1000 ? 1000 : 1024;
+        result_t ki_factor = 1024;
+        result_t k = 1;
+        result_t ki = 1;
+        m["b"] = 1;
+        for(std::string p : {"k", "m", "g", "t", "p", "e"}) {
+            k *= k_factor;
+            ki *= ki_factor;
+            m[p] = k;
+            m[p + "b"] = k;
+            m[p + "i"] = ki;
+            m[p + "ib"] = ki;
+        }
+        return m;
+    }
+
+    /// Cache calculated mapping
+    static std::map<std::string, result_t> get_mapping(bool kb_is_1000) {
+        if(kb_is_1000) {
+            static auto m = init_mapping(true);
+            return m;
+        } else {
+            static auto m = init_mapping(false);
+            return m;
+        }
+    }
+};
+
+namespace detail {
+/// Split a string into a program name and command line arguments
+/// the string is assumed to contain a file name followed by other arguments
+/// the return value contains is a pair with the first argument containing the program name and the second
+/// everything else.
+inline std::pair<std::string, std::string> split_program_name(std::string commandline) {
+    // try to determine the programName
+    std::pair<std::string, std::string> vals;
+    trim(commandline);
+    auto esp = commandline.find_first_of(' ', 1);
+    while(detail::check_path(commandline.substr(0, esp).c_str()) != path_type::file) {
+        esp = commandline.find_first_of(' ', esp + 1);
+        if(esp == std::string::npos) {
+            // if we have reached the end and haven't found a valid file just assume the first argument is the
+            // program name
+            if(commandline[0] == '"' || commandline[0] == '\'' || commandline[0] == '`') {
+                bool embeddedQuote = false;
+                auto keyChar = commandline[0];
+                auto end = commandline.find_first_of(keyChar, 1);
+                while((end != std::string::npos) && (commandline[end - 1] == '\\')) {  // deal with escaped quotes
+                    end = commandline.find_first_of(keyChar, end + 1);
+                    embeddedQuote = true;
+                }
+                if(end != std::string::npos) {
+                    vals.first = commandline.substr(1, end - 1);
+                    esp = end + 1;
+                    if(embeddedQuote) {
+                        vals.first = find_and_replace(vals.first, std::string("\\") + keyChar, std::string(1, keyChar));
+                    }
+                } else {
+                    esp = commandline.find_first_of(' ', 1);
+                }
+            } else {
+                esp = commandline.find_first_of(' ', 1);
+            }
+
+            break;
+        }
+    }
+    if(vals.first.empty()) {
+        vals.first = commandline.substr(0, esp);
+        rtrim(vals.first);
+    }
+
+    // strip the program name
+    vals.second = (esp != std::string::npos) ? commandline.substr(esp + 1) : std::string{};
+    ltrim(vals.second);
+    return vals;
+}
+
+}  // namespace detail
+/// @}
+
+// [CLI11:validators_hpp:end]
+}  // namespace CLI
diff --git a/src/phasicFlow/commandLine/CLI/Version.hpp b/src/phasicFlow/commandLine/CLI/Version.hpp
new file mode 100644
index 00000000..c989ae86
--- /dev/null
+++ b/src/phasicFlow/commandLine/CLI/Version.hpp
@@ -0,0 +1,16 @@
+// Copyright (c) 2017-2021, University of Cincinnati, developed by Henry Schreiner
+// under NSF AWARD 1414736 and by the respective contributors.
+// All rights reserved.
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#pragma once
+
+// [CLI11:version_hpp:verbatim]
+
+#define CLI11_VERSION_MAJOR 2
+#define CLI11_VERSION_MINOR 1
+#define CLI11_VERSION_PATCH 1
+#define CLI11_VERSION "2.1.1"
+
+// [CLI11:version_hpp:end]
diff --git a/src/phasicFlow/commandLine/commandLine.C b/src/phasicFlow/commandLine/commandLine.C
new file mode 100644
index 00000000..dfa1cb1f
--- /dev/null
+++ b/src/phasicFlow/commandLine/commandLine.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+#include "commandLine.H"
+
+
+pFlow::commandLine::commandLine(word appName)
+:
+	CLI::App(description),
+	appName_(appName)
+{
+	CLI::App::set_help_flag("-h,--help", "Help for using "+appName_+ " of "+versionName);
+	CLI::App::set_version_flag("-v,--version", versionName, "Program version information");
+}
+
+pFlow::commandLine::commandLine(word appName, word disptn)
+:
+	commandLine(appName)
+{
+	
+	CLI::App::add_flag_callback(
+		"--discription",
+		[disptn, appName]() {
+			output<<"\n"<<yellowText(versoinCopyright)<<endl<<endl;
+			output<<"Discription for "<< boldText(appName)<<":\n";
+			output<<"  "<<disptn<<endl;
+		},
+		"What does this app do?"
+		)->configurable(false);
+}
+
+bool pFlow::commandLine::parse(
+	int argc,
+	char** argv)
+{
+	try {                       
+        CLI::App::parse(argc, argv);
+        if(CLI::App::count("--discription")) return false;
+        return true;
+    } catch(const ParseError &e) {                                                                                
+        CLI::App::exit(e);
+        return false;
+    }
+
+    //if()
+}
diff --git a/src/phasicFlow/commandLine/commandLine.H b/src/phasicFlow/commandLine/commandLine.H
new file mode 100644
index 00000000..d3c01525
--- /dev/null
+++ b/src/phasicFlow/commandLine/commandLine.H
@@ -0,0 +1,140 @@
+/*------------------------------- 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 __commandLine_H__
+#define __commandLine_H__
+
+#include <any>
+#include "CLI.hpp"
+
+#include "types.H"
+#include "Lists.H"
+#include "streams.H"
+
+namespace pFlow
+{
+
+
+class commandLine
+:
+	public CLI::App
+{
+public:
+	
+	using Option = CLI::Option;
+
+	using ParseError = CLI::ParseError;
+
+	using any = std::any;
+
+protected:
+	
+	word appName_;
+
+	List<any> 	internalBinVars_;
+
+	inline static  word versionStr = "v-"+
+					int322Word(phasicFlow_VERSION_MAJOR)+
+					"."+
+					int322Word(phasicFlow_VERSION_MINOR);
+	inline static  	word copyRight = "(copyright(C): www.cemf.ir)";
+
+	inline static 	word versionName = "phasicFlow "+ versionStr;
+
+	inline static   word versoinCopyright = versionName + " " +copyRight;
+
+	inline static 	word description = "Command line help for "+
+										versoinCopyright +"\n";
+	
+	
+
+public:
+
+	commandLine(word appName);
+
+	commandLine(word appName, word disptn);
+	
+
+	bool parse(int argc, char** argv);
+
+	template<typename Type>
+	Option* addOption(
+		word optionName,
+		word description,
+		word opText = "");
+
+	template<typename Type>
+	Option* addOption(
+		word optionName,
+		Type& bindingVar,
+		word description,
+		word opText = "");
+
+
+
+};
+
+}// pFlow
+
+
+template<typename Type>
+pFlow::commandLine::Option*
+	pFlow::commandLine::addOption(
+		word optionName,
+		word description,
+		word opText)
+{
+	try{
+
+		Type& bindingVar = std::any_cast<Type&>(
+			internalBinVars_.emplace_back( any(Type()))
+				);
+		return CLI::App::add_option(optionName, bindingVar, description)->option_text(opText);		
+	} 
+	catch (ParseError& err){
+		fatalExit;
+		return nullptr;
+	}
+}
+
+
+template<typename Type>
+pFlow::commandLine::Option*
+	pFlow::commandLine::addOption(
+		word optionName,
+		Type& bindingVar,
+		word description,
+		word opText)
+{
+	try{
+
+		return CLI::App::add_option(optionName, bindingVar, description)->option_text(opText);		
+	} 
+	catch (ParseError& err){
+		fatalExit;
+		return nullptr;
+	}
+}
+
+
+
+#endif 
+
diff --git a/src/phasicFlow/containers/Field/Field.C b/src/phasicFlow/containers/Field/Field.C
new file mode 100644
index 00000000..2acd3fb0
--- /dev/null
+++ b/src/phasicFlow/containers/Field/Field.C
@@ -0,0 +1,170 @@
+/*------------------------------- 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<template<class, class> class VectorField, class T, class PropType>
+bool pFlow::Field<VectorField, T, PropType>::readUniform
+( 
+	iIstream& is,
+	size_t len,
+	bool readLength
+)
+{
+	size_t flen = 0;
+	if( readLength ) 
+	{
+		is>>flen;
+
+		if(is.bad() || is.eof() )
+		{
+			ioErrorInFile( is.name(), is.lineNumber() ) <<
+			"expected integer value to specify field length \n";
+			return false;
+		}
+	}
+	else
+	{
+		flen = len;
+	}
+
+	// create a vector with one element and read it in
+	T bF;
+	
+	is >> bF;	
+	
+	VectorType::assign(flen, bF);
+	
+	// read end statement char ;
+	is.readEndStatement("readField");
+
+	return true;
+}
+
+
+template<template<class, class> class VectorField, class T, class PropType>
+bool pFlow::Field<VectorField, T, PropType>::readNonUniform
+(
+	iIstream& is,
+	size_t len
+)
+{
+	size_t flen = 0;
+
+	
+	is >> flen;
+	if(is.bad() || is.eof() )
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		"  expected integer value to specify field length \n";
+		return false;
+	}
+	
+	if( len!=0 && flen != len )
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		"  expected "<< len <<" as the field length but found "<< flen <<" \n";
+		return false;	
+	}
+
+	this->clear();
+	VectorType::read(is);
+	
+	is.readEndStatement("readField");
+
+	if(  this->size() != flen )
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		"  expected " << flen << " elements, but supplied "<<
+		this->size() << " elements in file "<< is.name() <<endl;
+		return false; 
+	}
+
+	return true;	
+}
+
+
+template<template<class, class> class VectorField, class T, class PropType>
+bool pFlow::Field<VectorField, T, PropType>::readField
+(
+	iIstream& is,
+	const size_t len,
+	bool readLength
+)
+{
+	if( !is.findToken(fieldKey_) )
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		" error in searching for filedkey " << fieldKey_<<endl;
+		return false;
+	}
+
+	word fieldU;
+
+	is >> fieldU;
+	
+	if(is.bad() || is.eof())
+	{
+		ioErrorInFile( is.name(), is.lineNumber()) <<
+		" error in reading keyword from file.";
+		return false;
+	}
+
+	if( fieldU == uniform__ )
+	{
+		
+		return readUniform(is, len, readLength);
+
+	}
+	else if( fieldU == nonUniform__ )
+	{
+
+		return readNonUniform(is, len); 
+
+	}
+	else
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		"unknown keyword, expected uniform/nonUniform, but found " <<
+		fieldU << endl;
+		return false;
+	}
+
+	return true;
+}
+
+
+template<template<class, class> class VectorField, class T, class PropType>
+bool pFlow::Field<VectorField, T, PropType>::readField
+(
+	iIstream& is
+)
+{
+	return readField(is, 0, true);
+}
+
+
+template<template<class, class> class VectorField, class T, class PropType>
+bool pFlow::Field<VectorField, T, PropType>::writeField(iOstream& os)const
+{
+	os.writeWordKeyword(fieldKey_) << nonUniform__<<endl;
+	os<< this->size()<<endl;
+	VectorType::write(os);
+	os.endEntry();
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Field/Field.H b/src/phasicFlow/containers/Field/Field.H
new file mode 100644
index 00000000..512f3339
--- /dev/null
+++ b/src/phasicFlow/containers/Field/Field.H
@@ -0,0 +1,270 @@
+/*------------------------------- 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 __Field_H__
+#define __Field_H__
+
+#include "VectorSingle.H"
+#include "vocabs.H"
+
+namespace pFlow
+{
+
+
+
+template<template<class, class> class VectorField, class T, class PropType=void>
+class Field
+:
+	public VectorField<T, PropType>
+{
+public:
+	
+
+	using VectorType  		= VectorField<T,PropType>;
+
+	using FieldType         = Field<VectorField, T, PropType>;
+
+	using iterator        = typename VectorType::iterator;
+
+  	using constIterator   = typename VectorType::constIterator;
+
+	using reference       = typename VectorType::reference;
+  	
+  	using constReference  = typename VectorType::constReference;
+
+	using valueType       = typename VectorType::valueType;
+  	
+  	using pointer         = typename VectorType::pointer;
+  	
+  	using constPointer    = typename VectorType::constPointer;
+  	
+
+protected:
+	
+	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
+	TypeNameTemplateNV2("Field", T, VectorType::memoerySpaceName());
+
+	//// - Constructors
+
+		// construct an empty Filed with default fieldKey
+		Field()
+		:
+			VectorType()
+		{}
+
+		// construct an empty Field with fieldKey
+		Field(const word& fieldKey)
+		:
+			VectorType(),
+			fieldKey_(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 
+		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
+		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)
+		:
+			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()),
+			fieldKey_(fieldKey)
+		{}
+
+		// construct an empty field with name and fieldKey 
+		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
+		Field(const word& fieldKey, const Vector<T>& vec)
+		:
+			VectorType(vec),
+			fieldKey_(fieldKey)
+		{}
+
+		// construct an empty field with name and fieldKey 
+		Field(const word& name, const word& fieldKey, const Vector<T>& vec)
+		:
+			VectorType(name, vec),
+			fieldKey_(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
+		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
+		{
+			return makeUnique<FieldType>(*this);
+		}
+
+		// - clone as a raw pointer 
+		INLINE_FUNCTION_H
+		FieldType* clonePtr()const
+		{
+			return new FieldType(*this);
+		}
+
+	//// - Methods
+
+		const word& fieldKey()const
+		{
+			return fieldKey_;
+		}
+	
+	//// - IO operations 
+		bool readField(iIstream& is, const size_t len, bool readLength = true);
+		
+		
+		bool readField(iIstream& is );
+
+		
+		bool writeField(iOstream& os)const;
+
+		
+		bool read(iIstream& is)
+		{
+			return readField(is);
+		}
+
+		bool write(iOstream& os)const
+		{
+			return writeField(os);
+		}
+	
+
+};
+
+
+template<template<class, class> class VectorField, class T, class PropType>
+inline iIstream& operator >> (iIstream & is, Field<VectorField, T, PropType> & ifld )
+{
+	if( !ifld.readField(is) )
+	{
+		ioErrorInFile (is.name(), is.lineNumber());
+		fatalExit;
+	}
+	return is;
+}
+
+template<template<class, class> class VectorField, class T, class PropType>
+inline iOstream& operator << (iOstream& os, const Field<VectorField, T, PropType>& ofld )
+{
+	
+	if( !ofld.writeField(os) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+
+	return os; 
+}
+
+
+}
+
+#include "Field.C"
+
+
+#endif  //__Field_H__
diff --git a/src/phasicFlow/containers/Field/Fields.C b/src/phasicFlow/containers/Field/Fields.C
new file mode 100644
index 00000000..de4628a2
--- /dev/null
+++ b/src/phasicFlow/containers/Field/Fields.C
@@ -0,0 +1,81 @@
+/*------------------------------- 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 "Fields.H"
+
+
+template class pFlow::Field<pFlow::VectorSingle, pFlow::int8>;
+
+template class pFlow::Field<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>;
+
+template class pFlow::Field<pFlow::VectorSingle, pFlow::int16>;
+
+template class pFlow::Field<pFlow::VectorSingle, pFlow::int16, pFlow::HostSpace>;
+
+template class pFlow::Field<pFlow::VectorSingle, pFlow::int32>;
+
+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::Vector, pFlow::word, pFlow::vecAllocator<pFlow::word>>;
+
+
diff --git a/src/phasicFlow/containers/Field/Fields.H b/src/phasicFlow/containers/Field/Fields.H
new file mode 100644
index 00000000..a15cb00b
--- /dev/null
+++ b/src/phasicFlow/containers/Field/Fields.H
@@ -0,0 +1,126 @@
+/*------------------------------- 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 __Fields_H__
+#define __Fields_H__
+
+#include "types.H"
+#include "Field.H"
+#include "VectorSingle.H"
+#include "VectorDual.H"
+
+
+namespace pFlow
+{
+
+
+using int8Field_D 		= Field<VectorSingle, int8>;
+
+using int8Field_H 		= Field<VectorSingle, int8, HostSpace>;
+
+using int16Field_D 		= Field<VectorSingle, int16>;
+
+using int16Field_H 		= Field<VectorSingle, int16, HostSpace>;
+
+using int32Field_D 		= Field<VectorSingle, int32>;
+
+using int32Field_H 		= Field<VectorSingle, int32, HostSpace>;
+
+using int64Field_D 		= Field<VectorSingle, int64>;
+
+using int64Field_H 		= Field<VectorSingle, int64, HostSpace>;
+
+using uint32Field_D 	= Field<VectorSingle, uint32>;
+
+using uint32Field_H 	= Field<VectorSingle, uint32, HostSpace>;
+
+using labelField_D 		= Field<VectorSingle, label>;
+
+using labelField_H 		= Field<VectorSingle, label, HostSpace> ;
+
+using realField_D 		= Field<VectorSingle, real>;
+
+using realField_H 		= Field<VectorSingle, real, HostSpace> ;
+
+using realx3Field_D 	= Field<VectorSingle, realx3>;
+
+using realx3Field_H 	= Field<VectorSingle, realx3, HostSpace>;
+
+using uint16x3Field_D 	= Field<VectorSingle, uint16x3>;
+
+using uint16x3Field_H 	= Field<VectorSingle, uint16x3, HostSpace>;
+
+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>;
+
+// - no typedef on device (since word does not compile on CUDA)
+using wordField_H 		= Field<VectorSingle, word, HostSpace>;
+
+
+// host device fields
+using int8Field_HD 		= Field<VectorDual, int8>;
+
+using int16Field_HD 	= Field<VectorDual, int16>;
+
+using int32Field_HD 	= Field<VectorDual, int32>;
+
+using int64Field_HD 	= Field<VectorDual, int64>;
+
+using uint32Field_HD 	= Field<VectorDual, uint32>;
+
+using labelField_HD 	= Field<VectorDual, label>;
+
+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>>; 
+
+
+
+}
+
+
+
+#endif  //__Fields_H__
diff --git a/src/phasicFlow/containers/List/List/List.H b/src/phasicFlow/containers/List/List/List.H
new file mode 100644
index 00000000..d880a99f
--- /dev/null
+++ b/src/phasicFlow/containers/List/List/List.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#ifndef __List_H__
+#define __List_H__
+
+#include <list>
+
+#include "types.H"
+#include "typeInfo.H"
+#include "uniquePtr.H"
+#include "iOstream.H"
+#include "iIstream.H"
+
+namespace pFlow
+{
+
+
+template<
+    typename T
+> class List 
+:
+	public std::list<T, std::allocator<T> >
+{
+
+public:
+
+	using ListType 		= List<T>;
+
+	using listType 		= std::list<T,std::allocator<T>>;
+
+	using iterator 		= typename listType::iterator;
+	
+	using constIterator = typename listType::const_iterator;
+	
+	using reference 	= typename listType::reference;
+	
+	using constReference= typename listType::const_reference;
+	
+	using initList 		= typename std::initializer_list<T>;
+	
+	using valueType 	= T; 
+
+
+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;
+		if( len < 6 )
+			stride = len;
+		else if( len <16 )
+			stride = 3;
+		else if( len < 31)
+			stride = 2;
+		else
+			stride = 1;
+
+		return stride;
+	}
+
+public:
+
+	// - Type info
+	TypeNameTemplateNV("List", T);
+
+	//// - Constructors
+
+		// - empty list 
+		List()
+		{}
+
+		// - list with length len
+		List(size_t len)
+		:
+			listType(len)
+		{}
+
+		// - list with length len and value
+		List(size_t len, const T& value)
+		:
+			listType(len, value)
+		{}
+
+		// - construct from initList
+		List(initList lst)
+		:
+			listType(lst)
+		{}
+
+
+		// - copy construct
+		List(const List& src):
+			listType(src)
+		{}
+
+		// - move construct
+		List( List && mv)
+		:
+			listType(std::move(mv))
+		{}
+
+		// - copy assignment
+		ListType& operator=(const ListType& rhs)
+		{
+			listType::operator=(rhs);
+			return *this;
+		}
+
+		// - move assignment
+		ListType& operator=(ListType&& rhs)
+		{
+			listType::operator=(std::move(rhs));
+			return *this;
+		}	
+
+
+		uniquePtr<ListType> clone()const{
+			return makeUnique<ListType>(*this);
+		}
+
+		ListType* clonePtr()const{
+			return new ListType(*this);
+		}
+
+
+		// - destructor 
+		~List()
+		{
+			listType::clear();
+		}
+
+	//// -  Methods
+
+		// - counts elements based on a given value
+		int32 countElement(const T& elm) const;
+		
+		// - size of container
+		size_t size()const;
+		
+		// - access to ith element
+		//   fatal exit if out of range
+		T& operator[](size_t i);
+
+		// - const access to ith element
+		//   fatal exit if our of range
+		const T& operator[](size_t i)const;
+		
+		// - find the position of the first element with value val
+		//   cend() if not found
+		constIterator find(const T& val) const;
+		
+		// - find the position of the first element with value val
+		//    end() if not found
+		iterator find(const T& val);
+
+		// - find the index of the first element with value val
+		//   -1 if not found
+		int32 findi(const T& val) const;
+		
+
+		// - search for element, if finds it, 
+		//   return true, otherwise false
+		bool search(const T& val) const;
+
+		// - set ith element with copy 
+		//   fatal error if out of range
+		void set(size_t i, const T& val);
+		
+		// - set ith element with move operation 
+		//   fatal error if out of range 
+		void set(size_t i, T&& val);
+
+	//// - IO operations
+
+		// - write to oStream
+		bool writeList(iOstream& os) const;
+		
+		// - read from iStream
+		bool readList(iIstream& is);
+
+		bool read(iIstream& is)
+		{
+			return readList(is);
+		}
+
+		bool write(iOstream& os)const
+		{
+			return writeList(os);
+		}
+	
+};
+
+
+template<typename T>
+iOstream& operator << (iOstream& os, const List<T>& lst );
+
+
+template<typename T>
+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 uint32List 	= List<uint32>;
+
+using realList 		= List<real>;
+using realx3List 	= List<realx3>;
+using realx3x3List  = List<realx3x3>;
+
+
+using boolList 		= List<bool>;
+using wordList 		= List<word>;
+
+
+
+} // pFlow
+
+
+#include "ListI.H"
+
+#endif //__List_H__
diff --git a/src/phasicFlow/containers/List/List/ListI.H b/src/phasicFlow/containers/List/List/ListI.H
new file mode 100644
index 00000000..60caf3b2
--- /dev/null
+++ b/src/phasicFlow/containers/List/List/ListI.H
@@ -0,0 +1,257 @@
+/*------------------------------- 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>
+auto pFlow::List<T>::pos
+(
+	size_t i
+)
+{
+	if( i >= size() )
+	{
+		fatalErrorInFunction<<
+		"our of range access to list element. \n";
+		fatalExit;
+	}
+	auto iter = listType::begin();
+	std::advance(iter, i);
+	return iter;
+}
+
+template<typename T>
+const auto pFlow::List<T>::pos
+(
+	size_t i
+)const 
+{
+	if( i >= size() )
+	{
+		fatalErrorInFunction<<
+		"our of range access to list element. \n";
+		fatalExit;
+	}
+	auto iter = listType::cbegin();
+	std::advance(iter, i);
+	return iter;
+}
+
+
+template<typename T>
+inline pFlow::int32 pFlow::List<T>::countElement
+(
+	const T& elm
+) const
+{
+	return std::count( listType::begin(), listType::end(), elm);
+}
+
+template<typename T>
+inline size_t pFlow::List<T>::size()const
+{
+	return listType::size();
+}
+
+template<typename T>
+inline T& pFlow::List<T>::operator[]
+(
+	size_t i
+)
+{
+	return *pos(i);
+}
+
+template<typename T>
+inline const T& pFlow::List<T>::operator[]
+(
+	size_t i
+)const
+{
+	
+	return *pos(i);
+}
+
+template<typename T>
+inline typename  pFlow::List<T>::constIterator pFlow::List<T>::find
+(
+	const T& val
+) const
+{
+	return std::find(this->begin(),this->end(), val);
+}
+
+template<typename T>
+inline typename  pFlow::List<T>::iterator pFlow::List<T>::find
+(
+	const T& val
+)
+{
+	return std::find(this->begin(),this->end(), val);
+}
+
+template<typename T>
+pFlow::int32 pFlow::List<T>::findi(const T& val) const
+{
+	auto pos = find(val);
+	if( pos == this->end() )return -1;
+	return static_cast<int32> (std::distance(this->begin(), pos));
+}
+
+template<typename T>
+bool pFlow::List<T>::search
+(
+	const T& val
+) const
+{
+	if( find(val) == this->end())return false;
+	return true;
+}
+
+
+template<typename T>
+inline void pFlow::List<T>::set(size_t i, const T& val)
+{
+	auto p = pos(i);
+	*p = val;
+}
+
+template<typename T>
+inline void pFlow::List<T>::set(size_t i, T&& val)
+{
+	auto p = pos(i);
+	*p = std::move(val);
+}
+
+
+template<typename T>
+inline bool pFlow::List<T>::writeList
+(
+	iOstream& os
+) const
+{
+	
+	size_t len = size();
+	size_t stride = getListStride(len);
+
+	// start of List
+	
+	os << beginListToken();
+	
+	for(auto elm = listType::begin(); elm!=listType::end(); )
+	{
+		os<< *elm++;
+		
+		for(size_t j=0; j<stride && elm!=listType::end(); j++)
+		{
+			os<<spaceToken()<< *elm++;
+		}
+
+		if( elm!=listType::end() )
+			os<<newLineToken();
+	}
+
+	os<< endListToken();
+
+    //os.check(FUNCTION_NAME);
+
+    return os.check(FUNCTION_NAME);
+}
+
+template<typename T>
+inline bool pFlow::List<T>::readList
+(
+	iIstream& is
+)
+{
+	// first clear the list
+	listType::clear();
+
+	is.fatalCheck(FUNCTION_NAME);
+
+	token firstToken(is);
+
+	if( firstToken.isPunctuation() ) // start of list 
+	{
+		if(firstToken != beginListToken() )
+		{
+			ioErrorInFile(is.name(), is.lineNumber())
+				<< "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);
+
+			T val;
+			is >> val;
+			
+			listType::push_back(val);
+			
+			is >> lastToken;
+			is.fatalCheck(FUNCTION_NAME);
+
+		}
+
+	}
+	else
+	{
+		ioErrorInFile(is.name(), is.lineNumber())
+				<< "expected token "<< beginListToken()
+				<< " but found "<< firstToken ;
+				return false;
+
+	}
+	
+	return is.fatalCheck(FUNCTION_NAME);
+
+}
+
+template<typename T>
+inline pFlow::iOstream& pFlow::operator << (iOstream& os, const List<T>& lst )
+{
+	if(!lst.writeList(os))
+	{
+		fatalExit;
+	}
+	return os;
+}
+
+template<typename T>
+inline pFlow::iIstream& pFlow::operator >>(iIstream& is, List<T>& lst)
+{
+	if( !lst.readList(is) )
+	{
+		fatalExit;
+	}
+	return is;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/List/ListPtr/ListPtr.H b/src/phasicFlow/containers/List/ListPtr/ListPtr.H
new file mode 100644
index 00000000..1987c026
--- /dev/null
+++ b/src/phasicFlow/containers/List/ListPtr/ListPtr.H
@@ -0,0 +1,197 @@
+/*------------------------------- 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 __ListPtr_H__
+#define __ListPtr_H__
+
+
+#include <list>
+
+
+#include "types.H"
+#include "uniquePtr.H"
+#include "error.H"
+#include "iOstream.H"
+
+
+namespace pFlow
+{
+
+template<typename  T >
+class ListPtr
+{
+public:
+
+	using ListPtrType 		= ListPtr<T> ; 
+	using listType 			= std::list<T*>;
+
+
+	template<typename... Args>
+    inline static uniquePtr<T> makeSafe(Args&&... args)
+    {
+    	return uniquePtr<T>(new T(std::forward<Args>(args)...));
+    }
+
+protected:
+
+	//// - data members
+
+		// - list of pointers 
+		std::list<T*>  	list_;
+
+	
+
+	//// - Methods
+
+		// - copy the content to this list
+		bool copy(const ListPtrType& src);
+
+		// - return ith pointer
+		T* ptr(label i);
+
+		// - return ith const poiter
+		const T* ptr(label i)const;
+
+		// - iterator position of ith element
+		auto pos(label i);
+		
+		// - const iterator position of ith element
+		auto pos(label i) const;
+
+public:
+
+	// - Type info
+	TypeNameTemplateNV("ListPtr", T);
+	
+	//// - Contructors 
+
+		// - empty list
+		ListPtr()
+		:
+			list_()
+		{}
+
+		// - a list with initial length of len
+		ListPtr(size_t len)
+		:
+			list_(len)
+		{}
+
+		// - copy construct, create new objects out of the pointers in the src 
+		ListPtr(const ListPtrType& src);
+		
+
+		//- copy assignment, create new objects out of he pointers in the src
+	    ListPtrType&  operator=(const ListPtrType& rhs);
+    
+
+	    // - move construct
+	    //   Simply move the pointers, so the new object takes the 
+	    //   ownership of the pointers. 
+	    ListPtr( ListPtrType&& src )
+	    :
+	    	list_(std::move(src))
+	    {}	
+
+	    // - move assignment
+	    // 	 the lhs object takes the ownership of pointers and rhs loses the ownership
+	    ListPtrType& operator=(ListPtrType&& rhs)
+	    {
+	    	// clears the content of this 
+	    	clear();
+
+	    	list_.operator=(std::move(rhs));
+	    	return *this;
+	    }
+
+	    ListPtrType* clonePtr()const
+		{
+			auto ptr = makeUnique<ListPtrType>(*this);
+			return ptr.release();
+		}
+
+		uniquePtr<ListPtrType> clone()const
+		{
+			return makeUnique<ListPtrType>(*this);
+		}
+
+	    // - remove /delete all the objectes associated with pointers
+	    ~ListPtr()
+		{
+			clear();
+		}
+
+	//// - Methods 
+
+		// - set the ith element 
+		T* set(label i, T* ptr);
+		
+		// - set the ith element and take the ownership from uniquePtr
+		uniquePtr<T> set(label 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);
+	    
+	    // - put the pointer at the end
+	    void push_back(T* ptr);
+	    
+	    // - put the pointer at the end
+	    void push_back(uniquePtr<T>& ptr);
+	    
+	    // - safely create (in-place) and put the pointer at the end
+	    template<typename... Args>
+	    void push_backSafe(Args&&... args);
+	    
+		// - access to ith element
+		//   fatalexit if out of range or nullptr    
+		T& operator[](label i);
+		
+		// - const access to ith element
+		//   fatalexit if out of range or nullptr    
+		const T& operator[](label i) const;
+
+		// size of container
+	    size_t size()const;
+	    
+	    // check if the container empty
+		auto empty() const;
+
+		// release the ownership of ith pointer 
+		uniquePtr<T> release(label i);
+		
+		// - clear the content of list and delete objects
+		void clear();
+		
+		// - clear the ith element
+		void clear(label i);	
+		
+		// - clone the object 
+		
+};
+
+
+} // pFlow
+
+
+#include "ListPtrI.H"
+
+#endif
diff --git a/src/phasicFlow/containers/List/ListPtr/ListPtrI.H b/src/phasicFlow/containers/List/ListPtr/ListPtrI.H
new file mode 100644
index 00000000..2d476154
--- /dev/null
+++ b/src/phasicFlow/containers/List/ListPtr/ListPtrI.H
@@ -0,0 +1,301 @@
+/*------------------------------- 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>
+inline bool pFlow::ListPtr<T>::copy(const ListPtrType& src)
+{
+	
+	for( auto& iter : src.list_)
+	{		
+
+		if( iter != nullptr)
+		{
+			push_back( iter->clone().release());
+		}
+		else
+		{
+			push_back(nullptr);
+		}
+	}
+
+	return true;
+}
+
+template<typename T>
+T* pFlow::ListPtr<T>::ptr(label i) 
+{
+
+	if(i >= size() ) return nullptr;	
+
+	auto iter = list_.begin();
+	std::advance(iter, i);
+
+	return *iter;
+}
+
+template<typename T>
+const T* pFlow::ListPtr<T>::ptr
+(
+	label i
+) const
+{
+
+	if(i >= size() ) return nullptr;	
+
+	auto iter = list_.cbegin();
+	std::advance(iter, i);
+
+	return *iter;
+}
+
+template<typename T>
+auto pFlow::ListPtr<T>::pos
+(
+	label i
+)
+{
+	if(i >= size() ) 
+	{
+		fatalErrorInFunction<< 
+		"out of range access to container element. \n";
+		fatalExit;
+	}
+
+	auto iter = list_.begin();
+	std::advance(iter, i);
+	return iter;
+}
+
+template<typename T>
+auto pFlow::ListPtr<T>::pos
+(
+	label i
+)const 
+{
+	if(i >= size() ) 
+	{
+		fatalErrorInFunction<< 
+		"out of range access to container element. \n";
+		fatalExit;
+	}
+
+	auto iter = list_.cbegin();
+	std::advance(iter, i);
+	return iter;
+}
+
+template<typename T>
+pFlow::ListPtr<T>::ListPtr
+(
+	const ListPtrType& src
+)
+{
+	
+	if( !copy(src) )
+	{
+		fatalErrorInFunction<<
+			"cannot copy new item into ListPtr \n" <<
+			"ListPtr type is "<< typeid(T).name() <<endl;
+			fatalExit;
+	}		
+}
+
+
+template<typename T>
+pFlow::ListPtr<T>& pFlow::ListPtr<T>::operator=
+(
+	const ListPtrType& rhs
+)
+{
+	if (this == &rhs)
+	{
+    	return *this;  // Self-assignment 
+	}
+
+	// clears the content of this 
+	clear();
+
+	if( !copy(rhs) )
+	{
+		fatalErrorInFunction<<
+			"cannot perform assignment from rhs into MapPtr \n" <<
+			"MapPtr type is "<< typeid(T).name() <<endl;
+			fatalExit;
+	}
+
+	return *this;
+}
+
+template<typename T>
+T* pFlow::ListPtr<T>::set
+(
+	label i, T* ptr
+)
+{
+	uniquePtr<T> uptr(ptr);
+	return set(i, uptr);
+}
+
+
+template<typename T>
+pFlow::uniquePtr<T> pFlow::ListPtr<T>::set
+(
+	label i,
+	uniquePtr<T>& ptr
+)
+{
+	if( i > size() )
+	{
+		fatalErrorInFunction<<
+		"Out of range access of list members. PtrList size is "<<
+		size() << "and you are accessing "<< i << "\n";
+		fatalExit;
+	}
+
+	auto iter = list_.begin();
+	std::advance(iter, i);
+	auto oldIter = iter;
+	*iter = ptr.release();
+	return *oldIter;
+
+}
+
+
+template<typename T>
+template<typename... Args>
+pFlow::uniquePtr<T> pFlow::ListPtr<T>::setSafe
+(
+	label i,
+	Args&&... args
+)
+{
+	auto ptr(uniquePtr<T>::makeUnique(std::forward<Args>(args)...) );
+	return set(i,ptr);	
+}
+
+template<typename T>
+void pFlow::ListPtr<T>::push_back
+(
+	T* ptr
+)
+{
+	list_.push_back(ptr);
+}
+
+template<typename T>
+void pFlow::ListPtr<T>::push_back(uniquePtr<T>& ptr)
+{
+	list_.push_back( ptr.release() );
+}
+
+template<typename T>
+template<typename... Args>
+void pFlow::ListPtr<T>::push_backSafe(Args&&... args)
+{
+	auto ptr=makeUnique<T>(std::forward<Args>(args)...) ;
+	push_back(ptr);
+}
+
+template<typename T>
+T& pFlow::ListPtr<T>::operator[]
+(
+	label i
+)
+{
+	T* p = ptr(i);
+
+	if( !p )
+	{
+		fatalErrorInFunction<<
+		"trying to reach the reference of a nullptr or out of range access. \n";
+		fatalExit;
+	}
+
+	return *p;
+}
+
+template<typename T>
+const T& pFlow::ListPtr<T>::operator[]
+(
+	label i
+) const
+{
+	const T* p = ptr(i);
+
+	if(!p)
+	{
+		fatalErrorInFunction<<
+		"trying to reach the reference of a nullptr or out of range access. \n";
+		fatalExit;
+	}
+	return *p;
+}
+
+template<typename T>
+size_t pFlow::ListPtr<T>::size()const
+{
+	return list_.size();
+}
+
+template<typename T>
+auto pFlow::ListPtr<T>::empty() const
+{
+	return list_.emtpy();
+}
+
+template<typename T>
+pFlow::uniquePtr<T> pFlow::ListPtr<T>::release
+(
+	label i
+)
+{
+	auto p = ptr(i);
+	list_.erase(pos(i));
+	return p;
+}
+
+template<typename T>
+void pFlow::ListPtr<T>::clear()
+{
+	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
+)
+{
+	T* p = ptr(i);
+
+	if( p )
+	{
+		delete p;
+		list_.erase(pos(i));
+	}
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/List/Lists.H b/src/phasicFlow/containers/List/Lists.H
new file mode 100644
index 00000000..cdf72ca3
--- /dev/null
+++ b/src/phasicFlow/containers/List/Lists.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#ifndef __Lists_H__
+#define __Lists_H__
+
+
+#include "List.H"
+
+
+#include "ListPtr.H"
+
+
+
+
+
+#endif //__Lists_H__
diff --git a/src/phasicFlow/containers/Map/Map/Map.H b/src/phasicFlow/containers/Map/Map/Map.H
new file mode 100644
index 00000000..80294558
--- /dev/null
+++ b/src/phasicFlow/containers/Map/Map/Map.H
@@ -0,0 +1,174 @@
+/*------------------------------- 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 __Map_H__
+#define __Map_H__
+
+
+#include <map>
+
+#include "types.H"
+#include "iOstream.H"
+
+
+namespace pFlow
+{
+
+template<class Key, class T, class Compare = std::less<Key> >
+class Map
+:
+	public std::map<Key, T, Compare>
+{
+public:
+
+	using MapType 		= Map<Key, T, Compare>;
+	
+	using mapType 		= std::map<Key, T, Compare>;
+
+	using iterator 		= typename mapType::iterator;
+	
+	using constIterator = typename mapType::const_iterator;
+	
+	using reference 	= typename mapType::reference;
+	
+	using constReference= typename mapType::const_reference;
+	
+	using initList 		= typename std::initializer_list<T>;
+	
+	using keyType 		= typename mapType::key_type;
+	
+	using mappedType 	= typename mapType::mapped_type;
+	
+	using valueType 	= typename mapType::value_type;
+
+	// - type info 
+	TypeNameTemplateNV("Map", Key);
+
+	//// - Constructors
+
+		// Empty Map
+		Map()
+		{}
+
+		// - with initList
+		Map(initList lst)
+		:
+			mapType(lst)
+		{}
+
+		// - Copy construct
+		Map(const MapType & src)
+		:
+			mapType(src)
+		{}
+
+		// - Move construct 
+		Map( MapType&& src)
+		:
+			mapType(std::move(src))
+		{}
+
+		// - Copy assignment
+		MapType& operator=(const MapType& rhs)
+		{
+			mapType::operator=(rhs);
+			return *this;
+		}
+
+		// - Move assignment
+		MapType& operator=(MapType&& rhs)
+		{
+			mapType::operator=( std::move(rhs));
+			return *this;
+		}	
+
+		uniquePtr<MapType> clone()const
+		{
+			return makeUnique<MapType>(*this);
+		}
+
+		MapType* clonePtr()const
+		{
+			return new MapType(*this);
+		}
+
+		~Map()
+		{
+			this->clear();
+		}
+
+
+	//// - Methods		
+
+		// Insert an item with copy operation
+		bool insertIf(const keyType& k, const mappedType & v);
+		
+		// insert an item with move operation 
+		bool insertIf( keyType&& k, mappedType && v);
+
+		// search for a key
+		bool search(const keyType k) const;
+		
+		std::pair<iterator, bool> findIf(const keyType& k);
+		
+		const std::pair<constIterator, bool> findIf(const keyType& k) const;
+	
+};
+
+
+template<typename T>
+using wordMap = Map<word,T>;
+
+template<typename T>
+using labelMap = Map<label,T>;
+
+template<typename T>
+using uint32Map = Map<uint32,T>;
+
+template<typename T>
+using int32Map = Map<int32,T>;
+
+template<typename T>
+using int64Map = Map<int64,T>;
+
+
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const wordMap<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const labelMap<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const uint32Map<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int32Map<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int64Map<T> & m);
+
+
+#include "MapI.H"
+
+} // pFlow
+
+#endif
diff --git a/src/phasicFlow/containers/Map/Map/MapI.H b/src/phasicFlow/containers/Map/Map/MapI.H
new file mode 100644
index 00000000..7d52ea7e
--- /dev/null
+++ b/src/phasicFlow/containers/Map/Map/MapI.H
@@ -0,0 +1,134 @@
+/*------------------------------- 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 Key, class T, class Compare >
+bool pFlow::Map<Key, T, Compare>::insertIf(const keyType& k, const mappedType & v)
+{
+	auto [iter, success] = this->insert( valueType(k,v));
+	return success;
+}
+
+template<class Key, class T, class Compare >
+bool pFlow::Map<Key, T, Compare>::insertIf( keyType&& k, mappedType && v)
+{
+	auto [iter, success] = this->insert
+									( 
+										std::move( valueType(k,v) )
+									);
+	return success;
+}
+
+template<class Key, class T, class Compare >
+bool pFlow::Map<Key, T, Compare>::search(const keyType k) const
+{
+	auto [iter, found] = findIf(k);
+	return found;
+}
+
+template<class Key, class T, class Compare >
+std::pair<typename pFlow::Map<Key, T, Compare>::iterator, bool> pFlow::Map<Key, T, Compare>::findIf(const keyType& k)
+{	
+	if( auto iter = this->find(k); iter!= this->end() )
+		return {iter,true};
+	else
+		return {iter,false};
+}
+
+template<class Key, class T, class Compare >
+const std::pair<typename pFlow::Map<Key, T, Compare>::constIterator, bool> pFlow::Map<Key, T, Compare>::findIf(const keyType& k) const
+{
+	if( auto iter = this->find(k); iter!= this->end() )
+		return {iter,true};
+	else
+		return {iter,false};
+}
+
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const wordMap<T> & m)
+{
+	if (m.empty())
+		return os<<"wordMap is empty"<<endl;
+
+	for(auto& iter : m)
+	{
+		os << iter.first<<endl;
+	}
+
+	return os;
+}
+
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const uint32Map<T> & m)
+{
+	if (m.empty())
+		return os<<"uint32Map is empty"<<endl;
+
+	for(auto& iter : m)
+	{
+		os << iter.first<<endl;
+	}
+
+	return os;
+}
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const labelMap<T> & m)
+{
+	if (m.empty())
+		return os<<"labelMap is empty"<<endl;
+
+	for(auto& iter : m)
+	{
+		os << iter.first<<endl;
+	}
+
+	return os;
+}
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int32Map<T> & m)
+{
+	if (m.empty())
+		return os<<"int32Map is empty"<<endl;
+
+	for(auto& iter : m )
+	{
+		os << iter.first<<endl;
+	}
+
+	return os;
+}
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int64Map<T> & m)
+{
+	if (m.empty())
+		return os<<"int64Map is empty"<<endl;
+
+	for(auto& iter : m )
+	{
+		os << iter.first<<endl;
+	}
+
+	return os;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Map/MapPtr/MapPtr.H b/src/phasicFlow/containers/Map/MapPtr/MapPtr.H
new file mode 100644
index 00000000..919fa8f3
--- /dev/null
+++ b/src/phasicFlow/containers/Map/MapPtr/MapPtr.H
@@ -0,0 +1,274 @@
+
+/*------------------------------- 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 __MapPtr_H__
+#define __MapPtr_H__
+
+
+#include <typeinfo>
+#include <map>
+#include <unordered_map>
+
+#include "types.H"
+#include "uniquePtr.H"
+#include "error.H"
+#include "iOstream.H"
+
+
+namespace pFlow
+{
+
+template< template<class, class> class Container, class Key, class T >
+class MapPtr
+
+{
+public:
+
+	using MapPtrType 		= MapPtr<Container, Key, T>; 
+	
+	using mapType 			= Container<Key, T*>;
+
+	using keyType 			= typename mapType::key_type;
+	
+	using mappedType 		= typename mapType::mapped_type;
+	
+	using valueType 		= typename mapType::value_type;
+	
+	using reference 		= typename mapType::reference;
+	
+	using constReference 	= typename mapType::const_reference;
+	
+	using iterator 			= typename mapType::iterator;
+	
+	using constIterator 	= typename mapType::const_iterator;
+	
+	template<typename... Args>
+    inline static uniquePtr<T> makeSafe(Args&&... args)
+    {
+    	return std::make_unique(std::forward<Args>(args)...);
+    }
+
+protected:
+
+	// data members
+	Container<Key, T*>  map_;
+
+	
+
+	// Methods
+	bool copy(const MapPtrType& src);
+
+	// - find a key and return the the pointer associated with the key
+	//   nullptr if fails
+	T* findPtr(const keyType& k);
+
+	const T* findPtr(const keyType& k)const ;
+	
+public:
+
+	// - type info
+	TypeNameTemplateNV("MapPtr", Key);
+
+	//// Contructors 
+	
+		// - empty map
+		MapPtr()
+		:
+			map_()
+		{}
+
+		// - copy construct, create new objects out of the objects in the src 
+		MapPtr(const MapPtrType& src);
+		
+
+		// - copy assignment, create new objects out of he pointers in the src
+	    MapPtrType&  operator=(const MapPtrType& rhs);
+	    
+
+	    // move construct
+	    // it just simply move the pointers, so the new objects takes the 
+	    // ownership of the pointers. 
+	    MapPtr( MapPtrType&& src );
+	    
+
+	    // move assignment
+	    // the lhs object takes the ownership of the new objects and rhs loses the ownership
+	    MapPtrType& operator=(MapPtrType&& rhs);
+	    
+	    // removes /deletes all the objectes associated with pointers
+
+	    uniquePtr<MapPtrType> clone()const
+	    {
+	    	return makeUnique<MapPtrType>(*this);
+	    }
+
+	    MapPtrType* clonePtr()const
+	    {
+	    	return new MapPtrType(*this);
+	    }
+
+	    ~MapPtr()
+		{
+			clear();
+		}
+
+	//// - Methods
+
+		// - insert the object with key and replace if it already exists in the container
+		//   return false if fails to insert, no action is taken for object deletion 
+		bool insertReplace(const keyType& key, T* ptr);
+
+		// - insert the object with key and replace if it already exists in the container
+		//   return false if fail to insert, no action is taken for object deletion  
+		bool insertReplace(const keyType& key, uniquePtr<T>& ptr);
+
+		// - insert the object (construct in-place)
+		//   return false if fail to insert, the object is deleted by default if fails
+		template<typename... Args>
+		bool insertReplaceSafe(const keyType& key, Args&&... args);
+
+		// - insert the object if key is new and return nullptr
+		// - if key exist, replace the new object and return the pointer to the old object 
+		T* set(const keyType& key, T* ptr);
+
+		// - insert the object if key is new and return nullptr
+		// - if key exist, replace the new object and return the pointer to the old object 
+		uniquePtr<T> set(const keyType& key, uniquePtr<T>& ptr );
+
+		// - insert the object (construct in-place), if key is new and return nullptr
+		// - if key exist, replace the new object and return the pointer to the old object 
+		template<typename... Args>
+		uniquePtr<T> setSafe(const keyType& key, Args&&... args);		
+
+		// - reference to the object found by key
+		//   fatalError if not found
+		T& operator[] (const keyType& key);
+		
+		// - const reference to the object found by key
+		//   fatalError if not found
+		const T& operator[]	(const keyType& key)const;
+
+		// - search if a key exists
+	    bool search(const keyType k) const;
+	
+
+		// - find a key and return the const pointer if successful
+		std::pair<const T*, bool> find(const keyType& k)const;
+	
+		// - find a key and return the pointer if successful
+		std::pair<T*, bool> find(const keyType& k);
+		
+
+		// - find the key and release the ownership of the object associated with it
+		//   delete the key after release
+		uniquePtr<T> release(const keyType& k);
+
+	    // - erase the element and delete the object if it is allocated
+	    void erase( const keyType& key );
+	    
+	    // - clear the content of the map with object deletion 
+		void clear();
+	
+		// - size of container
+		size_t size() const
+		{
+			return map_.size();
+		}
+
+		// - check if the container empty
+		auto empty() const
+		{
+			return map_.emtpy();
+		}
+
+		// - iterators 
+		iterator begin()
+		{
+			return map_.begin();
+		}
+
+		constIterator begin() const
+		{
+			return map_.begin();
+		}
+
+		iterator end()
+		{
+			return map_.end();
+		}
+
+		constIterator end() const
+		{
+			return map_.end();
+		}
+
+};
+
+// ordered (sorted) map 
+template<typename key, typename T>
+using orderedMapPtr = MapPtr<std::map, key, T>;
+
+// unordered map (hash) map pointer
+template<typename key, typename T>
+using hashMapPtr = MapPtr<std::unordered_map , key, T>;
+
+template<typename T>
+using wordOrderedMapPtr = orderedMapPtr<word,T>;
+
+template<typename T>
+using wordHashMapPtr = hashMapPtr<word,T>;
+
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const wordHashMapPtr<T> & m)
+{
+	if (m.empty())
+		return os<<"wordHashMapPtr is empty"<<endl;
+
+	for(const auto iter : m )
+	{
+		os << iter->first<<endl;
+	}
+
+	return os;
+}
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const wordOrderedMapPtr<T> & m)
+{
+	if (m.empty())
+		return os<<"wordOrderedMapPtr is empty"<<endl;
+
+	for(const auto iter : m )
+	{
+		os << iter->first<<endl;
+	}
+
+	return os;
+}
+
+
+} // pFlow
+
+
+#include "MapPtrI.H"
+
+#endif
diff --git a/src/phasicFlow/containers/Map/MapPtr/MapPtrI.H b/src/phasicFlow/containers/Map/MapPtr/MapPtrI.H
new file mode 100644
index 00000000..3da2c7fd
--- /dev/null
+++ b/src/phasicFlow/containers/Map/MapPtr/MapPtrI.H
@@ -0,0 +1,333 @@
+/*------------------------------- 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< template<class, class> class Container, class Key, class T >
+bool pFlow::MapPtr<Container, Key, T>::copy
+(
+	const MapPtrType& src
+)
+{
+	for(constIterator iter= src.begin(); iter != src.end(); ++iter)
+	{
+
+		// first make sure that the new key can be inserted
+		auto [nIter, suc] = map_.insert(valueType(iter->first, nullptr));
+
+		// then insert the new item
+		if( suc ) 
+		{
+			if(iter->second != nullptr)
+				map_[iter->first] = iter->second->clonePtr();
+
+		}
+		else
+		{
+			return false;
+		}
+
+	}
+
+	return true;
+}
+
+template< template<class, class> class Container, class Key, class T >
+T* pFlow::MapPtr<Container, Key, T>::findPtr
+(
+	const keyType& k
+)
+{	
+	if( auto iter = map_.find(k); iter!= map_.end() )
+		return iter->second;
+	else
+		return nullptr;
+}
+
+template< template<class, class> class Container, class Key, class T >
+const T* pFlow::MapPtr<Container, Key, T>::findPtr
+(
+	const keyType& k
+)const 
+{	
+	if( auto iter = map_.find(k); iter!= map_.cend() )
+		return iter->second;
+	else
+		return nullptr;
+}
+
+template< template<class, class> class Container, class Key, class T >
+pFlow::MapPtr<Container, Key, T>::MapPtr
+(
+	const MapPtrType& src
+)
+{
+	
+	if( !copy(src) )
+	{
+		fatalErrorInFunction<<
+			"cannot copy new item into MapPtr \n" <<
+			"MapPtr type is "<< typeid(T).name() <<endl;
+			fatalExit;
+	}		
+}
+
+template< template<class, class> class Container, class Key, class T >
+pFlow::MapPtr<Container, Key, T>&  pFlow::MapPtr<Container, Key, T>::operator=
+(
+	const MapPtrType& rhs
+)
+{
+	if (this == &rhs)
+	{
+    	return *this;  // Self-assignment 
+	}
+
+	// clears the content of this 
+	clear();
+
+	if( !copy(rhs) )
+	{
+		fatalErrorInFunction<<
+			"cannot perform assignment from rhs into MapPtr \n" <<
+			"MapPtr type is "<< typeid(T).name() <<endl;
+			fatalExit;
+	}
+
+	return *this;
+
+}
+
+template< template<class, class> class Container, class Key, class T >
+pFlow::MapPtr<Container, Key, T>::MapPtr
+(
+	MapPtrType&& src
+)
+:
+	map_(std::move(src))
+{}	
+
+template< template<class, class> class Container, class Key, class T >
+pFlow::MapPtr<Container, Key, T>&  pFlow::MapPtr<Container, Key, T>::operator=
+(
+	MapPtrType&& rhs
+)
+{
+	// clears the content of this 
+	clear();
+
+	map_.operator=(std::move(rhs));
+	return *this;
+}
+
+
+template< template<class, class> class Container, class Key, class T >
+bool pFlow::MapPtr<Container, Key, T>::insertReplace
+(
+	const keyType& key,
+	T* ptr
+)
+{
+	// delete the current key if it exists
+    erase(key);
+    
+    auto [iter, success] = map_.insert( valueType(key,ptr));
+     
+	return success;
+}
+
+template< template<class, class> class Container, class Key, class T >
+bool pFlow::MapPtr<Container, Key, T>::insertReplace
+(
+	const keyType& key,
+	uniquePtr<T>& ptr
+)
+{
+	erase(key);
+	if(auto [iter, success] = map_.insert(valueType(key, nullptr)); success)
+	{
+		map_[key] = ptr.release();
+		return true;
+	}
+
+	return false;
+}
+	
+template< template<class, class> class Container, class Key, class T >
+template<typename... Args>
+bool pFlow::MapPtr<Container, Key, T>::insertReplaceSafe
+(
+	const keyType& key,
+	Args&&... args
+)
+{
+	auto ptr = makeUnique<T>(std::forward<Args>(args)...);
+	return insertReplace(key, ptr);
+}
+
+
+template< template<class, class> class Container, class Key, class T >
+T* pFlow::MapPtr<Container, Key, T>::set
+(
+	const keyType& key,
+	T* ptr
+)
+{
+
+	auto [optr, exist] = find(key); 
+	map_[key] = ptr;
+	return optr;
+}
+
+template< template<class, class> class Container, class Key, class T >		
+pFlow::uniquePtr<T> pFlow::MapPtr<Container, Key, T>::set
+(
+	const keyType& key,
+	uniquePtr<T>& ptr)
+{
+
+	auto[optr,exist] = find(key);
+	map_[key] = ptr.release();
+	return optr;
+	
+}
+
+template< template<class, class> class Container, class Key, class T >
+template<typename... Args>
+pFlow::uniquePtr<T> pFlow::MapPtr<Container, Key, T>::setSafe
+(
+	const keyType& key, Args&&... args
+)
+{
+	auto ptr = makeUnique<T>(std::forward<Args>(args)...);
+	return set(key, ptr);
+}
+
+
+template< template<class, class> class Container, class Key, class T >
+T& pFlow::MapPtr<Container, Key, T>::operator[]
+(
+	const keyType& key
+)
+{
+	T* p = findPtr(key);
+	if( !p )
+	{
+		fatalErrorInFunction<<
+		"trying to reach the reference of a nullptr or out of range access the element with key "
+		<<key<<endl;
+		fatalExit;
+	}
+	return *p;
+}
+
+template< template<class, class> class Container, class Key, class T >
+const T& pFlow::MapPtr<Container, Key, T>::operator[]
+(
+	const keyType& key
+)const
+{
+	const T* p = findPtr(key);
+	if( !p )
+	{
+		fatalErrorInFunction<<
+		"trying to reach the reference of a nullptr or out of range access the element with key "
+		<<key<<endl;
+		fatalExit;
+	}
+
+	return *p;
+}
+
+template< template<class, class> class Container, class Key, class T >
+bool pFlow::MapPtr<Container, Key, T>::search
+(
+	const keyType k
+) const
+{
+	auto [iter, found] = find(k);
+	return found;
+}
+
+
+template< template<class, class> class Container, class Key, class T >
+std::pair<const T*, bool> pFlow::MapPtr<Container, Key, T>::find
+(
+	const keyType& k
+)const
+{	
+	if( auto iter = map_.find(k); iter!= map_.end() )
+		return {iter->second,true};
+	else
+		return {nullptr,false};
+}
+
+
+template< template<class, class> class Container, class Key, class T >
+std::pair<T*, bool> pFlow::MapPtr<Container, Key, T>::find(const keyType& k)
+{	
+	if( auto iter = map_.find(k); iter!= map_.end() )
+		return {iter->second,true};
+	else
+		return {nullptr,false};
+}
+
+
+template< template<class, class> class Container, class Key, class T >
+pFlow::uniquePtr<T> pFlow::MapPtr<Container, Key, T>::release
+(
+	const keyType& key
+)
+{
+	auto p = findPtr(key);
+	map_.erase(key);
+	return p;
+}
+
+
+template< template<class, class> class Container, class Key, class T >
+void pFlow::MapPtr<Container, Key, T>::erase
+(
+	const keyType& key
+)
+{
+	if( auto ptr = findPtr(key); ptr )
+	{
+		delete ptr;
+		ptr = nullptr;	
+	}
+
+	map_.erase(key);
+}
+
+template< template<class, class> class Container, class Key, class T >
+void pFlow::MapPtr<Container, Key, T>::clear()
+{
+	for( auto iter = map_.begin(); iter != map_.end(); ++iter )
+	{
+		if(iter->second != nullptr)
+		{
+			delete iter->second;
+			iter->second = nullptr;
+		}
+	}
+	map_.clear();
+}
+
+	
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Map/Maps.H b/src/phasicFlow/containers/Map/Maps.H
new file mode 100644
index 00000000..c1a974e4
--- /dev/null
+++ b/src/phasicFlow/containers/Map/Maps.H
@@ -0,0 +1,30 @@
+/*------------------------------- 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 __Maps_H__
+#define __Maps_H__
+
+#include "Map.H"
+#include "hashMap.H"
+#include "MapPtr.H"
+
+
+#endif
diff --git a/src/phasicFlow/containers/Map/hashMap/hashMap.H b/src/phasicFlow/containers/Map/hashMap/hashMap.H
new file mode 100644
index 00000000..28c00a5f
--- /dev/null
+++ b/src/phasicFlow/containers/Map/hashMap/hashMap.H
@@ -0,0 +1,174 @@
+/*------------------------------- 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 __hashMap_H__
+#define __hashMap_H__
+
+#include <unordered_map>
+
+#include "types.H"
+#include "typeInfo.H"
+#include "iOstream.H"
+
+
+namespace pFlow
+{
+
+template<class Key, class T,  class Hash = std::hash<Key> >
+class hashMap
+:
+	public std::unordered_map<Key, T, Hash>
+{
+public:
+
+	using hashMapType 	= hashMap<Key, T, Hash>;
+	
+	using hashmapType 	= std::unordered_map<Key, T, Hash>;
+
+	using iterator 		= typename hashmapType::iterator;
+	
+	using constIterator = typename hashmapType::const_iterator;
+	
+	using reference 	= typename hashmapType::reference;
+	
+	using constReference= typename hashmapType::const_reference ;
+	
+	using initList 		= typename std::initializer_list<T>;
+	
+	using keyType 		= typename hashmapType::key_type;
+	
+	using mappedType 	= typename hashmapType::mapped_type;
+	
+	using valueType 	= typename hashmapType::value_type;
+
+	
+	TypeNameTemplateNV("hashMap", Key);
+
+	//// - Constructors
+
+		// Empty hashMap
+		hashMap()
+		{}
+
+		// - with initList
+		hashMap(initList lst)
+		:
+			hashmapType(lst)
+		{}
+
+		// - Copy construct
+		hashMap(const hashMapType & src)
+		:
+			hashmapType(src)
+		{}
+
+		// - Move construct 
+		hashMap( hashMapType&& src)
+		:
+			hashmapType(std::move(src))
+		{}
+
+		// - Copy assignment
+		hashMapType& operator=(const hashMapType& rhs)
+		{
+			hashmapType::operator=(rhs);
+			return *this;
+		}
+
+		// - Move assignment
+		hashMapType& operator=(hashMapType&& rhs)
+		{
+			hashmapType::operator=( std::move(rhs));
+			return *this;
+		}
+
+		uniquePtr<hashMapType> clone()const
+		{
+			return makeUnique<hashMapType>(*this);
+		}
+
+		hashMapType* clonePtr()const
+		{
+			return new hashMapType(*this);
+		}	
+
+		~hashMap()
+		{
+			this->clear();
+		}
+
+
+	//// - Methods	
+
+		// Insert an item with copy operation
+		bool insertIf(const keyType& k, const mappedType & v);
+		
+		// insert an item with move operation 
+		bool insertIf( keyType&& k, mappedType && v);
+
+		// search for a key
+		bool search(const keyType k) const;
+		
+
+		std::pair<iterator, bool> findIf(const keyType& k);
+		
+
+		const std::pair<constIterator, bool> findIf(const keyType& k) const;
+	
+};
+
+
+template<typename T>
+using wordHashMap = hashMap<word,T>;
+
+template<typename T>
+using labelHashMap = hashMap<label,T>;
+
+template<typename T>
+using uint32HashMap = hashMap<uint32,T>;
+
+template<typename T>
+using int64HashMap = hashMap<int64,T>;
+
+template<typename T>
+using int32HashMap = hashMap<int32,T>;
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const wordHashMap<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const labelHashMap<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const uint32HashMap<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int64HashMap<T> & m);
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int32HashMap<T> & m);
+
+
+#include "hashMapI.H"
+
+} // pFlow
+
+#endif
diff --git a/src/phasicFlow/containers/Map/hashMap/hashMapI.H b/src/phasicFlow/containers/Map/hashMap/hashMapI.H
new file mode 100644
index 00000000..74e85e6d
--- /dev/null
+++ b/src/phasicFlow/containers/Map/hashMap/hashMapI.H
@@ -0,0 +1,137 @@
+/*------------------------------- 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 Key, class T, class Compare >
+bool pFlow::hashMap<Key, T, Compare>::insertIf(const keyType& k, const mappedType & v)
+{
+	auto [iter, success] = this->insert( valueType(k,v));
+	return success;
+}
+
+template<class Key, class T, class Compare >
+bool pFlow::hashMap<Key, T, Compare>::insertIf( keyType&& k, mappedType && v)
+{
+	auto [iter, success] = this->insert
+									( 
+										std::move( valueType(k,v) )
+									);
+	return success;
+}
+
+template<class Key, class T, class Compare >
+bool pFlow::hashMap<Key, T, Compare>::search(const keyType k) const
+{
+	auto [iter, found] = findIf(k);
+	return found;
+}
+
+template<class Key, class T, class Compare >
+std::pair<typename pFlow::hashMap<Key, T, Compare>::iterator, bool>
+	pFlow::hashMap<Key, T, Compare>::findIf(const keyType& k)
+{	
+	if( auto iter = this->find(k); iter!= this->end() )
+		return {iter,true};
+	else
+		return {iter,false};
+}
+
+template<class Key, class T, class Compare >
+const std::pair<typename pFlow::hashMap<Key, T, Compare>::constIterator, bool> 
+	pFlow::hashMap<Key, T, Compare>::findIf(const keyType& k) const
+{
+	if( auto iter = this->find(k); iter!= this->end() )
+		return {iter,true};
+	else
+		return {iter,false};
+}
+
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const wordHashMap<T> & m)
+{
+	if (m.empty())
+		return os<<"wordHashMap is empty"<<endl;
+
+	for(auto iter = m.cbegin(); iter != m.cend(); iter++ )
+	{
+		os << iter->first<<endl;
+	}
+
+	return os;
+}
+
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const labelHashMap<T> & m)
+{
+	if (m.empty())
+		return os<<"labelHashMap is empty"<<endl;
+
+	for(auto iter : m )
+	{
+		os << iter->first<<endl;
+	}
+
+	return os;
+}
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const uint32HashMap<T> & m)
+{
+	if (m.empty())
+		return os<<"uint32HashMap is empty"<<endl;
+
+	for(auto iter : m )
+	{
+		os << iter->first<<endl;
+	}
+
+	return os;
+}
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int64HashMap<T> & m)
+{
+	if (m.empty())
+		return os<<"int64HashMap is empty"<<endl;
+
+	for(auto iter : m )
+	{
+		os << iter->first<<endl;
+	}
+
+	return os;
+}
+
+
+template<typename T>
+inline iOstream& printKeys(iOstream& os, const int32HashMap<T> & m)
+{
+	if (m.empty())
+		return os<<"int32HashMap is empty"<<endl;
+
+	for(auto iter : m )
+	{
+		os << iter->first<<endl;
+	}
+
+	return os;
+}
diff --git a/src/phasicFlow/containers/Set/Set.H b/src/phasicFlow/containers/Set/Set.H
new file mode 100644
index 00000000..c235d814
--- /dev/null
+++ b/src/phasicFlow/containers/Set/Set.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef __Set_H__
+#define __Set_H__
+
+#include <set>
+
+namespace pFlow
+{
+
+
+template<typename Key>
+using Set = std::set<Key,std::less<Key>,std::allocator<Key>>;
+
+}
+
+#endif 
diff --git a/src/phasicFlow/containers/Vector/Vector.C b/src/phasicFlow/containers/Vector/Vector.C
new file mode 100644
index 00000000..808a399e
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/Vector.C
@@ -0,0 +1,352 @@
+/*------------------------------- 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 Allocator>
+pFlow::Vector<T, Allocator>::Vector(iIstream& is)
+{
+	readVector(is);
+}
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::readVector
+(
+	iIstream& is
+)
+{
+	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;
+}
+
+#include "streams.H"
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::writeVector
+(
+	iOstream& os
+) const
+{
+
+	
+	auto len = size();
+	auto stride  = getVectorStride(len);
+
+	// start of 
+	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>
+bool pFlow::Vector<T, Allocator>::deleteElement_sorted
+(
+	const Vector<label>& indices
+)
+{
+	if( indices.size() == 0 )return true;
+
+	if( indices.size() == 1 )
+	{
+		return deleteElement(indices[0]);
+	}
+
+	if( *(indices.end()-1) >= size() ) return false;
+	
+
+	VectorType tmp(capacity(), RESERVE());
+	tmp.clear();
+
+	label lindex = 0;
+	for(auto& delem: indices)
+	{
+		for(label i=lindex; i<delem; i++)
+		{
+			tmp.push_back( vectorType::operator[](i) );
+		}
+		lindex = delem+1;
+	}
+
+	// copy after the last delete element 
+	for(label i=lindex; i<size(); i++)
+	{
+		tmp.push_back( vectorType::operator[](i) );
+	}
+	
+
+	vectorType::swap(tmp);
+
+	return true;
+}
+
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::deleteElement
+(
+	const Vector<label>& indices
+)
+{
+	if( indices.size() == 0 )return true;
+
+	if( indices.size() == 1)
+	{
+		return deleteElement(indices[0]);
+	}
+
+	// sorts 
+	auto sorted = indices;
+	sort(sorted);
+	return deleteElement_sorted(sorted);
+}
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::deleteElement
+(
+	label index
+)
+{
+	if(index < size())
+	{
+		auto iter = vectorType::begin();
+		advance(iter, index);
+		vectorType::erase(iter);
+		return true;
+	}
+	else
+		return false;
+}
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::insertSetElement(
+	const  int32IndexContainer& indices,
+	const T& val)
+{
+	
+	if(indices.size() == 0)return true;
+	
+	auto hIndices = indices.hostView();
+
+	forAll(i, indices)
+	{
+		auto s = size();
+		auto idx = hIndices[i];
+
+		if( idx < s )
+		{
+			this->operator[](idx) = val;
+		}
+		else if(idx == s )
+		{	
+			this->push_back(val);
+		} 
+		else
+		{
+			this->resize(idx+1);
+			this->operator[](idx) = val;
+		}
+	}
+	return true;
+}
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::insertSetElement(
+	const  int32IndexContainer& indices,
+	const Vector<T>& vals)
+{
+	if(indices.size() == 0)return true;
+	if(indices.size() != vals.size())return false;
+
+	auto hIndices = indices.hostView();
+	
+	forAll(i, indices)
+	{
+		auto s = size();
+		auto idx = hIndices[i];
+		if( idx < s )
+		{
+			this->operator[](idx) = vals[i];
+		}
+		else if(idx == s )
+		{	
+			this->push_back(vals[i]);
+		} 
+		else
+		{
+			this->resize(idx+1);
+			this->operator[](idx) = vals[i];
+		}
+	}
+	return true;
+
+}
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::insertSetElement
+(
+	const Vector<int32>& indices,
+	const T& val
+)
+{
+	if(indices.size() == 0)return true;
+	
+	forAll(i, indices)
+	{
+		auto s = size();
+		auto idx = indices[i];
+		if( idx < s )
+		{
+			this->operator[](idx) = val;
+		}
+		else if(idx == s )
+		{	
+			this->push_back(val);
+		} 
+		else
+		{
+			this->resize(idx+1);
+			this->operator[](idx) = val;
+		}
+	}
+	return true;
+}
+
+
+template<typename T, typename Allocator>
+bool pFlow::Vector<T, Allocator>::insertSetElement
+(
+	const Vector<int32>& indices,
+	const Vector<T>& vals
+)
+{
+	if(indices.size() == 0)return true;
+	if(indices.size() != vals.size())return false;
+
+	forAll(i, indices)
+	{
+		auto s = size();
+		auto idx = indices[i];
+		if( idx < s )
+		{
+			this->operator[](idx) = vals[i];
+		}
+		else if(idx == s )
+		{	
+			this->push_back(vals[i]);
+		} 
+		else
+		{
+			this->resize(idx+1);
+			this->operator[](idx) = vals[i];
+		}
+	}
+	return true;
+}
+
+template<typename T, typename Allocator>
+inline bool pFlow::Vector<T, Allocator>::insertSetElement
+(
+	int32 idx,
+	const T & val
+)
+{
+	
+	auto s = size();
+	
+	if( idx < s )
+	{
+		this->operator[](idx) = val;
+	}
+	else if(idx == s)
+	{	
+		this->push_back(val);
+	} 
+	else
+	{
+		this->resize(idx+1);
+		this->operator[](idx) = val;
+	}
+	
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Vector/Vector.H b/src/phasicFlow/containers/Vector/Vector.H
new file mode 100644
index 00000000..de7a8360
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/Vector.H
@@ -0,0 +1,425 @@
+/*------------------------------- 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 __Vector_H__
+#define __Vector_H__
+
+#include <vector>
+#include <algorithm>
+
+#include "typeInfo.H"
+#include "error.H"
+#include "uniquePtr.H"
+#include "stdAlgorithms.H"
+#include "indexContainer.H"
+#include "iOstream.H"
+#include "iIstream.H"
+
+#ifndef __RESERVE__
+#define __RESERVE__
+	struct RESERVE{};
+#endif
+
+namespace pFlow
+{
+
+
+template<typename T, typename Allocator>
+class Vector;
+
+#include "VectorFwd.H"
+
+
+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
+: 
+	public std::vector<T, Allocator>
+{
+public:
+	
+	typedef Vector<T, Allocator>					VectorType;
+
+	typedef typename std::vector<T, Allocator>		vectorType;
+
+	typedef typename vectorType::iterator 			iterator;
+	
+	typedef typename vectorType::const_iterator 	constIterator;
+	
+	typedef typename vectorType::reference 			reference;
+	
+	typedef typename vectorType::const_reference 	constReference;
+	
+	typedef  T 										valueType; 		
+
+	typedef  T* 									pointer;
+
+	typedef const T*  								constPointer;
+
+	typedef typename std::initializer_list<T> 		initList;
+
+protected:
+
+	// - 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
+	TypeNameTemplateNV2("Vector", T, memoerySpaceName());
+
+	//// - Constructors
+
+		// - empty Vector
+		inline Vector()
+		:
+			Vector("Vector")
+		{}
+
+		inline 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)
+		:
+			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(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(const word& name, size_t cap, size_t len, RESERVE ):
+			name_(name)
+		{
+			this->reserve(cap);
+			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)
+		:
+			vectorType(l)
+		{}
+
+		// - from src and a new name
+		inline Vector(const word name, const Vector<T>& 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)
+		:
+			vectorType(src),
+			name_("Vector")
+		{
+			
+		}
+		
+		// copy assignment
+		inline VectorType& operator=( const VectorType& rhs ) = default;
+
+		inline VectorType& operator=(const vectorType& rhs)
+		{
+			Vector::assign(rhs.begin(), rhs.end());
+			return *this;
+		}
+		
+		// move assignment 
+		inline VectorType& operator=( VectorType && mv) = default;
+	
+		// scalar assignment 
+		inline void operator=(const T& val)
+		{
+			fill(val);
+		}
+
+		inline ~Vector()
+		{
+			vectorType::clear();
+		}
+
+		inline uniquePtr<VectorType> clone() const
+		{
+			return makeUnique<VectorType>(*this);
+		}
+
+		inline VectorType* clonePtr()const
+		{
+			return new VectorType(*this);
+		}
+
+	inline auto clear()
+	{
+		return vectorType::clear();
+	}
+
+	// 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;
+	}
+
+	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 
+	//   return false if out of range
+	bool deleteElement_sorted(const Vector<label>& indices );
+
+	// - delete elemens of vector based on indices 
+	//   return false if out of range
+	bool deleteElement(const Vector<label>& indices );
+
+	// - delete elment with index 
+	//   return false if out of range
+	bool deleteElement(label index);
+
+	// - set or insert new elements into the vector 
+	//   return false if it fails
+	bool insertSetElement(const  int32IndexContainer& indices, const T& val);
+
+	// - set or insert new elements into the vector 
+	//   return false if it fails
+	bool insertSetElement(const  int32IndexContainer& indices, const Vector<T>& vals);
+	
+	// - set or insert new elements into the vector 
+	//   return false if it fails
+	bool insertSetElement(const  Vector<int32>& indices, const T& val);
+
+	// - set or insert new elements into the vector 
+	//   return false if it fails
+	bool insertSetElement(const  Vector<int32>& indices, const Vector<T>& vals);
+
+	// - 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);
+
+	bool readVector(iIstream& is);
+
+	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.H"
+#include "Vector.C"
+#include "VectorMath.H"
+#include "VectorAlgorithm.H"
+
+#endif
diff --git a/src/phasicFlow/containers/Vector/VectorAlgorithm.H b/src/phasicFlow/containers/Vector/VectorAlgorithm.H
new file mode 100644
index 00000000..80c5b9be
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/VectorAlgorithm.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+namespace pFlow
+{
+	
+template<typename T, typename Allocator>
+inline auto count(const Vector<T, Allocator>& vec, const T& val)
+{
+	return std::count(vec.begin(), vec.end(), val);
+}
+
+template<typename T, typename Allocator, typename UnaryPredicate>
+inline auto count_if(const Vector<T, Allocator>& vec, UnaryPredicate p)
+{
+	return std::count_if(vec.begin(), vec.end(), p);
+}
+
+template<typename T, typename Allocator>
+inline void fill_n(Vector<T, Allocator>& vec, size_t n, const T& val)
+{
+	std::fill_n(vec.begin(), n, val);
+}
+
+template<typename T, typename Allocator>
+inline void fill(Vector<T, Allocator>& vec, const T& val)
+{
+	std::fill(vec.begin(), vec.end(), val);
+}
+
+template<typename T, typename Allocator>
+inline void fillSequence(Vector<T, Allocator>& vec, int32 start, int32 end, const T& startVal)
+{
+	pFlow::algorithms::STD::fillSequence<T, false>(vec.data()+start, end-start, startVal);
+}
+
+template<typename T, typename Allocator>
+inline void fillSequence(Vector<T, Allocator>& vec, const T& startVal)
+{
+	pFlow::fillSequence(vec, 0, vec.size(), startVal);
+}
+
+template<typename T, typename Allocator>
+inline void sort(Vector<T, Allocator>& vec)
+{
+	std::sort(vec.begin(), vec.end());
+}
+
+
+template<typename T, typename Allocator>
+inline int64 find(Vector<T, Allocator>& vec, const T& val)
+{
+	forAll( i,vec)
+	{
+		if ( vec[i] == val) return static_cast<int64>(i);
+	}
+	return -1;
+}
+
+
+} // pFlow
+
diff --git a/src/phasicFlow/containers/Vector/VectorFwd.H b/src/phasicFlow/containers/Vector/VectorFwd.H
new file mode 100644
index 00000000..6c7c00ee
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/VectorFwd.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator+ (const Vector<T, Allocator>& op1, const T& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator+ (const T& op1, const Vector<T, Allocator>& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator+ (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator - (const Vector<T, Allocator>& op1, const T& op2 );
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator - (const T& op1, const Vector<T, Allocator>& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator - (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator* (const Vector<T, Allocator>& op1, const T& op2 );
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator* (const T& op1, const Vector<T, Allocator>& op2 );
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator* (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator / (const Vector<T, Allocator>& op1, const T& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator / (const T& op1, const Vector<T, Allocator>& op2 );
+
+
+template<typename T, typename Allocator>
+inline Vector<T, Allocator> operator / (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 );
+
+
+template<typename T, typename Allocator>
+inline auto count(const Vector<T, Allocator>& vec, const T& val);
+
+template<typename T, typename Allocator, typename UnaryPredicate>
+inline auto count_if(const Vector<T, Allocator>& vec, UnaryPredicate p);
+
+template<typename T, typename Allocator>
+inline void fill_n(Vector<T, Allocator>& vec, size_t n, const T& val);
+
+template<typename T, typename Allocator>
+inline void fill(Vector<T, Allocator>& vec, const T& val);
+
+template<typename T, typename Allocator>
+inline void sort(Vector<T, Allocator>& vec);
diff --git a/src/phasicFlow/containers/Vector/VectorI.H b/src/phasicFlow/containers/Vector/VectorI.H
new file mode 100644
index 00000000..6bacd5dd
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/VectorI.H
@@ -0,0 +1,302 @@
+/*------------------------------- 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 Allocator>
+inline void pFlow::Vector<T, Allocator>::fill( const T& val)
+{
+	std::fill(this->begin(), this->end(), val);
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator +=( const T& val)
+{
+	for( auto& v:(*this) )
+	{
+		v+= val;
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator -=( const T& val)
+{
+	for( auto& v:(*this) )
+	{
+		v -= val;
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator *=( const T& val)
+{
+	for( auto& v:(*this) )
+	{
+		v *= val;
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator /=( const T& val)
+{
+	for( auto& v:(*this) )
+	{
+		v /= val;
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator +=( const Vector<T, Allocator>& v )
+{
+
+	if(size() != v.size() )
+	{
+		fatalErrorInFunction <<
+		"the += operator is invalid, vector size of right side (" << v.size() <<
+		") is not equal to the left side (" << size() << ").\n";
+		fatalExit;
+	}
+
+	for(label i=0; i<v.size(); i++)
+	{
+		this->operator[](i) += v[i];
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator -=( const Vector<T, Allocator>& v )
+{
+
+	if(size() != v.size() )
+	{
+		fatalErrorInFunction <<
+		"the -= operator is invalid, vector size of right side (" << v.size() <<
+		") is not equal to the left side (" << size() << ").\n";
+		fatalExit;
+	}
+
+	for(label i=0; i<v.size(); i++)
+	{
+		this->operator[](i) -= v[i];
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator *=( const Vector<T, Allocator>& v )
+{
+
+	if(size() != v.size() )
+	{
+		fatalErrorInFunction <<
+		"the * operator is invalid, vector size of right side (" << v.size() <<
+		") is not equal to the left side (" << size() << ").\n";
+		fatalExit;
+	}
+
+	for(label i=0; i<v.size(); i++)
+	{
+		this->operator[](i) *= v[i];
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline void pFlow::Vector<T, Allocator>::operator /=( const Vector<T, Allocator>& v )
+{
+
+	if(size() != v.size() )
+	{
+		fatalErrorInFunction <<
+		"the /= operator is invalid, vector size of right side (" << v.size() <<
+		") is not equal to the left side (" << size() << ").\n";
+		fatalExit;
+	}
+
+	for(label i=0; i<v.size(); i++)
+	{
+		this->operator[](i) /= v[i];
+	}
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::Vector<T, Allocator>::operator -
+(
+)const
+{
+	Vector<T, Allocator> res(*this);
+	for( auto& vi:res)
+	{
+		vi = -vi;
+	}
+	return res;
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator+ (const Vector<T, Allocator>& op1, const T& op2 )
+{
+	Vector<T, Allocator> res(op1);
+	res += op2;
+	return res;
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator+ (const T& op1, const Vector<T, Allocator>& op2 )
+{
+	Vector<T, Allocator> res(op2);
+	res += op1;
+
+	return res;
+
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator+ (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 )
+{
+	if( op1.size() != op2.size() )
+	{
+		fatalErrorInFunction <<
+		"the + operator is invalid, vector size of operand1 (" << op1.size() <<
+		") is not equal to vector size of operand2 (" << op1.size() << ").\n";
+		fatalExit;
+	}
+
+	Vector<T, Allocator> res(op1);
+	res += op2;
+	return res;
+}
+
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator - (const Vector<T, Allocator>& op1, const T& op2 )
+{
+	Vector<T, Allocator> res(op1);
+	res -= op2;
+	return res;
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator - (const T& op1, const Vector<T, Allocator>& op2 )
+{
+	Vector<T, Allocator> res(op2.size(), op1);
+	res -= op2;
+	return res;
+
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator - (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 )
+{
+	if( op1.size() != op2.size() )
+	{
+		fatalErrorInFunction <<
+		"the - operator is invalid, vector size of operand1 (" << op1.size() <<
+		") is not equal to vector size of operand2 (" << op1.size() << ").\n";
+		fatalExit;
+	}
+
+	Vector<T, Allocator> res(op1);
+	res -= op2;
+	return res;
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator* (const Vector<T, Allocator>& op1, const T& op2 )
+{
+	Vector<T, Allocator> res(op1);
+	res *= op2;
+	return res;
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator* (const T& op1, const Vector<T, Allocator>& op2 )
+{
+	Vector<T, Allocator> res(op2);
+	res *= op1;
+
+	return res;
+
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator* (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 )
+{
+	if( op1.size() != op2.size() )
+	{
+		fatalErrorInFunction <<
+		"the * operator is invalid, vector size of operand1 (" << op1.size() <<
+		") is not equal to vector size of operand2 (" << op1.size() << ").\n";
+		fatalExit;
+	}
+
+	Vector<T, Allocator> res(op1);
+	res *= op2;
+	return res;
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator / (const Vector<T, Allocator>& op1, const T& op2 )
+{
+	Vector<T, Allocator> res(op1);
+	res /= op2;
+	return res;
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator / (const T& op1, const Vector<T, Allocator>& op2 )
+{
+	Vector<T, Allocator> res(op2.size(), op1);
+	res /= op2;
+	return res;
+
+}
+
+#pragma hd_warning_disable 
+template<typename T, typename Allocator>
+inline pFlow::Vector<T, Allocator> pFlow::operator / (const Vector<T, Allocator>& op1, const Vector<T, Allocator>& op2 )
+{
+	if( op1.size() != op2.size() )
+	{
+		fatalErrorInFunction <<
+		"the / operator is invalid, vector size of operand1 (" << op1.size() <<
+		") is not equal to vector size of operand2 (" << op1.size() << ").\n";
+		fatalExit;
+	}
+
+	Vector<T, Allocator> res(op1);
+	res /= op2;
+	return res;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Vector/VectorMath.H b/src/phasicFlow/containers/Vector/VectorMath.H
new file mode 100644
index 00000000..22c7087d
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/VectorMath.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#define VecFunc(fnName) 									\
+template<typename T, typename Allocator>										\
+inline pFlow::Vector<T, Allocator> pFlow::fnName(const Vector<T,Allocator>& v)	\
+{															\
+	Vector<T, Allocator> res(v.capacity(), Logical());		\
+	for(auto& e:v)											\
+	{														\
+		res.push_back( fnName(e) );							\
+	}														\
+	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) 	\
+{																		\
+	Vector<T, Allocator> res(v.capacity(), Logical());								\
+	for(label i=0; i<v.size(); i++)										\
+	{																	\
+		if( iFn(i) )													\
+			res.push_back(fnName(v[i]));								\
+		else															\
+			res.push_back(v[i]);										\
+	}																	\
+	return std::move(res);												\
+}
+
+#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)	\
+{															\
+	Vector<T, Allocator> res(v1.capacity(), Logical());					\
+	for(label 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) 	\
+{																		\
+	Vector<T, Allocator> res(v1.capacity(), Logical());							\
+	for(label i=0; i<v1.size(); i++)									\
+	{																	\
+		if( iFn(i) )													\
+			res.push_back(fnName(v1[i], v2[i]));						\
+		else															\
+			res.push_back(v1[i]);										\
+	}																	\
+	return std::move(res);												\
+}
+
+
+//* * * * * * * * * * *  List of functinos * * * * * * * * //
+// abs, mod, exp, log, log10, pow, sqrt, cbrt
+// sin, cos, tan, asin, acos, atan, atan2
+// sinh, cosh, tanh, asinh, acosh, atanh 
+// min, max
+//* * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+VecFunc(abs);
+VecFunc2(mod);
+VecFunc(exp);
+VecFunc(log);
+VecFunc(log10);
+VecFunc2(pow);
+VecFunc(sqrt);
+VecFunc(cbrt);
+VecFunc(sin);
+VecFunc(cos);
+VecFunc(tan);
+VecFunc(asin);
+VecFunc(acos);
+VecFunc(atan);
+VecFunc2(atan2);
+VecFunc(sinh);
+VecFunc(cosh);
+VecFunc(tanh);
+VecFunc(asinh);
+VecFunc(acosh);
+VecFunc(atanh);
+
+#undef VecFunc
+
+//// special implementation of math functions 
+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());
+	for(auto& elm:v)
+	{
+		res.push_back(pow(elm,e));
+	}
+	return std::move(res);
+}
+
+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++)
+	{
+		if(iFn(i))
+		{
+			res.push_back(pow(v[i],e));
+		}
+		else
+		{
+			res.push_back(v[i]);
+		}
+	}
+	return std::move(res);
+}
+
+template<typename T, typename Allocator>
+inline T min(const Vector<T, Allocator>& v)
+{
+	T minVal(largestPositive<T>());
+	for(auto& elm:v)
+	{
+		minVal = min(elm, minVal);
+	}
+	return minVal;
+}
+
+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++)
+	{
+		if(iFn(i))
+		{
+			minVal = min(v[i], minVal);
+		}
+		
+	}
+	return minVal;
+}
+
+template<typename T, typename Allocator>
+inline T max(const Vector<T, Allocator>& v)
+{
+	T maxVal(largestNegative<T>());
+	for(auto& elm:v)
+	{
+		maxVal = max(elm, maxVal);
+	}
+	return maxVal;
+}
+
+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++)
+	{
+		if(iFn(i))
+		{
+			maxVal = max(v[i], maxVal);
+		}
+		
+	}
+	return maxVal;
+}
+
+template<typename T, typename Allocator>
+inline T sum(const Vector<T, Allocator>& v)
+{
+	T s = static_cast<T>(0);
+	for(auto& elm:v)
+	{
+		s += elm;
+	}
+	return s;
+}
+
+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)
+	{
+		if(iFn(i))
+			s += v[i];
+	}
+	return s;
+}
+
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/Vector/Vectors.C b/src/phasicFlow/containers/Vector/Vectors.C
new file mode 100644
index 00000000..ea8ee972
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/Vectors.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+#include "Vectors.H"
+
+// 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.H b/src/phasicFlow/containers/Vector/Vectors.H
new file mode 100644
index 00000000..1c681ff3
--- /dev/null
+++ b/src/phasicFlow/containers/Vector/Vectors.H
@@ -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 __Vectors_H__
+#define __Vectors_H__
+
+
+#include "types.H"
+#include "Vector.H"
+
+namespace pFlow
+{
+
+
+using int8Vector 	= Vector<int8>;
+
+using int16Vector 	= Vector<int16>;
+
+using int32Vector 	= Vector<int32>;
+
+using int64Vector 	= Vector<int64>;
+
+using uint32Vector 	= Vector<uint32>;
+
+using labelVector 	= Vector<label>;
+
+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;*/
+
+}
+
+
+#endif //__Vectors_H__
\ No newline at end of file
diff --git a/src/phasicFlow/containers/VectorHD/VectorDual.H b/src/phasicFlow/containers/VectorHD/VectorDual.H
new file mode 100644
index 00000000..1575aaff
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorDual.H
@@ -0,0 +1,965 @@
+/*------------------------------- 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 __VectorDual_H__
+#define __VectorDual_H__
+
+#include "globalSettings.H"
+#include "types.H"
+#include "typeInfo.H"
+#include "Vector.H"
+#include "streams.H"
+
+#include "KokkosTypes.H"
+#include "ViewAlgorithms.H"
+
+#ifndef __RESERVE__
+#define __RESERVE__
+	struct RESERVE{};
+#endif
+
+
+namespace pFlow
+{
+
+template<typename T, typename MemorySpace>
+class VectorDual;
+
+
+template<typename T, typename MemorySpace=void>
+class VectorDual
+{
+public:
+	
+	using iterator        = T*;
+  	
+  	using constIterator   = const T*;
+
+	using reference       = T&;
+  	
+  	using constReference  = const T&;
+
+	using valueType       = T;
+  	
+  	using pointer         = T*;
+  	
+  	using constPointer    = const T*;  	
+  	
+  	using VectorType	  = VectorDual<T, MemorySpace>;
+
+  	// dualViewType (view of data host and device)
+  	using dualViewType 		= Kokkos::DualView<T*, MemorySpace>;
+
+  	// mirror scape of device view
+  	using hostMirrorSpace 	= typename dualViewType::host_mirror_space;
+  	
+  	// - viewType of data on device 
+  	using deviceViewType 	= typename dualViewType::t_dev;
+
+  	// - viewType of data on host
+  	using hostViewType 		= typename dualViewType::t_host;
+  
+	using deviceType 		= typename deviceViewType::device_type;
+
+	using hostType 			= typename hostViewType::device_type;
+
+	// to be consistent 
+  	using viewType 			= dualViewType;
+
+  	// we assume device view is the primary side
+  	using memory_space 		= typename viewType::memory_space;
+
+	// we assume device view is the primary side
+	using execution_space 	= typename deviceType::execution_space;
+
+protected:
+
+	size_t 			size_ = 0;
+
+	size_t 			capacity_ = 0;
+
+	dualViewType   	dualView_;
+
+	mutable deviceViewType 	deviceSubView_;
+
+	mutable hostViewType 	hostSubView_;
+
+	mutable bool   			subViewsUpdated_ = false;
+	
+	static const inline real 	growthFactor_ = vectorGrowthFactor__;
+
+	// is host accepsibble from device prespective 
+	static constexpr bool  isHostAccessible_ =	
+  	Kokkos::SpaceAccessibility<execution_space,Kokkos::HostSpace>::accessible;
+
+	// host-device name 
+	static inline const word hdName__ = 
+		word(hostType::memory_space::name())+
+		word(deviceType::memory_space::name());
+
+	
+	constexpr static inline const char* memoerySpaceName()
+  	{
+  		return hdName__.data();
+  	}
+
+	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_ )
+		{
+			if(actualCap)
+				capacity_ = n;
+			else
+				capacity_ = evalCapacity(n);
+	
+			dualView_.resize(capacity_);
+			subViewsUpdated_ = false;
+			syncViews();
+			
+		}
+		if(!actualCap) 
+		{
+			setSize(n);
+		}
+	}
+
+	INLINE_FUNCTION_H void setSize(size_t n) {
+		size_ = n;
+		subViewsUpdated_ = false;
+	}
+
+	// - seems strange, since we actually are updating values,
+	//   but in fact the content of object is actually const.
+	INLINE_FUNCTION_H void updateSubViews()const
+	{
+		if(subViewsUpdated_)return;
+		
+		hostSubView_   = Kokkos::subview(dualView_.h_view, Kokkos::make_pair(0,int(size_)));
+		deviceSubView_ = Kokkos::subview(dualView_.d_view, Kokkos::make_pair(0,int(size_)));
+		subViewsUpdated_ = true;
+	}
+
+public:
+
+	// - type info
+	TypeNameTemplateNV2("VectorDual", T, memoerySpaceName());
+
+	//// - Constructors
+
+		// - empty
+		VectorDual()
+		:
+			VectorDual("VectorDual")
+		{
+		}
+
+		VectorDual(const word& name)
+		:
+			size_(0),
+			capacity_(2),
+			dualView_(name,capacity_)
+		{
+			changeSize(size_);
+		}
+
+		// - with size n
+		VectorDual(size_t n)
+		:
+			VectorDual("VectorDual",n)
+		{}
+
+		// - with name and size n
+		VectorDual(const word& name, size_t n)
+		:
+			size_(n),
+			capacity_(evalCapacity(n)),
+			dualView_(name, capacity_)
+		{
+			changeSize(size_);
+		}
+
+		// with size and value, apply on both views
+		VectorDual(size_t n, const T& val)
+		:
+			VectorDual("VectorDual", n , val)
+		{}
+
+		// with name, size and value, apply on both views
+		VectorDual(const word& name, size_t n, const T& val)
+		:
+			VectorDual(name, n)
+		{
+			assign(n, val);
+		}
+
+		VectorDual(size_t cap, size_t n, RESERVE )
+		:
+			VectorDual("VectorDual", cap, n, RESERVE())
+		{}
+
+		VectorDual(const word& name, size_t cap, size_t n, RESERVE )
+		:
+			VectorDual(name)
+		{
+			reallocate(cap);
+			setSize(n);
+			
+		}
+
+		VectorDual(const Vector<T> & src)
+		:
+			VectorDual("VectorDual", src)
+		{}
+
+		VectorDual(const word& name, const Vector<T> & src)
+		:
+			VectorDual(name)
+		{
+			assign(src);
+		}
+
+		// - copy construct (perform deep copy)
+		//   preserve the sync status of the views
+		VectorDual(const VectorDual& src)
+		:
+			VectorDual(src.name(), src.capacity(), src.size(), RESERVE())
+		{
+			// transfer the sync status 
+			if(src.hostRequiresSync())
+			{
+				modifyOnDevice();
+			}else if( src.deviceRequiresSync())
+			{
+				modifyOnHost();
+			}else
+			{
+				dualView_.clear_sync_state();
+			}
+
+			Kokkos::deep_copy(hostVector(), src.hostVector());
+			Kokkos::deep_copy(deviceVector(), src.deviceVector());
+		}
+
+		// copy construct with new name 
+		VectorDual(const word& name, const VectorDual& src)
+		:
+			VectorDual(name, src.capacity(), src.size(), RESERVE())
+		{
+			// transfer the sync status 
+			if(src.hostRequiresSync())
+			{
+				modifyOnDevice();
+			}else if( src.deviceRequiresSync())
+			{
+				modifyOnHost();
+			}else
+			{
+				dualView_.clear_sync_state();
+			}
+
+			Kokkos::deep_copy(hostVector(), src.hostVector());
+			Kokkos::deep_copy(deviceVector(), src.deviceVector());
+		}
+
+		// - copy assignment 
+		VectorDual& operator = (const VectorDual& rhs)
+		{
+			if(&rhs == this) return *this;
+				
+			VectorDual temp(rhs);
+			capacity_   = temp.capacity();
+			setSize( temp.size());
+			dualView_   = temp.dualView_;
+			
+			return *this;
+		}
+
+		// no move construct
+		VectorDual(VectorDual&&) = delete;
+
+		// no move assignment
+		VectorDual& operator= (VectorDual&&) = delete;
+
+		// - clone as a uniquePtr
+		INLINE_FUNCTION_H uniquePtr<VectorDual> clone() const
+		{
+			return makeUnique<VectorDual>(*this);
+		}
+
+		// - clone as a pointer
+		INLINE_FUNCTION_H VectorDual* clonePtr()const
+		{
+			return new VectorDual(*this);
+		}
+
+
+	//// - Methods
+		// - return *this
+		INLINE_FUNCTION_H
+		VectorType& VectorField()
+		{
+			return *this;
+		}
+
+		// - return *this
+		INLINE_FUNCTION_H
+		const VectorType& VectorField()const
+		{
+			return *this;
+		}
+
+		// - Device vector
+		INLINE_FUNCTION_H deviceViewType& deviceVectorAll(){
+			return dualView_.d_view;
+		}
+
+		// - Device vector 
+		INLINE_FUNCTION_H const deviceViewType& deviceVectorAll() const {
+			return dualView_.d_view;
+		}
+
+		// - Host vector
+		INLINE_FUNCTION_H hostViewType& hostVectorAll(){
+			return dualView_.h_view;
+		}
+
+		// - Host Vector
+		INLINE_FUNCTION_H const hostViewType& hostVectorAll() const {
+			return dualView_.h_view;
+		}
+
+		INLINE_FUNCTION_H deviceViewType& deviceVector(){
+			updateSubViews();
+			return deviceSubView_;
+		}
+
+		INLINE_FUNCTION_H const deviceViewType& deviceVector() const{
+			updateSubViews();
+			return deviceSubView_;
+		}
+
+		INLINE_FUNCTION_H hostViewType& hostVector(){
+			updateSubViews();
+			return hostSubView_;
+		}
+
+		INLINE_FUNCTION_H const hostViewType& hostVector()const{
+			updateSubViews();
+			return hostSubView_;
+		}
+
+		INLINE_FUNCTION_H
+		hostViewType hostVector(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
+		{
+			return Kokkos::subview(dualView_.d_view, Kokkos::make_pair(start,end));
+		}
+		
+		INLINE_FUNCTION_H  const word  name()const
+		{
+			return dualView_.h_view.label();
+		}
+
+		INLINE_FUNCTION_H size_t size()const
+		{
+			return size_;
+		}
+
+		INLINE_FUNCTION_H size_t capacity()const
+		{
+			return capacity_;
+		}
+		
+		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);
+		}
+		// resize the views 
+		// no syncronization occurs
+		INLINE_FUNCTION_H void resize(size_t n)
+		{
+			changeSize(n);
+		}
+
+		INLINE_FUNCTION_H void reallocate(size_t cap)
+		{
+			capacity_ = cap;
+			setSize(0);
+			dualView_.realloc(cap);
+			dualView_.clear_sync_state();
+			
+			
+		}
+
+		INLINE_FUNCTION_H void resizeSync(size_t n)
+		{
+			changeSize(n);		
+			syncViews();
+		}
+
+		// resize the view and assign value to the most recent view (most updated)
+		// no syncronization occurs
+		INLINE_FUNCTION_H void resize(size_t n, const T& val) {
+			assign(n, val);
+		}
+
+		// resize the view and assign value to the most recent view (most updated)
+		// and syncronize both views 
+		INLINE_FUNCTION_H void resizeSync(size_t n, const T& val){
+			assign(n,val);
+			syncViews();
+		}
+
+		INLINE_FUNCTION_H void clear() {
+			 
+			 setSize(0);
+			 dualView_.clear_sync_state();
+		}
+
+		// - fill both views with val
+		INLINE_FUNCTION_H void fill(const T& val)
+		{
+			if(empty())return;
+			Kokkos::deep_copy(deviceVector(),val);
+			Kokkos::deep_copy(hostVector(),val);
+			dualView_.clear_sync_state();
+		}
+
+		INLINE_FUNCTION_H void fillHost(const T& val)
+		{
+			if(empty())return;
+			Kokkos::deep_copy(hostVector(),val);
+			modifyOnHost();
+		}
+
+		INLINE_FUNCTION_H void fillDevice(const T& val)
+		{
+			if(empty())return;
+			Kokkos::deep_copy(deviceVector(),val);
+			modifyOnDevice();
+		}
+
+		// - host calls only
+		// - assign n first elements to val
+		//   resize views
+		//   assign value to both sides (device&host)
+		FUNCTION_H void assign(size_t n, const T& val)
+		{
+			
+			if( n>= capacity_ )
+			{
+				reallocate(evalCapacity(n));
+			}
+			setSize(n);
+			fill(val);
+		}
+
+		// - host calls only
+		// - assign source vector
+		//   resize views
+		//   assign to both sides (device&host)
+		FUNCTION_H void assign(const Vector<T>& src)
+		{
+			auto srcSize = src.size();
+			if( capacity() < srcSize ) 
+			{
+				reallocate( evalCapacity(srcSize) );
+			}
+
+			setSize(0);
+			dualView_.clear_sync_state();
+			for( auto& elem:src )
+			{
+				this->push_back(elem);
+			}
+			syncViews();
+		}
+
+		// TODO: this part may be implemented in parallel 
+		bool deleteElement
+		(
+			const Vector<label>& indices
+		)
+		{
+			if( indices.size() == 0 )return true;
+
+			if( *(indices.end()-1) >= size() ) return false;
+			
+			auto oldSize = this->size();
+			auto nextInd = indices.begin();
+			label j = indices[0];
+			for(label i=indices[0]; i < oldSize; ++i)
+			{
+				if( nextInd != indices.end() && i == *nextInd )
+				{
+					++nextInd;
+				}
+				else
+				{
+					dualView_.h_view[j] = dualView_.h_view[i];
+					++j;	
+				}				
+			}
+			
+			setSize( oldSize - indices.size() );
+			modifyOnHost();
+
+			// TODO: deep_copy should be changed to a range shorter than the vector size
+			syncViews();
+
+			return true;
+		}
+
+		INLINE_FUNCTION_H
+		bool insertSetElement(const int32IndexContainer& indices, const T& val)
+		{
+			if(indices.size() == 0)return true;
+			
+			auto maxInd = indices.max();
+
+			if(this->empty() || maxInd > size()-1 )
+			{
+				resize(maxInd+1);
+			} 
+			fillSelected(hostVectorAll(), indices.hostView(), indices.size(), val);
+			
+			auto dIndices = indices.deviceView();
+			auto dVals = deviceVectorAll();
+
+			Kokkos::parallel_for(
+				"fillSelected",
+				indices.size(),
+				LAMBDA_HD(int32 i){
+				dVals[dIndices[i]]= val;
+			
+				});
+			Kokkos::fence();
+
+			return true;
+
+		}
+
+		template<typename side=HostSide>
+		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();
+			auto minInd = indices.min(); 
+			
+			if(this->empty() || maxInd > size()-1 )
+			{
+				resize(maxInd+1);
+			} 
+
+			if constexpr (std::is_same<side,HostSide>::value )
+			{
+
+				hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
+				//fillSelected(hostVector(), indices.hostView(), hVecVals, indices.size());
+
+				pFlow::algorithms::KOKKOS::fillSelected<T, int32, DefaultHostExecutionSpace>(
+					hostVectorAll().data(),
+					indices.hostView().data(),
+					hVecVals.data(),
+					indices.size());
+
+				modifyOnHost();
+			
+				syncViews(minInd, maxInd+1);
+			}
+			else
+			{
+				
+				pFlow::hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
+				pFlow::deviceViewType1D<T> dVecVals("dVecVals", indices.size());
+				
+				Kokkos::deep_copy(dVecVals, hVecVals);
+				
+
+				//fillSelected(deviceVector(), indices.deviceView(), dVecVals, indices.size());
+				pFlow::algorithms::KOKKOS::fillSelected<T, int32, execution_space>(
+					deviceVectorAll().data(),
+					indices.deviceView().data(),
+					dVecVals.data(),
+					indices.size());
+
+				modifyOnDevice();
+				
+				// TODO: deep_copy should be changed to a range shorter than the vector size
+				syncViews(minInd, maxInd+1);
+
+			}
+
+			return true;
+			
+		}
+
+		template<typename side=HostSide>
+		INLINE_FUNCTION_H
+		bool insertSetElement(const Vector<int32>& indices, const T& val)
+		{
+			if(indices.size() == 0)return true;
+			
+			auto maxInd = max(indices);
+			auto minInd = min(indices);
+
+			if(this->empty() || maxInd > size()-1 )
+			{
+				resize(maxInd+1);
+			} 
+					
+			if constexpr (std::is_same<side,HostSide>::value )
+			{
+				hostViewType1D<int32> hVecInd( const_cast<int32*>(indices.data()), indices.size());
+				fillSelected( hostVectorAll(), hVecInd, indices.size(), val);
+
+				modifyOnHost();
+				syncViews(minInd, maxInd+1);
+
+				return true;
+			}
+			else
+			{
+				
+				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);
+				
+				modifyOnDevice();
+
+				// TODO: deep_copy should be changed to a range shorter than the vector size
+				syncViews(minInd, maxInd+1);
+				return true;
+				
+			}
+		
+		return false;
+
+		}
+
+		template<typename side=HostSide>
+		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;
+
+			auto maxInd = max(indices);
+			auto minInd = min(indices); 
+			
+			if(this->empty() || maxInd > size()-1 )
+			{
+				resize(maxInd+1);
+			} 
+
+			if constexpr (std::is_same<side,HostSide>::value )
+			{
+				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());
+
+				modifyOnHost();
+			
+				syncViews(minInd, maxInd+1);
+			}
+			else
+			{
+				
+				pFlow::hostViewType1D<int32> hVecInd( const_cast<int32*>(indices.data()), indices.size());
+				pFlow::deviceViewType1D<int32> dVecInd("dVecInd", indices.size());
+
+				pFlow::hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
+				pFlow::deviceViewType1D<T> dVecVals("dVecVals", indices.size());
+				
+				Kokkos::deep_copy(dVecVals, hVecVals);
+				Kokkos::deep_copy(dVecInd, hVecInd);
+
+				fillSelected(deviceVectorAll(), dVecInd, dVecVals, indices.size());
+
+				modifyOnDevice();
+				
+				// TODO: deep_copy should be changed to a range shorter than the vector size
+				syncViews(minInd, maxInd+1);
+
+			}
+
+			return true;
+			
+		}
+
+		// push a new element at the end
+		// resize if necessary
+		// first sycn to host side
+		void push_back(const T& val)
+		{
+			
+			syncToHost();
+			modifyOnHost();
+			
+			if(size_ == capacity_) changeSize(capacity_);
+			data()[size_++] = val;
+			subViewsUpdated_ = false;
+			
+		}
+
+		INLINE_FUNCTION_H pointer data(){
+			return dualView_.h_view.data();
+		}
+
+		INLINE_FUNCTION_H constPointer data()const{
+			return dualView_.h_view.data();
+		}
+
+		// host call
+		// returns begin iterator 
+		INLINE_FUNCTION_H iterator begin(){
+			return data();
+		}
+
+		// host call
+		// returns begin iterator 
+		INLINE_FUNCTION_H constIterator begin()const {
+			return data();
+		}
+
+		// host call
+		// returns end iterator 
+		INLINE_FUNCTION_H iterator end(){
+			return size_ > 0 ? data() + size_: data();
+		}
+
+		// host call
+		// returns end iterator 
+		INLINE_FUNCTION_H constIterator end()const{
+			return size_ > 0 ? data() + size_: data();
+		}
+
+		INLINE_FUNCTION_H reference operator[](label i){
+			return dualView_.h_view[i];
+		}
+
+		INLINE_FUNCTION_H constReference operator[](label i)const{
+			return dualView_.h_view[i];
+		}
+
+		
+	//// - managing sync between views
+
+		INLINE_FUNCTION_H void modifyOnHost()
+		{
+			dualView_.modify_host();
+		}
+
+		INLINE_FUNCTION_H void modifyOnDevice()
+		{
+			dualView_.modify_device();
+		}
+		
+		INLINE_FUNCTION_H bool hostRequiresSync()const
+		{
+			return dualView_.template need_sync<hostType>();
+		}
+
+		INLINE_FUNCTION_H bool deviceRequiresSync()const
+		{
+			return dualView_.template need_sync<deviceType>();
+		}
+
+		INLINE_FUNCTION_H bool areViewsSimilar()const
+		{
+			return std::is_same<hostType,deviceType>::value;
+		}
+
+		// - copy from host to device 
+		//   set both views to updated
+		INLINE_FUNCTION_H void copyHostToDevice()
+		{
+			if(empty())return;
+			
+			Kokkos::deep_copy(deviceVector(), hostVector());
+			dualView_.clear_sync_state();
+		}
+
+		INLINE_FUNCTION_H 
+		void copyHostToDevice(int32 start, int32 end, bool setUpdated = true)
+		{
+			if(empty())return;
+			Kokkos::deep_copy(deviceVector(start, end), hostVector(start, end));
+			if(setUpdated)
+				dualView_.clear_sync_state();
+		}
+
+		// - copy from device to host
+		//   set both views to updated
+		INLINE_FUNCTION_H void copyDeviceToHost()
+		{
+			if(empty())return;
+			Kokkos::deep_copy(hostVector(), deviceVector());
+			dualView_.clear_sync_state();
+		}
+
+		INLINE_FUNCTION_H 
+		void copyDeviceToHost(int32 start, int32 end, bool setUpdated = true)
+		{
+			if(empty())return;
+			Kokkos::deep_copy(hostVector(start, end), deviceVector(start, end));
+			if(setUpdated)
+				dualView_.clear_sync_state();
+		}
+
+		INLINE_FUNCTION_H void syncToHost()
+		{
+			if(hostRequiresSync())
+			{
+				copyDeviceToHost();
+			}
+		}
+
+		INLINE_FUNCTION_H void syncToDevice()
+		{
+			if(deviceRequiresSync())
+			{
+				copyHostToDevice();
+			}	
+		}
+		// - check which side requires update and 
+		//   apply the update 
+		INLINE_FUNCTION_H void syncViews()
+		{
+			if(deviceRequiresSync())
+			{
+				copyHostToDevice();
+			}
+			else if(hostRequiresSync())
+			{
+				copyDeviceToHost();
+			}
+		}
+
+		INLINE_FUNCTION_H void syncViews(int32 start, int32 end)
+		{
+			if(deviceRequiresSync())
+			{
+				copyHostToDevice(start, end);
+			}
+			else if(hostRequiresSync())
+			{
+				copyDeviceToHost(start, end);
+			}
+		}
+
+	//// - IO operations
+		FUNCTION_H
+		bool read(iIstream& is)
+		{
+			Vector<T> vecFromFile;
+			if( !vecFromFile.read(is) ) return false;
+			
+			this->assign(vecFromFile);
+
+			return true;
+		}
+
+		FUNCTION_H
+		bool write(iOstream& os) const
+		{
+			// since the object should be const, no way to syncViews
+			
+			Vector<T, noConstructAllocator<T>> vecToFile(this->size());
+			hostViewType1D<T> mirror(vecToFile.data(), vecToFile.size());
+
+			
+			if(hostRequiresSync()) // device is updated
+			{
+				//const auto dVec = Kokkos::subview(dualView_.d_view, Kokkos::make_pair(0,int(size_)));
+				Kokkos::deep_copy(mirror,deviceVector());
+			}
+			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());
+			}				
+			return vecToFile.write(os);
+		}
+};
+
+template<typename T, typename memory_space>
+inline iIstream& operator >> (iIstream & is, VectorDual<T, memory_space> & ivec )
+{
+	if( !ivec.read(is) )
+	{
+		ioErrorInFile (is.name(), is.lineNumber());
+		fatalExit;
+	}
+	return is;
+}
+
+template<typename T, typename memory_space>
+inline iOstream& operator << (iOstream& os, const VectorDual<T, memory_space>& ovec )
+{
+	
+	if( !ovec.write(os) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+
+	return os; 
+}
+
+
+} // pFlow
+
+#include "VectorDualAlgorithms.H"
+
+
+#endif //__VectorDual_H__
+
diff --git a/src/phasicFlow/containers/VectorHD/VectorDualAlgorithms.H b/src/phasicFlow/containers/VectorHD/VectorDualAlgorithms.H
new file mode 100644
index 00000000..ea67bc8d
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorDualAlgorithms.H
@@ -0,0 +1,113 @@
+/*------------------------------- 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 __VectorDualMath_H__
+#define __VectorDualMath_H__
+
+
+
+#include "baseAlgorithms.H"
+
+
+namespace pFlow
+{
+
+
+
+// - select the side (HostSide or DeviceSide)
+template<typename side, typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+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);
+	}
+	else
+	{
+		return count( vec.deviceVectorAll(), static_cast<size_t>(0), vec.size(), val);
+	}
+
+	return -1;
+}
+
+// default to device side
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+int64 count(const VectorDual<T,MemorySpace>& vec, const T& val)
+{
+	return count<DeviceSide>( vec, val);
+}
+
+template<typename side, typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+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());
+	}
+	else
+	{
+		return min( vec.deviceVectorAll(), static_cast<size_t>(0), vec.size());
+	}
+
+	return 0.0;
+}
+
+// default to device side
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+int64 min(const VectorDual<T,MemorySpace>& vec)
+{
+	return min<DeviceSide>( vec);
+}
+
+template<typename side, typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+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());
+	}
+	else
+	{
+		return max( vec.deviceVectorAll(), static_cast<size_t>(0), vec.size());
+	}
+
+	return 0.0;
+}
+
+// default to device side
+template<typename T, typename MemorySpace>
+INLINE_FUNCTION_H 
+int64 max(const VectorDual<T,MemorySpace>& vec)
+{
+	return max<DeviceSide>( vec);
+}
+
+
+
+} // pFlow
+
+
+#endif // __VectorSingleMath_H__
diff --git a/src/phasicFlow/containers/VectorHD/VectorDuals.H b/src/phasicFlow/containers/VectorHD/VectorDuals.H
new file mode 100644
index 00000000..9b07fb85
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorDuals.H
@@ -0,0 +1,52 @@
+/*------------------------------- 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 __VectorDuals_H__
+#define __VectorDuals_H__
+
+
+#include "types.H"
+#include "VectorDual.H"
+
+namespace pFlow
+{
+
+using int8Vector_HD 	= VectorDual<int8>;
+
+using int16Vector_HD 	= VectorDual<int16>;
+
+using int32Vector_HD 	= VectorDual<int32>;
+
+using int64Vector_HD 	= VectorDual<int64>;
+
+using uint32Vector_HD 	= VectorDual<uint32>;
+
+using labelVector_HD 	= VectorDual<label>;
+
+using realVector_HD 	= VectorDual<real>;
+
+using realx3Vector_HD 	= VectorDual<realx3>;
+
+using realx3x3Vector_HD = VectorDual<realx3x3>;
+
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingle.H b/src/phasicFlow/containers/VectorHD/VectorSingle.H
new file mode 100644
index 00000000..b2898e29
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorSingle.H
@@ -0,0 +1,859 @@
+/*------------------------------- 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 __VectorSingle_H__
+#define __VectorSingle_H__
+
+#include "globalSettings.H"
+#include "types.H"
+#include "typeInfo.H"
+#include "Vector.H"
+#include "indexContainer.H"
+
+#include "KokkosTypes.H"
+#include "ViewAlgorithms.H"
+
+
+#ifndef __RESERVE__
+#define __RESERVE__
+	struct RESERVE{};
+#endif
+
+namespace pFlow
+{
+
+
+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>;
+
+  	using iterator        = T*;
+
+  	using constIterator   = const T*;
+  	
+	using reference       = T&;
+  	
+  	using constReference  = const T&;
+
+	using valueType       = T;
+  	
+  	using pointer         = T*;
+  	
+  	using constPointer    = const T*;
+  	
+  	// type defs related to Kokkos 
+  	using viewType 			= ViewType1D<T, MemorySpace>;
+
+  	using deviceType 		= typename viewType::device_type;
+
+  	using memory_space 		= typename viewType::memory_space;
+
+  	using execution_space 	= typename viewType::execution_space;
+
+protected:
+	
+	size_t 			size_ = 0;
+
+	size_t 			capacity_ = 0;
+
+	viewType   		view_;
+
+	mutable viewType	subView_;
+
+	mutable bool		subViewUpdated_ = false;
+
+	static const inline real 	growthFactor_ = vectorGrowthFactor__;
+
+	static constexpr bool  isHostAccessible_ =
+  	Kokkos::SpaceAccessibility<execution_space,Kokkos::HostSpace>::accessible;
+
+  	constexpr static inline const char* memoerySpaceName()
+  	{
+  		return memory_space::name();
+  	}
+
+	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_ )
+		{
+			if(actualCap)
+				capacity_ = n;
+			else
+				capacity_ = evalCapacity(n);
+
+			Kokkos::resize(view_, capacity_);
+			subViewUpdated_ = false;
+		}
+		if(!actualCap) 
+		{
+			setSize(n);
+		}
+	}
+
+	INLINE_FUNCTION_H void setSize(size_t n)
+	{
+		size_ = n;
+		subViewUpdated_ = false;
+	}
+
+	// - update subview 
+	INLINE_FUNCTION_H void updateSubView()const
+	{
+		if(subViewUpdated_) return;
+
+		subView_ 	= Kokkos::subview(view_, Kokkos::make_pair(0,int(size_)));
+		subViewUpdated_ = true;
+	}
+	
+	
+public:
+
+	// - type info
+	TypeNameTemplateNV2("VectorSingle", T, memoerySpaceName());
+
+	//// - Constructors
+
+		// - empty constructor
+		VectorSingle()
+		:
+			VectorSingle("VectorSingle")
+		{}
+
+		// empty vector with a name 
+		VectorSingle(const word& name)
+		:
+			size_(0),
+			capacity_(2),
+			view_(name,capacity_)
+		{
+			changeSize(size_);
+		}
+
+		// - a vector with size n
+		VectorSingle(size_t n)
+		:
+			VectorSingle("VectorSingle",n)
+		{}
+
+		// - a vector with name and size n
+		VectorSingle(const word& name, size_t n)
+		:
+			size_(n),
+			capacity_(evalCapacity(n)),
+			view_(name, capacity_)
+		{
+			changeSize(size_);
+		}
+
+		// a vector with size and value 
+		VectorSingle(size_t n, const T& val)
+		:
+			VectorSingle("VectorSingle", n , val)
+		{}
+
+		// 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
+		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);
+		}
+
+	//// - Methods
+
+		// - return *this
+		INLINE_FUNCTION_H
+		VectorType& VectorField()
+		{
+			return *this;
+		}
+
+		// - return *this
+		INLINE_FUNCTION_H
+		const VectorType& VectorField()const
+		{
+			return *this;
+		}
+
+
+		// - Device vector range [0,capcity)
+		INLINE_FUNCTION_H 
+		viewType& deviceVectorAll(){
+			return view_;
+		}
+
+		// - Device vector range [0,capacity)
+		INLINE_FUNCTION_H 
+		const viewType& deviceVectorAll() const {
+			return view_;
+		}
+
+		//  - Device vector range [0, size)
+		INLINE_FUNCTION_H 
+		viewType& deviceVector(){
+			updateSubView();
+			return subView_;
+		}
+
+		//  - Device vector range [0, size)
+		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();
+		}
+		
+		// - size of vector 
+		INLINE_FUNCTION_H 
+		size_t size()const
+		{
+			return size_;
+		}
+
+		// - capcity of 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);
+		}
+		
+		// - 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);
+			}
+
+			if constexpr (isHostAccessible_)
+			{
+				fillSelected(deviceVectorAll(), indices.hostView(), indices.size(), val);
+				return true;
+			
+			}else
+			{
+				fillSelected(deviceVectorAll(), indices.deviceView(), indices.size(), val);
+				return true;
+			}
+
+			return false;
+		}
+
+		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);
+			} 
+
+			if constexpr (isHostAccessible_)
+			{
+				// TODO: remove const_cast
+				hostViewType1D<T> dVecVals( const_cast<T*>(vals.data()), vals.size());
+
+
+				pFlow::algorithms::KOKKOS::fillSelected<T, int32, execution_space>(
+					deviceVectorAll().data(),
+					indices.hostView().data(),
+					dVecVals.data(),
+					indices.size());
+
+				return true;
+			
+			}else
+			{
+				
+				// TODO: remove const_cast
+				hostViewType1D<T> hVecVals( const_cast<T*>(vals.data()), vals.size());
+				deviceViewType1D<T> dVecVals("dVecVals", indices.size());
+				copy(dVecVals, hVecVals);
+
+				
+				pFlow::algorithms::KOKKOS::fillSelected<T, int32, execution_space>(
+					deviceVectorAll().data(),
+					indices.deviceView().data(),
+					dVecVals.data(),
+					indices.size());
+				return true;
+			}
+
+			return false;
+		}
+
+		INLINE_FUNCTION_H
+		bool insertSetElement(const Vector<int32>& indices, const T& val)
+		{
+			if(indices.empty()) return true;
+
+			auto maxInd = max(indices);
+			
+			if(this->empty() || maxInd > size()-1 )
+			{
+				resize(maxInd+1);
+			}
+
+			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;
+		}
+
+		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;
+
+			auto maxInd = max(indices); 
+			
+			if(this->empty() || maxInd > size()-1 )
+			{
+				resize(maxInd+1);
+			} 
+
+			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
+			{
+				
+				// 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
+		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.deviceVector(), Vec.size());
+		}
+
+		// - host calls only
+		//   push a new element at the end
+		//   resize if necessary
+		//   works on host accessible vector 
+		template<bool Enable = true>
+		typename std::enable_if<
+			isHostAccessible_ && Enable,
+			void>::type
+		push_back(const T& val)
+		{
+			if(size_ == capacity_) changeSize(capacity_);
+			data()[size_++] = val;
+			subViewUpdated_ = false;
+		}
+
+		INLINE_FUNCTION_H pointer data(){
+			return view_.data();
+		}
+
+		INLINE_FUNCTION_H constPointer data()const{
+			return view_.data();
+		}
+
+		// - host calls only
+		//   works on host accessible vector 
+		// 	 returns begin iterator 
+		template<bool Enable = true>
+		INLINE_FUNCTION_H 
+		typename std::enable_if_t<
+			isHostAccessible_ && Enable,
+			iterator>
+		begin(){
+			return data();
+		}
+
+		// - host calls only
+		//   works on host accessible vector 
+		//   returns begin iterator 
+		template<bool Enable = true>
+		INLINE_FUNCTION_H 
+		typename std::enable_if<
+			isHostAccessible_ && Enable,
+			constIterator>::type
+		begin()const {
+			return data();
+		}
+
+		// - host calls only
+		//   works on host accessible vector 
+		//   returns end iterator
+		template<bool Enable = true> 
+		INLINE_FUNCTION_H
+		typename std::enable_if<
+			isHostAccessible_ && Enable,
+			iterator>::type
+		end(){
+			return size_ > 0 ? data() + size_: data();
+		}
+
+		// host call
+		// returns end iterator 
+		template<bool Enable = true>
+		INLINE_FUNCTION_H
+		typename std::enable_if<
+			isHostAccessible_ && Enable,
+			constIterator>::type
+		end()const{
+			return size_ > 0 ? data() + size_: data();
+		}
+				
+		// operator to be used on host side vectors
+		template<bool Enable = true>
+		INLINE_FUNCTION_H 
+		typename std::enable_if<
+			isHostAccessible_ && Enable,
+			reference>::type
+		operator[](label i){
+			return view_[i];
+		}
+
+		template<bool Enable = true>
+		INLINE_FUNCTION_H 
+		typename std::enable_if<
+			isHostAccessible_ && Enable,
+			constReference>::type
+		 operator[](label i)const{
+			return view_[i];
+		}
+
+	//// - IO operations
+
+		FUNCTION_H
+		bool read(iIstream& is)
+		{
+			Vector<T> vecFromFile;
+			if( !vecFromFile.read(is) ) return false;
+
+			this->assign(vecFromFile);
+
+			return true;
+		}
+
+		FUNCTION_H
+		bool write(iOstream& os)const
+		{
+			
+			Vector<T, noConstructAllocator<T>> vecToFile(this->size());
+			
+			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);
+		}
+
+}; // class VectorSingle
+
+template<typename T, typename MemorySpace>
+inline iIstream& operator >> (iIstream & is, VectorSingle<T, MemorySpace> & ivec )
+{
+	if( !ivec.read(is) )
+	{
+		ioErrorInFile (is.name(), is.lineNumber());
+		fatalExit;
+	}
+	return is;
+}
+
+template<typename T, typename MemorySpace>
+inline iOstream& operator << (iOstream& os, const VectorSingle<T, MemorySpace>& ovec )
+{
+	
+	if( !ovec.write(os) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+
+	return os; 
+}
+
+
+
+
+} // - pFlow
+
+#include "VectorSingleAlgorithms.H"
+
+
+#endif //__VectorSingle_H__
+
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingleAlgorithms.H b/src/phasicFlow/containers/VectorHD/VectorSingleAlgorithms.H
new file mode 100644
index 00000000..df14ab5c
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorSingleAlgorithms.H
@@ -0,0 +1,61 @@
+/*------------------------------- 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 __VectorSingleMath_H__
+#define __VectorSingleMath_H__
+
+
+
+
+namespace pFlow
+{
+
+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);
+}
+
+template<class T, class MemorySpace>
+INLINE_FUNCTION_H T min( const VectorSingle<T,MemorySpace>& vec) 
+{
+	return min(
+		vec.deviceVectorAll(),
+		0, vec.size()
+		);	
+}
+
+template<class T, class MemorySpace>
+INLINE_FUNCTION_H T max( const VectorSingle<T, MemorySpace>& vec) 
+{
+	return min(
+		vec.deviceVectorAll(),
+		0, vec.size()
+		);		
+}
+
+
+
+}
+
+
+#endif // __VectorSingleMath_H__
diff --git a/src/phasicFlow/containers/VectorHD/VectorSingles.H b/src/phasicFlow/containers/VectorHD/VectorSingles.H
new file mode 100644
index 00000000..506953ad
--- /dev/null
+++ b/src/phasicFlow/containers/VectorHD/VectorSingles.H
@@ -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 __VectorSingles_H__
+#define __VectorSingles_H__
+
+
+#include "types.H"
+#include "VectorSingle.H"
+
+namespace pFlow
+{
+
+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;
+
+typedef VectorSingle<int64> 			int64Vector_D;
+
+typedef VectorSingle<int64, HostSpace> 	int64Vector_H;
+
+typedef VectorSingle<uint32> 			uint32Vector_D;
+
+typedef VectorSingle<uint32, HostSpace> uint32Vector_H;
+
+typedef VectorSingle<label> 			labelVector_D;
+
+typedef VectorSingle<label, HostSpace> 	labelVector_H;
+
+typedef VectorSingle<real> 				realVector_D;
+
+typedef VectorSingle<real, HostSpace> 	realVector_H;
+
+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;
+
+typedef VectorSingle<int64x3> 				int64x3Vector_D;
+
+typedef VectorSingle<int64x3, HostSpace> 	int64x3Vector_H;
+
+typedef VectorSingle<realx3x3> 				realx3x3Vector_D;
+
+typedef VectorSingle<realx3x3, HostSpace> 	realx3x3Vector_H;
+
+}
+
+#endif
\ No newline at end of file
diff --git a/src/phasicFlow/containers/bitsetHD/bitsetHD.H b/src/phasicFlow/containers/bitsetHD/bitsetHD.H
new file mode 100644
index 00000000..21e945b4
--- /dev/null
+++ b/src/phasicFlow/containers/bitsetHD/bitsetHD.H
@@ -0,0 +1,223 @@
+/*------------------------------- 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 __bitsetHD_H__ 
+#define __bitsetHD_H__
+
+
+#include "KokkosTypes.H"
+#include "types.H"
+
+// a lightweight container for holding bits on host or device 
+// it is NOT concurrent and it does not used atommic operation on memory
+
+namespace pFlow
+{
+
+
+template<typename blockType, typename MemorySpace=void>
+class bitsetHD
+{
+public:
+
+	using BlockType 		= blockType;
+
+	using blockViewType 	= Kokkos::View<BlockType*, Kokkos::LayoutLeft, MemorySpace>;
+
+  	using deviceType 		= typename blockViewType::device_type;
+
+  	using memory_space 		= typename blockViewType::memory_space;
+
+  	using execution_space 	= typename blockViewType::execution_space;  
+
+protected:
+
+	int32 			numBlocks_;
+
+	int32 			numBits_;
+
+	blockViewType 	blocks_;
+
+	const static inline 
+	int32 bitsPerBlock_ = std::numeric_limits<BlockType>::digits;
+
+	const static inline
+	int32 blockMask_   = bitsPerBlock_ - 1;
+
+	static INLINE_FUNCTION_HD
+	int32 blockIndex(int32 pos)
+	{
+		return pos/bitsPerBlock_;
+	}
+	
+	static INLINE_FUNCTION_HD
+	BlockType bitIndex(int32 pos)
+	{
+		return static_cast<BlockType>(pos%bitsPerBlock_);
+	}
+
+	static INLINE_FUNCTION_HD
+	BlockType blockMask(int32 pos)
+	{
+		return static_cast<BlockType> (1 <<(pos & blockMask_));
+	}
+
+	static INLINE_FUNCTION_HD
+	int32 calculateBlockSize(int32 numBits)
+	{
+		return numBits/bitsPerBlock_ + 1;
+	}
+
+
+public:
+
+	
+	bitsetHD(const word& name, int32 numBits)
+	:
+		numBlocks_(calculateBlockSize(numBits)),
+		numBits_(numBits),
+		blocks_(name, numBlocks_)
+	{
+		
+	}
+
+	bitsetHD(const bitsetHD&) = default;
+
+	bitsetHD(bitsetHD&&) = default;
+
+	bitsetHD& operator=(const bitsetHD&) = default;
+
+	bitsetHD& operator=(bitsetHD&&) = default;
+
+	void set()
+	{
+		Kokkos::deep_copy(blocks_, ~0);
+	}
+
+	void reset()
+	{ 
+		Kokkos::deep_copy( blocks_ , static_cast<BlockType>(0));
+	}
+   
+    void clear() 
+    {
+    	Kokkos::deep_copy( blocks_ , static_cast<BlockType>(0)); 
+    }
+
+  	INLINE_FUNCTION_HD
+  	void set(int32 pos) const 
+  	{
+		BlockType& block = blocks_[blockIndex(pos)];
+		block |= blockMask(pos);
+	}
+
+	INLINE_FUNCTION_HD
+	void unset(int32 pos)const
+	{
+		BlockType& block = blocks_[blockIndex(pos)];
+		block &= (~blockMask(pos));
+	}
+
+	INLINE_FUNCTION_HD
+	void reset(int32 pos)const
+	{
+		unset(pos);
+	}
+
+	INLINE_FUNCTION_HD
+	void flip(int32 pos)const
+	{
+		BlockType& block = blocks_[blockIndex(pos)];
+		block ^= blockMask(pos);
+	}
+
+	INLINE_FUNCTION_HD
+	bool isSet(int32 pos)const
+	{
+		BlockType& block = blocks_[blockIndex(pos)];
+		return block & blockMask(pos); 
+	}
+
+	INLINE_FUNCTION_HD
+	bool isUnset(int32 pos)const
+	{
+		return !isSet(pos);
+	}
+
+	INLINE_FUNCTION_HD
+	bool isSetReset(int32 pos)const
+	{
+		BlockType& block = blocks_[blockIndex(pos)];
+		auto mask = blockMask(pos);
+		bool is_set = block & mask;
+		block &= (~mask);
+		return is_set;
+	}
+
+	INLINE_FUNCTION_HD
+	int32 numBlocks()const
+	{
+		return numBlocks_;
+	}
+	
+	INLINE_FUNCTION_HD
+	int32 numBits()const
+	{
+		return numBits_;
+	}
+	
+	INLINE_FUNCTION_HD
+	int32 size()const
+	{
+		return numBits_;
+	}
+
+	INLINE_FUNCTION_HD
+	int32 capacity()const
+	{
+		return numBlocks_*bitsPerBlock_;
+	}
+
+	INLINE_FUNCTION_H
+	void realloc(int32 numBits)
+	{
+		numBlocks_ = calculateBlockSize(numBits);
+		numBits_ = numBits;
+		Kokkos::realloc(blocks_, numBlocks_);
+	}
+  
+
+};
+
+
+using bitset32_D = bitsetHD<unsigned>;
+
+using bitset32_H = bitsetHD<unsigned, HostSpace>;
+
+using bitset64_D = bitsetHD<unsigned long>;
+
+using bitset64_H = bitsetHD<unsigned long, HostSpace>;
+
+
+} // namespace pFlow
+
+
+#endif //__bitsetHD_H__
diff --git a/src/phasicFlow/containers/bitsetHD/bitsetHDs.C b/src/phasicFlow/containers/bitsetHD/bitsetHDs.C
new file mode 100644
index 00000000..ec486d54
--- /dev/null
+++ b/src/phasicFlow/containers/bitsetHD/bitsetHDs.C
@@ -0,0 +1,27 @@
+/*------------------------------- 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 "bitsetHD.H" 
+
+
+
+template class pFlow::bitsetHD<unsigned>;
+
diff --git a/src/phasicFlow/containers/indexContainer/indexContainer.C b/src/phasicFlow/containers/indexContainer/indexContainer.C
new file mode 100644
index 00000000..888899f0
--- /dev/null
+++ b/src/phasicFlow/containers/indexContainer/indexContainer.C
@@ -0,0 +1,21 @@
+/*------------------------------- 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 "indexContainer.H"
\ No newline at end of file
diff --git a/src/phasicFlow/containers/indexContainer/indexContainer.H b/src/phasicFlow/containers/indexContainer/indexContainer.H
new file mode 100644
index 00000000..00d97b4b
--- /dev/null
+++ b/src/phasicFlow/containers/indexContainer/indexContainer.H
@@ -0,0 +1,171 @@
+/*------------------------------- 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 __indexContainer_H__ 
+#define __indexContainer_H__
+
+#include "span.H"
+#include "KokkosTypes.H"
+#include "KokkosUtilities.H"
+#include "ViewAlgorithms.H"
+
+namespace pFlow
+{
+
+template<typename IndexType>
+class indexContainer
+{
+public:
+	
+	using DualViewType 		= Kokkos::DualView<IndexType*>;
+
+	// - viewType of data on device 
+  	using DeviceViewType 	= typename DualViewType::t_dev;
+
+  	// - viewType of data on host
+  	using HostViewType 		= typename DualViewType::t_host;
+
+  	template<typename ViewType>
+  	class IndexAccessor
+  	{
+  	protected:
+  		ViewType 	view_;
+
+  	public:
+  		IndexAccessor(ViewType v):
+  		view_(v){}
+
+  		INLINE_FUNCTION_HD
+  		IndexType operator()(int32 i)const
+  		{
+  			return view_[i];
+  		}
+  	};
+
+protected:
+
+	int32 		min_  	= 0;
+	int32 		max_ 	= 0;
+	size_t 		size_	= 0; 	
+
+	DualViewType 	views_;
+
+public:
+
+	indexContainer(){}
+
+	// half open [begin,end)
+	indexContainer(IndexType begin, IndexType end)
+	:
+		min_(begin),
+		max_(end-1),
+		size_(end-begin),
+		views_("indexContainer", size_)
+	{
+		pFlow::fillSequence(views_.d_view, 0, size_, min_);
+		copy(views_.h_view, views_.d_view);
+	}
+
+
+	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() = 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>())
+		{
+			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;
+	}
+
+	auto indicesHost()const
+	{
+		return IndexAccessor<HostViewType>(views_.h_view);
+	}
+
+	auto indicesDevice()const
+	{
+		return IndexAccessor<DeviceViewType>(views_.d_veiw);
+	}
+};
+
+
+using int32IndexContainer = indexContainer<int32>;
+using int64IndexContainer = indexContainer<int64>;
+
+
+}
+
+
+#endif 
diff --git a/src/phasicFlow/containers/pointField/pointField.C b/src/phasicFlow/containers/pointField/pointField.C
new file mode 100644
index 00000000..41c5230b
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/pointField.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField
+(
+	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
+)
+:
+	eventObserver(pStruct, subscribe),
+	FieldType(pStruct.capacity(), pStruct.size(), RESERVE()),
+	pStruct_(pStruct),
+	defaultValue_(defVal)
+{
+	// set value 
+	this->fill(defVal);
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+pFlow::pointField<VectorField, 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<template<class, class> class VectorField, class T, class MemorySpace>
+pFlow::pointField<VectorField, T, MemorySpace>::pointField
+(
+	const pointField& src,
+	bool subscribe
+)
+:
+	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
+)
+{
+	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)
+{
+ 
+	if( msg.isDeleted() )
+	{
+		/*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_);
+	}
+	
+	return true;
+}
+
diff --git a/src/phasicFlow/containers/pointField/pointField.H b/src/phasicFlow/containers/pointField/pointField.H
new file mode 100644
index 00000000..304412b2
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/pointField.H
@@ -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_H__
+#define __pointField_H__
+
+
+#include "Field.H"
+#include "pointStructure.H"
+#include "error.H"
+
+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
+	TypeNameTemplateNV2("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.C"
+#include "pointFieldAlgorithms.H"
+
+#endif //  __pointField_H__
diff --git a/src/phasicFlow/containers/pointField/pointFieldAlgorithms.H b/src/phasicFlow/containers/pointField/pointFieldAlgorithms.H
new file mode 100644
index 00000000..2d38e1bf
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/pointFieldAlgorithms.H
@@ -0,0 +1,269 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+
+namespace pFlow
+{
+
+
+const inline auto ActivePoint = pointStructure::ACTIVE;
+
+template<class T, typename... properties>
+T maxActive_serial(
+	const Kokkos::View<T*, properties...>& view,
+	const Kokkos::View<int8*, Kokkos::LayoutLeft, Kokkos::HostSpace>& flag,
+	size_t start,
+	size_t end
+	)
+{
+	T maxValue = largestNegative<T>();
+	for(label i=start; i<end; ++i)
+	{
+		if(flag[i] == ActivePoint )maxValue = max(maxValue, view[i]);
+	}
+	return maxValue;
+}
+
+// to be executed on host 
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T maxActiveH(
+	const Kokkos::View<T*, properties...>& view,
+	const Kokkos::View<int8*, Kokkos::LayoutLeft, Kokkos::HostSpace>& flag,
+ 	size_t start,
+ 	size_t end
+ 	) 
+{
+
+	T maxValue = largestNegative<T>();
+
+	auto RP = Kokkos::RangePolicy<
+	Kokkos::IndexType<size_t>,
+	typename Kokkos::View<T, properties...>::execution_space >(start, end);
+
+	Kokkos::parallel_reduce("pointFieldAlgorithms-maxActive",
+							RP, 
+							LAMBDA_HD(label i, T& valueToUpdate){
+								if(flag[i] == ActivePoint) valueToUpdate = max(view[i],valueToUpdate);
+							},
+							Kokkos::Max<T>( maxValue )
+							);
+	return maxValue;
+}
+
+
+// to be executed on device 
+template<typename T, typename... properties>
+INLINE_FUNCTION_H
+T maxActiveD(
+	const Kokkos::View<T*, properties...>& view,
+	const Kokkos::View<int8*, Kokkos::LayoutLeft>& flag,
+ 	size_t start,
+ 	size_t end
+ 	) 
+{
+
+	T maxValue = largestNegative<T>();
+
+	auto RP = Kokkos::RangePolicy<
+	Kokkos::IndexType<size_t>,
+	typename Kokkos::View<T, properties...>::execution_space >(start, end);
+
+	Kokkos::parallel_reduce("pointFieldAlgorithms-maxActive",
+							RP, 
+							LAMBDA_HD(label i, T& valueToUpdate){
+								if(flag[i] == ActivePoint) valueToUpdate = max(view[i],valueToUpdate);
+							},
+							Kokkos::Max<T>( maxValue )
+							);
+	return maxValue;
+}
+
+template<class T, class MemorySpace>
+T maxActive(const pointField<VectorSingle, T, MemorySpace>& pField)
+{
+	
+	// if all points are active, perfrom a simple max
+	if( pField.allActive() )
+		return max(pField.VectorField());
+
+	const auto len = pField.size();
+	if constexpr ( pField.isHostAccessible())
+	{
+		if(len < sizeToSerial__ ) // serial execution instead of lunching parallel execution 
+			return maxActive_serial(
+				pField.deviceVectorAll(),
+				pField.pointFlag().hostVectorAll(),
+				static_cast<size_t>(0),
+				len
+				);
+		else
+			return maxActiveH(
+				pField.deviceVectorAll(),
+				pField.pointFlag().hostVectorAll(),
+				static_cast<size_t>(0),
+				len
+				);
+	}
+	else
+	{
+		return maxActiveD(
+			pField.deviceVectorAll(),
+			pField.pointFlag().deviceVectorAll(),
+			static_cast<size_t>(0),
+			len
+			);
+	}
+
+	// to remove the warning of CUDAC++ compiler when dealing with constexpr
+	return 0;
+}
+
+template<class side, class T, class MemorySpace=void>
+T maxActive(const pointField<VectorDual, T, MemorySpace>& pField)
+{
+	if( pField.allActive() )
+		return max(pField.VectorField());
+
+	auto len = pField.size();
+
+	if constexpr (std::is_same<side,HostSide>::value)
+	{
+		if( len < sizeToSerial__)
+			return maxActive_serial(
+				pField.hostVectorAll(),
+				pField.pointFlag().hostVectorAll(),
+				static_cast<size_t>(0),
+				len
+				);
+		else
+			return maxActiveH(
+				pField.hostVectorAll(),
+				pField.pointFlag().hostVectorAll(),
+				static_cast<size_t>(0),
+				len
+				);
+	}else
+	{
+		return maxActiveD(
+				pField.deviceVectorAll(),
+				pField.pointFlag().deviceVectorAll(),
+				static_cast<size_t>(0),
+				len
+				);
+	}
+
+	return 0;
+}
+
+/*template<typename T>
+	void inline fillActive(pointField<T>& field, const T& val)
+{
+	if(field.pStruct().allActive)
+	{
+		fill_n(field, field.size(), val);
+		return;
+	}
+	forAll(i, field)
+	{
+		if(field.pStruct().isActive(i)) field[i] = val;
+	}
+}
+
+template<typename T>
+	void inline fillMarkedDelete( pointField<T>& field, const T& val)
+{
+	if(field.pStruct().allActive())return;
+	forAll(i,field)
+	{
+		if(!field.pStruct().isActive(i)) field[i] = val;
+	}
+}
+
+template<typename T>
+inline auto countActive(const pointField<T>& field, const T& val)
+{
+	if(field.pStruct().allActive())
+	{
+		return count(field, val);
+	}
+	else
+	{
+		return count(field, val, [&](label i){return field.pointField().isActive(i);});
+	}
+}
+
+template<typename T, typename UnaryPredicate>
+inline auto for_eachActive(pointField<T>& field, UnaryPredicate func)
+{
+	if(field.pStruct().allActive())
+	{
+		forAll(i,field)
+		{
+			func(i);
+		}
+	}
+	else
+	{
+		forAll(i, field)
+		{
+			if(field.pStruct().isActive(i)) func(i);
+		}
+	}
+	return func;
+}
+
+template<typename T, typename UnaryPredicate>
+inline bool for_eachActiveBreak(pointField<T>& field, UnaryPredicate func)
+{
+	if(field.pStruct().allActive())
+	{
+		forAll(i,field)
+		{
+			if(!func(i))return false;
+		}
+	}
+	else
+	{
+		forAll(i, field)
+		{
+			if(field.pStruct().isActive(i))
+			{
+			 	if(!func(i)) return false;
+			}
+		}
+	}
+	return true;
+}
+
+template<typename T, typename UnaryPredicate>
+inline auto for_eachMarkedDelete(pointField<T>& field, UnaryPredicate func)
+{
+	if(field.pStruct().allActive()) return func;
+		
+	forAll(i, field)
+	{
+		if(!field.pStruct().isActive(i)) func(i);
+	}
+	return func;
+}*/
+
+
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/pointFields.C b/src/phasicFlow/containers/pointField/pointFields.C
new file mode 100644
index 00000000..d4ed99ec
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/pointFields.C
@@ -0,0 +1,58 @@
+/*------------------------------- 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 "pointFields.H"
+
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8>; 
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>; 
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int16>; 
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int16, pFlow::HostSpace>; 
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int32>; 
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int32, pFlow::HostSpace>; 
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int64>; 
+
+template class pFlow::pointField<pFlow::VectorSingle, pFlow::int64, pFlow::HostSpace>; 
+
+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>;
+
+
+
diff --git a/src/phasicFlow/containers/pointField/pointFields.H b/src/phasicFlow/containers/pointField/pointFields.H
new file mode 100644
index 00000000..8b908825
--- /dev/null
+++ b/src/phasicFlow/containers/pointField/pointFields.H
@@ -0,0 +1,88 @@
+/*------------------------------- 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 __pointFields_H__
+#define __pointFields_H__
+
+#include "VectorSingle.H"
+#include "pointField.H"
+#include "types.H"
+
+namespace pFlow
+{
+
+
+using int8PointField_D 		= pointField<VectorSingle, int8>;
+
+using int8PointField_H 		= pointField<VectorSingle, int8, HostSpace>;
+
+using int16PointField_D 	= pointField<VectorSingle, int16>;
+
+using int16PointField_H 	= pointField<VectorSingle, int16, HostSpace>;
+
+using int32PointField_D 	= pointField<VectorSingle, int32>;
+
+using int32PointField_H 	= pointField<VectorSingle, int32, HostSpace>;
+
+using int64PointField_D 	= pointField<VectorSingle, int64>;
+
+using int64PointField_H 	= pointField<VectorSingle, int64, HostSpace>;
+
+using uint32PointField_D 	= pointField<VectorSingle, uint32>;
+
+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>>;
+
+}
+
+
+#endif
diff --git a/src/phasicFlow/containers/span/span.H b/src/phasicFlow/containers/span/span.H
new file mode 100644
index 00000000..788e7270
--- /dev/null
+++ b/src/phasicFlow/containers/span/span.H
@@ -0,0 +1,161 @@
+/*------------------------------- 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 __span_H__
+#define __span_H__
+
+#include "types.H"
+
+namespace pFlow {
+
+
+template<typename T>
+class span
+{
+
+public:
+	
+	using iterator        = T*;
+
+  	using constIterator   = const T*;
+  	
+	using reference       = T&;
+  	
+  	using constReference  = const T&;
+
+	using valueType       = T;
+  	
+  	using pointer         = T*;
+  	
+  	using constPointer    = const T*;
+
+protected:
+
+    T* data_ 		= nullptr;
+
+    label 	size_ 	= 0;
+
+public:
+    
+    TypeNameTemplateNV("span", T);
+
+    /// Constructor
+    INLINE_FUNCTION_HD
+    span() = default;
+
+
+    INLINE_FUNCTION_HD
+    span(T* data, label size)
+        : data_(data), size_(size)
+    {}
+
+    /// copy
+    INLINE_FUNCTION_HD
+    span(const span&) = default;
+
+    /// assignment
+    INLINE_FUNCTION_HD
+    span& operator=(const span&) = default;
+
+    /// move
+    INLINE_FUNCTION_HD
+    span(span&&) = delete;
+
+    /// assignment
+    INLINE_FUNCTION_HD
+    span& operator=(span&) = delete;
+
+    
+    INLINE_FUNCTION_HD
+    bool empty() const
+    {
+        return size_ == 0;
+    }
+
+    INLINE_FUNCTION_HD
+    T* data() const
+    {
+        return data_;
+    }
+
+    /// Returns the number of elements in the span
+    INLINE_FUNCTION_HD
+    label size() const
+    {
+        return size_;
+    }
+
+    /// Returns an iterator to the beginning of the span
+    INLINE_FUNCTION_HD
+    constIterator begin() const
+    {
+        return data_;
+    }
+
+    /// Returns an iterator to the beginning of the span
+    INLINE_FUNCTION_HD
+    constIterator cbegin() const
+    {
+        return data_;
+    }
+
+    /// Returns an iterator to one past the end of the span
+    INLINE_FUNCTION_HD
+    constIterator end() const
+    {
+        return data_ + size_;
+    }
+
+    /// Returns an iterator to one past the end of the span
+    INLINE_FUNCTION_HD
+    constIterator cend() const
+    {
+        return data_ + size_;
+    }
+
+    INLINE_FUNCTION_HD
+    T& operator[](int32 i)
+    {
+    	data_[i];
+    }
+
+    INLINE_FUNCTION_HD
+    const T& operator[](int32 i)const
+    {
+    	data_[i];
+    }
+
+    INLINE_FUNCTION_HD
+    T& operator[](label i)
+    {
+    	data_[i];
+    }
+
+    INLINE_FUNCTION_HD
+    const T& operator[](label i)const
+    {
+    	data_[i];
+    }
+
+};
+
+} // pFlow
+
+#endif //__span_H__
diff --git a/src/phasicFlow/containers/symArrayHD/symArrayHD.H b/src/phasicFlow/containers/symArrayHD/symArrayHD.H
new file mode 100644
index 00000000..f46fcc2b
--- /dev/null
+++ b/src/phasicFlow/containers/symArrayHD/symArrayHD.H
@@ -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 __symArray_H__
+#define __symArray_H__
+
+#include "KokkosTypes.H"
+
+
+#include "types.H"
+#include "typeInfo.H"
+#include "Vector.H"
+
+
+/*
+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
+{
+
+
+template<typename Type>
+INLINE_FUNCTION_HD
+void SWAP(Type &x, Type& y)
+{
+	auto temp = y;
+	y = x;
+	x = temp;
+}
+
+template<typename T, typename MemorySpace=void>
+class symArray
+{
+
+	using SymArrayType	= symArray<T, MemorySpace>;
+
+  	using iterator        = T*;
+
+  	using constIterator   = const T*;
+  	
+	using reference       = T&;
+  	
+  	using constReference  = const T&;
+
+	using valueType       = T;
+  	
+  	using pointer         = T*;
+  	
+  	using constPointer    = const T*;
+  	
+  	// type defs related to Kokkos 
+  	using ViewType 			= ViewType1D<T,MemorySpace>;
+
+  	using deviceType 		= typename ViewType::device_type;
+
+  	using memory_space 		= typename ViewType::memory_space;
+
+  	using execution_space 	= typename ViewType::execution_space;
+
+  	
+protected:
+
+	uint32 			n_=0;
+
+	ViewType 		view_;
+
+
+	constexpr static inline const char* memoerySpaceName()
+  	{
+  		return memory_space::name();
+  	}
+
+public:
+
+	// - type info
+	TypeNameTemplateNV2("symArray", T, memoerySpaceName());
+
+	//// constructors 
+	INLINE_FUNCTION_H
+	symArray();
+
+	INLINE_FUNCTION_H
+	symArray(uint32 n)
+	:
+		symArray("symArray",n)
+	{}
+
+	INLINE_FUNCTION_H
+	symArray(word name, uint32 n)
+	:
+		n_(n),
+		view_(name, numElem(n))
+	{}
+
+	INLINE_FUNCTION_H
+	symArray(word name, uint32 n , const T& val)
+	:
+		symArray(name, n)
+	{
+		this->fill(val);
+	}
+
+	INLINE_FUNCTION_H
+	symArray(word name, Vector<T> src)
+	:
+		view_(name)
+	{
+		if( !assign(src))
+		{
+			fatalErrorInFunction<<
+			"error in creating symArray " << name << endl;
+			fatalExit;
+		}
+	}
+
+	INLINE_FUNCTION_H
+	symArray(const symArray&) = default;
+
+	INLINE_FUNCTION_H
+	symArray& operator=(const symArray&) = default;
+
+	INLINE_FUNCTION_H
+	symArray(symArray&&) = delete;
+
+	INLINE_FUNCTION_H
+	symArray& operator=(symArray&&) = delete;
+
+	INLINE_FUNCTION_H
+	~symArray()=default;
+
+	
+	//// - Methods
+	void fill(const T& val)
+	{
+		if(n_==0)return;
+		Kokkos::deep_copy(view_, val);
+	}
+
+	INLINE_FUNCTION_HD
+	T& operator()(uint32 i, uint32 j)
+	{
+		if(i>j) SWAP(i,j);
+		return view_(j+i*n_-numElem(i));
+	}
+
+	INLINE_FUNCTION_HD
+	const T& operator()(uint32 i, uint32 j)const
+	{
+		if(i>j) SWAP(i,j);
+		return view_(j+i*n_-numElem(i));
+	}
+
+	bool assign(const Vector<T> src)
+	{
+		uint32 nElem = src.size();
+		uint32 n;
+		if( !getN(nElem,n))
+		{
+			fatalErrorInFunction<<
+			"size of input vector do not match a symetric array "<< nElem<<endl;
+			return false;
+		}
+
+		if(n == 0 )
+		{
+			n_ = 0;
+			return true;
+		}
+
+		if( n > n_ )
+			Kokkos::realloc(view_, nElem );
+
+		n_ = n;
+		hostViewType1D<const T> temp(src.data(), nElem );
+		Kokkos::deep_copy(view_, temp);
+
+		return true;
+	}
+
+	
+	//// IO operations 
+
+		FUNCTION_H
+		bool read(iIstream& is)
+		{
+			Vector<T> vecFromFile;
+			if( !vecFromFile.read(is) ) return false;
+
+			this->assign(vecFromFile);
+
+			return true;
+		}
+
+		FUNCTION_H
+		bool write(iOstream& os)const
+		{
+			
+			int32 s = numElem(n_);
+			Vector<T, noConstructAllocator<T>> vecToFile(s);
+			
+			const auto dVec = Kokkos::subview(view_, kPair<int32,int32>(0, s));
+			hostViewType1D<T> mirror(vecToFile.data(), vecToFile.size());
+			Kokkos::deep_copy(mirror,dVec);
+
+			return vecToFile.write(os);
+		}
+
+
+		INLINE_FUNCTION_HD
+		static uint32 numElem(uint32 n)
+		{
+			if(n==0)return 0;
+			return n*(n+1)/2;
+		}
+		
+		static bool getN(uint32 nElem, uint32& n)
+		{
+			real nr = 0.5*(sqrt(8.0*nElem+1)-1);
+			n = static_cast<uint32>(nr);
+			if( equal(nr-static_cast<real>(n) , 0.0) ) return true;
+
+			return false;
+		}
+
+
+};
+
+template<typename T, typename MemorySpace>
+inline iIstream& operator >> (iIstream & is, symArray<T, MemorySpace> & iArr )
+{
+	if( !iArr.read(is) )
+	{
+		ioErrorInFile (is.name(), is.lineNumber());
+		fatalExit;
+	}
+	return is;
+}
+
+template<typename T, typename MemorySpace>
+inline iOstream& operator << (iOstream& os, const symArray<T, MemorySpace>& oArr )
+{
+	
+	if( !oArr.write(os) )
+	{
+		ioErrorInFile(os.name(), os.lineNumber());
+		fatalExit;
+	}
+
+	return os; 
+}
+
+}
+
+#endif //__symArray_H__
diff --git a/src/phasicFlow/containers/symArrayHD/symArrays.C b/src/phasicFlow/containers/symArrayHD/symArrays.C
new file mode 100644
index 00000000..3f1aabec
--- /dev/null
+++ b/src/phasicFlow/containers/symArrayHD/symArrays.C
@@ -0,0 +1,29 @@
+/*------------------------------- 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 "symArrays.H"
+
+template class pFlow::symArray<pFlow::real>;
+
+template class pFlow::symArray<pFlow::real, pFlow::HostSpace>;
+
+template class pFlow::symArray<pFlow::realx3>; 
+
+template class pFlow::symArray<pFlow::realx3, pFlow::HostSpace>; 
\ No newline at end of file
diff --git a/src/phasicFlow/containers/symArrayHD/symArrays.H b/src/phasicFlow/containers/symArrayHD/symArrays.H
new file mode 100644
index 00000000..b5c99021
--- /dev/null
+++ b/src/phasicFlow/containers/symArrayHD/symArrays.H
@@ -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 "symArrayHD.H"
+
+namespace pFlow
+{
+
+
+using realSymArray_D 	= symArray<real>;
+
+using realSymArray_H 	= symArray<real, HostSpace>;
+
+using realx3SymArray_D 	= symArray<realx3>; 
+
+using realx3SymArray_H 	= symArray<realx3, HostSpace>; 
+
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceField.C b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.C
new file mode 100644
index 00000000..26830089
--- /dev/null
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.C
@@ -0,0 +1,119 @@
+/*------------------------------- 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<template<class, class> class VectorField, class T, class MemorySpace>
+pFlow::triSurfaceField<VectorField, T, MemorySpace>::triSurfaceField
+(
+	const triSurface& surface,
+	const T& defVal,
+	bool subscribe
+)
+:
+	eventObserver(surface, subscribe),
+	FieldType(surface.capacity(), surface.size(), RESERVE()),
+	surface_(surface),
+	defaultValue_(defVal)
+{
+	this->fill(defVal);
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+pFlow::triSurfaceField<VectorField, T, MemorySpace>::triSurfaceField
+(
+	const triSurface& surface,
+	const T& val,
+	const T& defVal,
+	bool subscribe
+)
+:
+	eventObserver(surface, subscribe),
+	FieldType(surface.capacity(), surface.size(), RESERVE()),
+	surface_(surface),
+	defaultValue_(defVal)
+{
+	this->fill(val);
+}
+
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+pFlow::triSurfaceField<VectorField, T, MemorySpace>::triSurfaceField
+(
+	const triSurfaceField& src,
+	bool subscribe
+)
+:
+	eventObserver(src.surface(), subscribe),
+	FieldType(src),
+	surface_(src.surface()),
+	defaultValue_(src.defaultValue_)
+{
+
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+pFlow::triSurfaceField<VectorField, T, MemorySpace>::triSurfaceField
+(
+	const triSurfaceField& src
+)
+:
+triSurfaceField<VectorField, T, MemorySpace>(src, src.subscribed())
+{}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+pFlow::triSurfaceField<VectorField, T, MemorySpace>&
+	pFlow::triSurfaceField<VectorField, T, MemorySpace>::operator= 
+(
+	const triSurfaceField& rhs
+)
+{
+	if(this == &rhs) return *this;
+	
+	this->VectorField() = rhs.VectorField();
+	return *this;
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+bool pFlow::triSurfaceField<VectorField, T, MemorySpace>::update
+(
+	const eventMessage& msg
+)
+{
+	notImplementedFunction;
+	return true;
+}
+
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+bool pFlow::triSurfaceField<VectorField, T, MemorySpace>::readTriSurfacceField
+(
+	iIstream& is
+)
+{
+	return FieldType::readField(is, surface_.size(), false);
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+bool pFlow::triSurfaceField<VectorField, T, MemorySpace>::writeTriSurfaceField
+(
+	iOstream& os
+)const
+{
+	return FieldType::write(os);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceField.H b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.H
new file mode 100644
index 00000000..dfecf8e3
--- /dev/null
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceField.H
@@ -0,0 +1,177 @@
+/*------------------------------- 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 __trieSurfaceField_H__ 
+#define __trieSurfaceField_H__
+
+#include "Field.H"
+#include "triSurface.H"
+#include "error.H"
+
+
+namespace pFlow
+{
+
+
+template<template<class, class> class VectorField, class T, class MemorySpace=void>
+class triSurfaceField
+:
+	public eventObserver,	
+	public Field<VectorField, T, MemorySpace>
+{
+public:
+	
+	using triSurfaceFieldType 	= triSurfaceField<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 triSurface& surface_;
+
+		// - value when a new item is added to field
+		T 	defaultValue_;
+
+
+public:
+	
+	// - type info
+	TypeNameTemplateNV2("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);
+
+		// - construct from iIOEntity, tirSurface and a value
+		triSurfaceField( const triSurface& surface, const T& val, const T& defVal, bool subscribe = true);
+
+		// - construct from another triSurfaceField
+		//   subscribe to events if true
+		triSurfaceField( const triSurfaceField& src, bool subscribe);
+
+
+		// - 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 {
+			return surface_;
+		}
+
+		auto getTriangleAccessor()const
+		{
+			return surface_.getTriangleAccessor();
+		}
+
+		bool update(const eventMessage& msg);
+
+
+	//// -  IO operations
+		bool readTriSurfacceField(iIstream& is);
+
+		bool writeTriSurfaceField(iOstream& os)const;
+
+
+		bool read(iIstream& is)
+		{
+			return readTriSurfacceField(is);
+		}
+
+		bool write(iOstream& os)const
+		{
+			return writeTriSurfaceField(os);
+		}
+
+};
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+iIstream& operator >> (iIstream & is, triSurfaceField<VectorField, T, MemorySpace> & tsF )
+{
+	if( !tsF.read(is))
+	{
+		ioErrorInFile( is.name(), is.lineNumber() ) <<
+		"error in reading triSurfaceField from file. \n"<<
+		"field name: "<< tsF.name()<<endl;
+		fatalExit;
+	}
+
+	return is;
+}
+
+template<template<class, class> class VectorField, class T, class MemorySpace>
+iOstream& operator << (iOstream& os, const triSurfaceField<VectorField, T, MemorySpace>& tsF )
+{
+	if(! tsF.write(os) )
+	{
+		ioErrorInFile( os.name(), os.lineNumber() )<<
+		"error in writing triSurfaceField into file. \n"<<
+		"field name: "<< tsF.name()<<endl;
+		fatalExit;
+	}
+
+	return os;
+}
+
+}
+
+#include "triSurfaceField.C"
+
+#endif //__trieSurfaceField_H__
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.C b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.C
new file mode 100644
index 00000000..fb8f6704
--- /dev/null
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.C
@@ -0,0 +1,34 @@
+/*------------------------------- 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 "triSurfaceFields.H"
+
+
+template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::real>;
+
+template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>;
+
+template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::realx3>;
+
+template class pFlow::triSurfaceField<pFlow::VectorSingle, pFlow::realx3, pFlow::HostSpace>;
+
+template class pFlow::triSurfaceField<pFlow::VectorDual, pFlow::real>;
+
+template class pFlow::triSurfaceField<pFlow::VectorDual, pFlow::realx3>;
\ No newline at end of file
diff --git a/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.H b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.H
new file mode 100644
index 00000000..dd0d1163
--- /dev/null
+++ b/src/phasicFlow/containers/triSurfaceField/triSurfaceFields.H
@@ -0,0 +1,59 @@
+/*------------------------------- 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 __triSurfaceFields_H__ 
+#define __triSurfaceFields_H__
+
+#include "VectorSingle.H"
+#include "VectorDual.H"
+#include "triSurfaceField.H"
+#include "types.H"
+
+namespace pFlow
+{
+
+using realTriSurfaceField_D 	= triSurfaceField<VectorSingle, real> ;
+
+using realTriSurfaceField_H 	= triSurfaceField<VectorSingle, real, HostSpace> ;
+
+using realx3TriSurfaceField_D 	= triSurfaceField<VectorSingle, realx3> ;
+
+using realx3TriSurfaceField_H 	= triSurfaceField<VectorSingle, realx3, HostSpace> ;
+
+using realTriSurfaceField_HD 	= triSurfaceField<VectorDual, real> ;
+
+using realx3TriSurfaceField_HD 	= triSurfaceField<VectorDual, realx3> ;
+
+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>> ;
+
+
+}
+
+#endif //__trieSurfaceField_H__
diff --git a/src/phasicFlow/dictionary/dictionary.C b/src/phasicFlow/dictionary/dictionary.C
new file mode 100644
index 00000000..9540e5b1
--- /dev/null
+++ b/src/phasicFlow/dictionary/dictionary.C
@@ -0,0 +1,819 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+
+#include "dictionary.H"
+#include "uniquePtr.H"
+#include "error.H"
+#include "streams.H"
+
+
+
+pFlow::dictionary pFlow::dictionary::nullDict;
+
+
+// better to move it to the abstract class
+// with an static member function. 
+bool pFlow::dictionary::readDictionary
+(
+	iIstream & is
+)
+{
+	// ensure that the entry list of new the dicrionary is empty
+	entries_.clear();
+
+
+	// empty dictionary
+    if (is.eof())
+    {
+        return true;
+    }
+
+    if (!is.good())
+    {
+        ioErrorInFile( is.name(), is.lineNumber() )<<
+        "iIstream is not good for reading tokens .... \n";
+        return false;
+    }
+
+    
+    // reads tokens one-by-one
+    token nextTok(is);
+    if( nextTok == token::END_BLOCK)
+    {
+    	ioErrorInFile( is.name(), is.lineNumber() )<<
+    	"Not expecting a } for the start of a dictionray \n";
+    	return false;
+    }
+    
+    bool hasBlockToken = true;
+    
+    // this is a sub-dict, so it should start with {
+	if(nextTok != token::BEGIN_BLOCK)
+	{
+		hasBlockToken = false;
+		is.putBack(nextTok);
+	}
+   
+	
+	//read all entries in ths dictionary
+    while ( !is.eof() && iEntry::createEntry(*this, is, hasBlockToken) )
+    {}
+
+
+    return true;
+}
+
+bool pFlow::dictionary::writeDictionary
+(
+	iOstream& os,
+	bool withBlock
+)const
+{
+	if(withBlock) os.beginBlock(keyword());
+
+	for( const auto& e:orderedEntries_)
+	{
+		if(e != nullptr )
+			e->write(os);
+	}
+	if(withBlock) os.endBlock();
+
+	return true;
+
+}
+
+pFlow::iEntry* pFlow::dictionary::findEntry
+(
+	const word& keyword
+)
+{
+	if( auto [ptr, exist] = entries_.find(keyword); exist)
+	{
+
+		return ptr;
+	
+	}
+
+	return nullptr;	
+}
+
+pFlow::iEntry* pFlow::dictionary::findEntry
+(
+	const word& keyword
+)const
+{
+	if( auto [ptr, exist] = entries_.find(keyword); exist)
+	{
+		return const_cast<iEntry*> (ptr);
+	}
+
+	return nullptr;	
+}
+
+
+pFlow::dictionary::dictionary
+()
+:
+	iEntry("NULL_DICT"),
+	name_("NULL_DICT"),
+	entries_(),
+	orderedEntries_(),
+	parDict_(dictionary::nullDict),
+	isGlobal_(false)
+{}
+
+pFlow::dictionary::dictionary
+(
+	const word& keyword
+)
+:
+	iEntry(keyword),
+	name_(keyword),
+	entries_(),
+	orderedEntries_(),
+	parDict_(dictionary::nullDict),
+	isGlobal_(false)
+{}
+
+
+pFlow::dictionary::dictionary
+(
+	const word& keyword,
+	bool global
+)
+:
+	iEntry(keyword),
+	name_(keyword),
+	entries_(),
+	orderedEntries_(),
+	parDict_(dictionary::nullDict),
+	isGlobal_(global)
+{
+}
+
+pFlow::dictionary::dictionary
+(
+	const word& keyword,
+	const fileSystem& file
+)
+:
+	iEntry(keyword),
+	name_(file.wordPath()),
+	entries_(),
+	orderedEntries_(),
+	parDict_(dictionary::nullDict),
+	isGlobal_(true)
+{
+	iFstream dictStream(file);
+
+	if(!read(dictStream))
+	{
+		ioErrorInFile(dictStream.name(), dictStream.lineNumber())<<
+		"error in reading dictionary from file "<< file <<endl;
+		fatalExit;
+	}
+
+}
+
+pFlow::dictionary::dictionary
+(
+	const word& keyword,
+	const dictionary& parDict
+)
+:
+	iEntry(keyword),
+	name_(groupNames(parDict.globalName(), keyword)),
+	entries_(),
+	orderedEntries_(),
+	parDict_(parDict),
+	isGlobal_(false)
+{
+
+}
+
+pFlow::dictionary::dictionary
+(
+	const word& keyword,
+	const dictionary& parDict,
+	iIstream& is
+)
+:
+	iEntry(keyword),
+	name_(groupNames(parDict.globalName(), keyword)),
+	entries_(),
+	orderedEntries_(),
+	parDict_(parDict),
+	isGlobal_(false)
+{
+
+	if( !readDictionary(is) )
+	{
+		ioErrorInFile(is.name(), is.lineNumber()) <<
+		"error in reading dictionary " << name_ <<endl;
+		fatalExit;
+	}
+}
+
+pFlow::dictionary::dictionary
+(
+	const word& keyword,
+	const dictionary& parDict,
+	const dictionary& dict
+)
+:
+	iEntry(keyword),
+	name_(groupNames(parDict.globalName(),keyword)),
+	entries_(),
+	orderedEntries_(),
+	parDict_(parDict),
+	isGlobal_(false)
+{
+
+	for( auto& entry : dict.orderedEntries_ )
+	{
+		if(entry)
+		{
+			auto ptr = entry->clone(*this); 
+			auto key = entry->name();
+
+			if( !addPtr(key, ptr) )
+			{
+				fatalErrorInFunction <<
+				" error in cloning dicrionary / dataEntry " << entry->globalName() <<endl;
+				fatalExit;
+			}
+		}
+	}
+
+}
+
+pFlow::dictionary::dictionary
+(
+	const dictionary& src
+)
+:
+	iEntry(src.keyword()),
+	name_(src.keyword()),
+	entries_(),
+	orderedEntries_(),
+	parDict_(dictionary::nullDict),
+	isGlobal_(src.isGlobal_)
+{
+
+	for( auto& entry: src.orderedEntries_)
+	{
+		
+		if(entry)
+		{
+			auto ptr = entry->clone(*this); 
+			auto key = entry->name();
+
+			if( !addPtr(key, ptr) )
+			{
+				fatalErrorInFunction <<
+				" error in cloning dicrionary / dataEntry " << entry->globalName() <<endl;
+				fatalExit;
+			}
+		}
+	}
+
+}
+
+pFlow::dictionary& pFlow::dictionary::operator=
+(
+	const dictionary& rhs
+)
+{
+	
+	if( &rhs == this)return *this;
+	
+	clear();
+
+	for( auto& entry: rhs.orderedEntries_)
+	{
+		
+		if(entry)
+		{
+			auto ptr = entry->clone(*this); 
+			auto key = entry->name();
+
+			if( !addPtr(key, ptr) )
+			{
+				fatalErrorInFunction <<
+				" error in cloning dicrionary / dataEntry " << entry->globalName() <<endl;
+				fatalExit;
+			}
+		}
+	}
+
+	return *this;
+}
+
+pFlow::dictionary* pFlow::dictionary::dictPtr()
+{
+	return this;
+}
+
+
+const pFlow::dictionary* pFlow::dictionary::dictPtr() const
+{
+	return this;
+}
+
+
+bool pFlow::dictionary::isDictionary() const
+{
+	return true;
+}
+
+pFlow::word pFlow::dictionary::globalName()const
+{
+	return name_;
+}
+
+
+const pFlow::dictionary& pFlow::dictionary::parrentDict() const
+{
+	return parDict_;
+}
+
+
+
+pFlow::dictionary& pFlow::dictionary::dict()
+{
+	return *this;
+}
+
+
+const pFlow::dictionary& pFlow::dictionary::dict() const
+{
+	return *this;
+}
+
+bool pFlow::dictionary::isFileDict()const
+{
+	return isGlobal_;
+}
+
+bool  pFlow::dictionary::addPtr
+(
+	const word& keyword,
+	uniquePtr<iEntry>& entry
+)
+{
+
+	if(entry == nullptr) return false;
+
+	iEntry* oldEntryPtr = nullptr;
+	iEntry* newEntryPtr = entry.get();
+
+	// 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";
+		// store the old pointer to entry
+		oldEntryPtr = ptr;
+	}
+	
+	
+	if( entries_.insertReplace(keyword, entry) )
+	{
+		if(oldEntryPtr)
+		{
+			// this should be replaced 
+			auto oIter = orderedEntries_.find(oldEntryPtr);
+			*oIter = newEntryPtr;
+		}
+		else
+		{
+			orderedEntries_.push_back(newEntryPtr);
+		}
+		return true;
+	}else
+	{
+		return false;
+	}
+
+}
+
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const float& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}
+
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const double& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}	
+
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const word& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}
+
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const int64& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}
+
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const int32& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	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
+(
+	const word& keyword,
+	const int8& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}
+
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const label& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}
+
+bool pFlow::dictionary::add
+(
+	const word& keyword,
+	const uint32& v
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this, token(v));
+	return addPtr(keyword, ptr);
+}
+
+
+bool pFlow::dictionary::addDict
+(
+	const word& keyword,
+	const dictionary& dict
+)
+{
+	uniquePtr<iEntry> ptr = makeUnique<dictionary>(keyword, *this, dict);
+	return addPtr(keyword, ptr);
+}
+
+void pFlow::dictionary::clear()
+{
+	orderedEntries_.clear();
+	entries_.clear();
+}
+
+pFlow::dictionary* pFlow::dictionary::subDictPtr
+(
+	const word& keyword
+)
+{
+	if( auto entry = findEntry(keyword); entry!= nullptr && entry->isDictionary()  )
+	{
+		return dynamic_cast<dictionary*>(entry);
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"keyword " << keyword<< " is not an sub-dictionary of " << this->globalName()<<endl;
+		fatalExit;
+		return this;	
+	}
+}
+
+pFlow::dictionary& pFlow::dictionary::subDict
+(
+	const word& keyword
+)
+{
+	
+	if( auto entry = findEntry(keyword); entry!= nullptr && entry->isDictionary()  )
+	{
+		return dynamic_cast<dictionary&>(*entry);
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"keyword " << keyword<< " is not an sub-dictionary of " << this->globalName()<<endl;
+		fatalExit;
+		return *this;	
+	}
+
+}
+
+const pFlow::dictionary& pFlow::dictionary::subDict
+(
+	const word& keyword
+) const
+{
+	
+	if( auto entry = findEntry(keyword); entry!= nullptr && entry->isDictionary()  )
+	{
+		return dynamic_cast<dictionary&>(*entry);
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"keyword " << keyword<< " is not an sub-dictionary of " << this->globalName()<<endl;
+		fatalExit;
+		return *this;	
+	}
+}
+
+pFlow::dataEntry* pFlow::dictionary::dataEntryPtr(const word& keyword)
+{
+	if( auto entry = findEntry(keyword); entry && !entry->isDictionary()  )
+	{
+		return dynamic_cast<dataEntry*>(entry);
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"keyword " << keyword<< " is not a dataEntry of " << this->globalName()<<endl;
+		fatalExit;
+		return nullptr;	
+	}
+}
+
+pFlow::dataEntry& pFlow::dictionary::dataEntryRef(const word& keyword)
+{
+	if( auto entry = findEntry(keyword); entry && !entry->isDictionary()  )
+	{
+		return dynamic_cast<dataEntry&>(*entry);
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"keyword " << keyword<< " is not a dataEntry of " << this->globalName()<<endl;
+		fatalExit;
+		return dataEntry::nullDataEntry;	
+	}
+}	
+
+const pFlow::dataEntry& pFlow::dictionary::dataEntryRef
+(
+	const word& keyword
+)const
+{
+	if( auto entry = findEntry(keyword); entry && !entry->isDictionary()  )
+	{
+		return dynamic_cast<dataEntry&>(*entry);
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"keyword " << keyword<< " is not a dataEntry of " << this->globalName()<<endl;
+		fatalExit;
+		return dataEntry::nullDataEntry;	
+	}
+}
+
+pFlow::dictionary& pFlow::dictionary::subDictOrCreate
+(
+	const word& keyword
+)
+{
+	if( auto entry = findEntry(keyword); entry!= nullptr && entry->isDictionary()  )
+	{
+		return dynamic_cast<dictionary&>(*entry);
+	}
+	else 
+	{
+		uniquePtr<iEntry> ptr = makeUnique<dictionary>(keyword, *this);
+		if( addPtr
+			(
+				keyword,
+				ptr
+			)
+		  )
+		{
+			return subDictOrCreate(keyword);
+		}
+		else
+		{
+			fatalErrorInFunction<<
+			"Unable to create sub-dictionary "<< keyword << " in dictionary " << globalName() <<endl;
+			fatalExit;
+		}
+	}
+	return *this;
+}
+
+size_t pFlow::dictionary::numEntries()const
+{
+	return entries_.size();
+}
+
+size_t pFlow::dictionary::numDataEntries()const
+{
+	size_t num = 0;
+	for(auto& e:entries_)
+	{
+		if( e.second && !e.second->isDictionary())
+		{
+			num++;
+		}
+	}
+	return num;
+}
+
+size_t pFlow::dictionary::numDictionaries()const
+{
+	size_t num = 0;
+	for(auto& e:entries_)
+	{
+		if( e.second && e.second->isDictionary())
+		{
+			num++;
+		}
+	}
+	return num;	
+}
+
+pFlow::wordList pFlow::dictionary::allKeywords()const
+{
+	wordList wl;
+
+	for(auto oe:orderedEntries_)
+	{
+		if(oe) wl.push_back( oe->keyword() );
+	}
+	return wl;
+}
+
+pFlow::wordList pFlow::dictionary::dataEntryKeywords()const
+{
+	wordList wl;
+
+	for(auto oe:orderedEntries_)
+	{
+		if( oe && !oe->isDictionary())
+		{
+			wl.push_back(oe->keyword());
+		}
+	}
+	return wl;
+}
+
+// return a list of all dictionary keywords
+pFlow::wordList pFlow::dictionary::dictionaryKeywords()const
+{
+	wordList wl;
+
+	for(auto& oe:orderedEntries_)
+	{
+		if( oe && oe->isDictionary())
+		{
+			wl.push_back(oe->keyword());
+		}
+	}
+	return wl;
+}
+
+bool pFlow::dictionary::containsDictionay
+(
+	const word& name
+)const
+{
+	if( auto  ptr = findEntry(name); ptr)
+	{
+		return ptr->isDictionary();
+	}
+	return false;
+}
+
+bool pFlow::dictionary::containsDataEntry
+(
+	const word& name
+)const
+{
+	if( auto  ptr = findEntry(name); ptr)
+	{
+		return !ptr->isDictionary();
+	}
+	return false;
+}
+
+bool pFlow::dictionary::read(iIstream& is)
+{
+	token tok;
+	if(!isFileDict() && !readKeyword(is, keyword_, tok))
+	{
+		ioErrorInFile(is.name(), is.lineNumber()) <<
+		"expected a valid keyword for dictionary but found " << tok <<endl;
+		fatalExit;
+	}
+
+	if( !readDictionary(is) )
+	{
+		ioErrorInFile(is.name(), is.lineNumber()) <<
+		"error in reading dictionary " << keyword_ <<endl;
+		fatalExit;
+	}
+
+	return true;
+}
+
+
+bool pFlow::dictionary::write(iOstream& os) const
+{
+	if(! writeDictionary(os, !isFileDict()) )
+	{
+		ioErrorInFile( os.name(), os.lineNumber());
+		fatalExit;
+	}
+	return true;
+}
+
+
+pFlow::uniquePtr<pFlow::iEntry> pFlow::dictionary::clone() const
+{
+	return makeUnique<dictionary>(*this);
+}
+
+
+pFlow::iEntry* pFlow::dictionary::clonePtr() const
+{
+	
+	auto ptr = makeUnique<dictionary>(*this);
+	return ptr.release();
+}
+
+pFlow::uniquePtr<pFlow::iEntry> pFlow::dictionary::clone
+(
+	const dictionary& parDict
+) const
+{
+	return makeUnique<dictionary>(this->keyword(), parDict, *this);
+}
+
+pFlow::iEntry* pFlow::dictionary::clonePtr
+(
+	const dictionary& parDict
+) const
+{
+	auto ptr = makeUnique<dictionary>(this->keyword(), parDict, *this);
+	return ptr.release();
+}
\ No newline at end of file
diff --git a/src/phasicFlow/dictionary/dictionary.H b/src/phasicFlow/dictionary/dictionary.H
new file mode 100644
index 00000000..e1f39fbe
--- /dev/null
+++ b/src/phasicFlow/dictionary/dictionary.H
@@ -0,0 +1,344 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+
+#ifndef __dictionary_H__
+#define __dictionary_H__
+
+#include "types.H"
+#include "iEntry.H"
+#include "dataEntry.H"
+#include "MapPtr.H"
+#include "List.H"
+#include "fileSystem.H"
+
+namespace pFlow
+{
+
+
+class dictionary
+:
+	public iEntry
+{
+protected:
+
+	//// - Data members
+
+		// global name of dictionary, separated with dots
+		word name_;
+
+		// all the entries (data and dictionary) of the current dictionary
+		wordOrderedMapPtr<iEntry> entries_;
+
+		// entries in order of insertion
+		List<iEntry*> orderedEntries_;
+
+		// - ref to parrent dictionary
+		const dictionary& parDict_;
+
+		bool isGlobal_;
+
+
+	//// - protected methods 
+
+		// - 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
+		iEntry* findEntry(const word& keyword)const;
+
+		// - reads a dataEntry with keyword from dictionary
+		template<typename T>
+		bool readDataEntry( const word& keyword, T& val)const;
+
+		// - read dictionary from stream - without keyword
+		bool readDictionary(iIstream & is);
+
+		// - write dictionary to stream - with keyword
+		bool writeDictionary(iOstream& os, bool withBlock = true)const;
+	
+
+public:
+
+	// null dictionary object, to be used for references 
+	static dictionary nullDict;
+
+	TypeName("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)
+		dictionary(const word& keyword, bool global);
+
+		// - construct a dictionary with name and read it from file 
+		dictionary(const word& keyword, const fileSystem& file);
+
+		// - 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
+		dictionary( const word& keyword, const dictionary& parDict, iIstream& is);
+
+		// - 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
+		dictionary(const dictionary& );
+
+
+		// - assignment preserve name of this dictionary 
+		// - only entries are transfered with ownership
+		dictionary& operator=(const dictionary& rhs);
+
+
+	//// - Methods
+
+		// - pointer to this dictionary
+		virtual dictionary* dictPtr();
+		
+		// - pointer to this dictionary
+		virtual const dictionary* dictPtr() const;
+		
+		// - if this is a dictionary
+		virtual bool isDictionary() const;
+
+		// - global name of entry, separated with dots
+		virtual word globalName()const;
+
+		// - const ref to parrent dictionary 
+		virtual const dictionary& parrentDict() const;
+
+		// - ref to this dictionary, if it is a dictionary
+		virtual dictionary& dict();
+
+		// - const ref to this dictionary, if it is a dictionary
+		virtual const dictionary& dict() const;
+
+		// - 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 );
+
+		// - add a float dataEntry 
+		bool add(const word& keyword, const float& v);
+
+		// - add a double dataEntry
+		bool add(const word& keyword, const double& v);
+
+		// - add a word dataEntry
+		bool add(const word& keyword, const word& v);
+
+		// - add a int64 dataEntry
+		bool add(const word& keyword, const int64& v);
+
+		// - 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
+		bool add(const word& keyword, const int8& v);
+
+		// - add a label dataEntry
+		bool add(const word& keyword, const label& v);
+
+		// - add a uint32 dataEntry
+		bool add(const word& keyword, const uint32& v);
+
+		// add a dictionary with the specifiedd keyword
+		bool addDict(const word& keyword, const dictionary& dict);
+
+		// - add a dataEntry of type T
+		template<typename T>
+		bool add(const word& keyword, const T& v );
+
+
+		void clear();
+
+		// - pointer to a subdictionary 
+		//   fatalExit if not found
+		dictionary* subDictPtr(const word& keyword);
+
+		// - ref to a subdictioanry 
+		//   fatalExit if not found 
+		dictionary& subDict(const word& keyword);
+
+		// - 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
+		dataEntry* dataEntryPtr(const word& keyword);
+
+		// - 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 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
+		dictionary& subDictOrCreate(const word& keyword);
+		
+		// - 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
+		template<typename T>
+		T getValOrSet(const word& keyword, const T& setVal)const;
+
+		// return number of entris in this dictionary
+		size_t numEntries()const;
+		
+		// return number of non-nullptr dataEntries
+		size_t numDataEntries()const;
+
+		// return number of non-nullptr dictionaries
+		size_t numDictionaries()const;
+
+		// return all keywords (non-nullptr) in this dictionary
+		wordList allKeywords()const;
+
+		// return a list of all dataEntries (non-nullptr) keywords
+		wordList dataEntryKeywords()const;
+
+		// return a list of all dictionary (non-null) keywords
+		wordList dictionaryKeywords()const;
+
+		// check if a sub-dictionary exists
+		bool containsDictionay(const word& name)const;
+		
+		// check if a data entry exist
+		bool containsDataEntry(const word& name)const;
+
+		// 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
+		virtual uniquePtr<iEntry> clone(const dictionary& parDict)const;
+
+		virtual iEntry* clonePtr(const dictionary& parDict) const;
+
+
+	//// IO operations 
+
+		// - read from stream
+		virtual bool read(iIstream& is);
+
+		// - write to stream
+		virtual bool write(iOstream& os) const;
+
+};
+
+
+
+template<typename T>
+bool dictionary::add(const word& keyword, const T& v )
+{
+
+	uniquePtr<iEntry> ptr = makeUnique<dataEntry>(keyword, *this ,v);
+	return addPtr(keyword, ptr);
+		
+}
+
+
+template<typename T>
+bool dictionary::readDataEntry
+(
+	const word& keyword,
+	T& val
+)const 
+{
+	
+	if( auto entry = findEntry(keyword); entry!= nullptr && !entry->isDictionary()  )
+	{
+		iTstream& is = dynamic_cast<dataEntry&>(*entry).stream();
+	
+		is >> val;
+		return true;
+	}
+	else
+	{
+		return false;	
+	}
+
+}
+
+template<typename T>
+T dictionary::getVal
+(
+	const word& keyword
+)const 
+{
+	T val{};
+	if(!readDataEntry(keyword, val))
+	{
+		fatalErrorInFunction <<
+		"cannot find dataEntry "<< keyword <<" in dictionary "<< globalName()<<endl;
+		fatalExit;
+	}
+	return val;
+}
+
+template<typename T>
+T dictionary::getValOrSet
+(
+	const word& keyword,
+	const T& setVal
+)const 
+{
+	T val{};
+	if( readDataEntry(keyword, val) )
+	{
+		return val;
+	}
+	else
+	{
+		return setVal;
+	}
+}
+
+}
+
+
+#endif // __dictionary_H__
diff --git a/src/phasicFlow/dictionary/entry/dataEntry.C b/src/phasicFlow/dictionary/entry/dataEntry.C
new file mode 100644
index 00000000..29202c08
--- /dev/null
+++ b/src/phasicFlow/dictionary/entry/dataEntry.C
@@ -0,0 +1,375 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+
+#include "dataEntry.H"
+#include "dictionary.H"
+#include "error.H"
+#include "iIstream.H"
+#include "iOstream.H"
+#include "iTstream.H"
+#include "oTstream.H"
+
+pFlow::dataEntry pFlow::dataEntry::nullDataEntry;
+
+bool pFlow::dataEntry::readDataEntry
+(
+	iIstream& is
+)
+{	
+	// reset the stream (only tokens)
+	tokenStream_.reset();
+
+	int32 level = 0;
+	token nextTok;
+
+	while
+	(
+		!is.read(nextTok).bad() && nextTok.good() && 
+		!(level == 0 && nextTok == token::END_STATEMENT)
+	)
+	{
+
+		if( nextTok.isPunctuation() )
+		{
+			auto t = nextTok.pToken();
+			if( t == token::BEGIN_LIST ||
+				t == token::BEGIN_BLOCK ||
+				t == token::BEGIN_SQR
+				)
+			{
+				level ++;
+			}
+			else if (
+				t == token::END_LIST ||
+				t == token::END_BLOCK ||
+				t == token::END_SQR )
+			{
+				level--;
+			}
+		}
+
+		// checks if there are imbalance (, { or [
+		if( level < 0 )
+		{
+			ioErrorInFile(is.name(), is.lineNumber()) <<
+			"number of opening and closing ( or, [ or { does not match, closing is greater than opening \n";
+			fatalExit;
+		}
+
+		// add token to tokenStream
+		// iTstream will take care of invalid tokens (space, tab, new line and null)
+		tokenStream_.appendToken(nextTok);
+	}
+
+
+	if( level )
+	{
+		ioErrorInFile(is.name(), is.lineNumber()) <<
+		"imbalance number of ( or { or [ \n";
+		fatalExit; 
+	}
+
+	is.fatalCheck(FUNCTION_NAME);
+    return nextTok.good();
+}
+
+
+bool pFlow::dataEntry::writeDataEntry
+(
+	iOstream& os
+)const
+{
+	writeKeyword(os);
+	auto lastPuncBegin = false;
+	auto lastPuncEnd = false;
+	auto applySpace = false;
+
+	const tokenList& tokens = tokenStream_.tokens();
+
+	
+	for(auto tok = tokens.cbegin(); tok != tokens.cend(); tok++)
+	{
+		if(*tok == endStatementToken()) continue;
+		
+
+		if(isBeginToken(*tok))
+		{
+			if(lastPuncEnd) 
+			{
+				os<<spaceToken();
+				os << *tok;
+			}
+			else
+			{
+				os << *tok;	
+			}
+			lastPuncBegin = true;
+			lastPuncEnd   = false;
+
+		}
+		else if(isEndToken(*tok))
+		{
+			if(lastPuncBegin)
+			{
+				 os<<spaceToken();
+				 os << *tok;
+			}
+			else
+				os << *tok;
+			lastPuncEnd = true;
+			lastPuncBegin = false;
+		}
+		else
+		{
+			if(!lastPuncBegin&&applySpace) os<<spaceToken();
+			os << *tok;
+			lastPuncEnd = false;
+			lastPuncBegin = false;
+			applySpace = true;			
+		}
+		
+		
+	}
+
+	os.endEntry();
+
+	return true;
+}
+
+pFlow::dataEntry::dataEntry()
+:
+	iEntry("NULL_DATAENTRY"),
+	parDict_(dictionary::nullDict),
+	tokenStream_(parDict_.globalName())
+{}
+
+
+pFlow::dataEntry::dataEntry
+(
+	const word& keyword,
+	const dictionary& parDict
+)
+:
+	iEntry(keyword),
+	parDict_(parDict),
+	tokenStream_
+	(
+		groupNames(parDict.globalName(), keyword)
+	)
+{
+
+}
+
+
+pFlow::dataEntry::dataEntry
+(
+	const word& keyWord,
+	const dictionary& parDict,
+	const iTstream& is
+)
+:
+	iEntry(keyWord),
+	parDict_(parDict),
+	tokenStream_
+	(
+		groupNames(parDict.globalName(), keyWord),
+		is.tokens()
+	)
+{
+	tokenStream_.rewind();
+}
+
+pFlow::dataEntry::dataEntry
+(
+	const word& keyWord,
+	const dictionary& parDict,
+	iIstream& is
+)
+:
+	iEntry(keyWord),
+	parDict_(parDict),
+	tokenStream_
+	(
+		groupNames(parDict.globalName(),keyWord)
+	)
+{
+	// reads the entry
+	if( !readDataEntry(is) )
+	{
+		ioErrorInFile(is.name(), is.lineNumber() ) <<
+		"error in reading data entry from file \n";
+		fatalExit;
+	}
+	tokenStream_.rewind();
+}
+
+pFlow::dataEntry::dataEntry
+(
+	const word& keyword,
+	const dictionary& parDict,
+	const token& tok
+)
+:
+	iEntry(keyword),
+	parDict_(parDict),
+	tokenStream_
+	(
+		groupNames(parDict.globalName(),keyword)
+	)
+{
+	
+	tokenStream_.appendToken(tok);
+	tokenStream_.rewind();
+}	
+
+
+pFlow::dataEntry::dataEntry
+(
+	const word& keyword,
+	const dictionary& parDict,
+	const dataEntry& entry
+)
+:
+	dataEntry(keyword, parDict)
+{
+	tokenStream_ = entry.tokenStream_.tokens();
+	tokenStream_.rewind();
+}
+
+
+pFlow::iTstream& pFlow::dataEntry::stream
+(
+)
+{
+	tokenStream_.rewind();
+	return tokenStream_;
+}
+
+
+pFlow::dictionary* pFlow::dataEntry::dictPtr()
+{
+	fatalErrorInFunction<<
+	"Request for an entry that is not a dictionray. Entry name is " << globalName() << endl;
+	fatalExit;
+	return nullptr;
+}
+
+
+const pFlow::dictionary* pFlow::dataEntry::dictPtr() const
+{
+	fatalErrorInFunction<<
+	"Request for an entry that is not a dictionray. Entry name is " << globalName() << endl;
+	fatalExit;
+	return nullptr;
+}
+
+bool pFlow::dataEntry::isDictionary()const
+{
+	return false;
+}
+
+pFlow::word pFlow::dataEntry::globalName()const
+{
+	return tokenStream_.name();
+}
+
+
+const pFlow::dictionary& pFlow::dataEntry::parrentDict() const
+{
+	return parDict_;
+}
+
+
+pFlow::dictionary& pFlow::dataEntry::dict()
+{
+	fatalErrorInFunction<<
+	"Request for an entry that is not a dictionray. Entry name is " << globalName() << endl;
+	fatalExit;
+	return const_cast<dictionary&>(parDict_);
+}
+
+
+const pFlow::dictionary& pFlow::dataEntry::dict() const
+{
+	fatalErrorInFunction<<
+	"Request for an entry that is not a dictionray. Entry name is " << globalName() << endl;
+	fatalExit;
+	return parDict_;
+}
+
+
+pFlow::uniquePtr<pFlow::iEntry> pFlow::dataEntry::clone() const 
+{
+	return makeUnique<dataEntry>(*this);
+}
+
+
+pFlow::iEntry* pFlow::dataEntry::clonePtr() const 
+{
+	auto ptr = makeUnique<dataEntry>(*this);
+	return ptr.release();
+}
+
+pFlow::uniquePtr<pFlow::iEntry> pFlow::dataEntry::clone(const dictionary& parDict) const 
+{
+	return makeUnique<dataEntry>(this->keyword(), parDict, *this);
+}
+
+pFlow::iEntry* pFlow::dataEntry::clonePtr(const dictionary& parDict) const 
+{
+	auto ptr = makeUnique<dataEntry>(this->keyword(), parDict, *this);	
+	return ptr.release();
+}
+
+///
+bool pFlow::dataEntry::read(iIstream& is)
+{
+	token tok;
+	if(!readKeyword(is, keyword_, tok))
+	{
+		ioErrorInFile(is.name(), is.lineNumber()) <<
+		"expected a valid keyword for dataEntry but found " << tok <<endl;
+		fatalExit;
+	}
+
+	if(!readDataEntry(is) )
+	{
+		fatalErrorInFunction<<
+		"unsucceful in reading dataEntry from " << is.name() <<endl;
+		fatalExit;
+	}
+	return true;
+}
+
+
+
+bool pFlow::dataEntry::write(iOstream& os) const
+{
+	if( !writeDataEntry(os) )
+	{
+		ioErrorInFile( os.name(), os.lineNumber() );
+		fatalExit;
+	}
+	
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/dictionary/entry/dataEntry.H b/src/phasicFlow/dictionary/entry/dataEntry.H
new file mode 100644
index 00000000..2c22f9f2
--- /dev/null
+++ b/src/phasicFlow/dictionary/entry/dataEntry.H
@@ -0,0 +1,163 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+
+#ifndef __dataEntry_H__
+#define __dataEntry_H__
+
+
+#include "iEntry.H"
+#include "iTstream.H"
+#include "oTstream.H"
+
+
+
+namespace pFlow
+{
+
+class dictionary;
+
+
+class dataEntry
+:
+	public iEntry
+{
+
+protected:
+
+	//// - data memebers
+
+		// - ref to parrent dictionary
+		const dictionary& parDict_;
+
+		// - list the tokens as input token stream
+		iTstream tokenStream_;
+
+
+	//// - protected member functions
+
+		// - read dataEntry from stream
+		bool readDataEntry(iIstream& is);
+
+		// - write dataEntry to stream
+		bool writeDataEntry(iOstream& os) const;
+
+public:
+
+	static dataEntry nullDataEntry;
+
+	//// - constructors
+
+		// - construct null dataEntry
+		dataEntry();
+
+		// - construct from keyword and parDict, empty dataEntry
+		dataEntry(const word& keyword, const dictionary& parDict);
+
+		// - 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
+		dataEntry(const word& keyword, const dictionary& parDict, const token& tok);
+
+		// - 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
+		dataEntry(const word& keyword, const dictionary& parDict, const dataEntry& entry );
+		
+		// - copy construct
+		dataEntry(const dataEntry& src )= default;
+
+
+	//// - Methods
+	
+		// - global name of entry, separated with dots
+		virtual word globalName()const;
+
+		
+		// - access to token stream
+		virtual iTstream& stream();
+
+		// - not permited to be called
+		virtual dictionary* dictPtr();
+		
+		// - not permited to be called
+		virtual const dictionary* dictPtr() const;
+		
+		// - should returen false;
+		virtual bool isDictionary()const;
+		
+		// - const ref to parrent dictionary 
+		virtual const dictionary& parrentDict() const;
+
+		// - not permited to be called
+		virtual dictionary& dict();
+
+		// - not permited to be called
+		virtual const dictionary& dict() const;
+
+		// clone the object
+		virtual iEntry* clonePtr() const;
+
+		virtual uniquePtr<iEntry> clone() const;
+
+		// clone the object and change its ownership to parDict 
+		virtual iEntry* clonePtr(const dictionary& parDict) const;
+
+		virtual uniquePtr<iEntry> clone(const dictionary& parDict)const;
+
+	//// - IO operations 
+
+		// - read from stream
+		virtual bool read(iIstream& is);
+
+		// - write to stream
+		virtual bool write(iOstream& os) const;
+
+};
+
+
+
+
+template<typename T>
+dataEntry::dataEntry(const word& keyword, const dictionary& parDict, const T& v)
+:
+	dataEntry(keyword, parDict)
+{
+
+	oTstream os("oTStream for " + globalName());
+
+	os<< v << endStatementToken();
+
+	tokenStream_ = std::move(os.tokens());
+}
+
+
+} // pFlow
+
+
+#endif //__dataEntry_H__
diff --git a/src/phasicFlow/dictionary/entry/iEntry.C b/src/phasicFlow/dictionary/entry/iEntry.C
new file mode 100644
index 00000000..1be43760
--- /dev/null
+++ b/src/phasicFlow/dictionary/entry/iEntry.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+#include "iEntry.H"
+#include "dictionary.H"
+#include "dataEntry.H"
+#include "error.H"
+#include "iOstream.H"
+#include "iIstream.H"
+
+
+bool pFlow::iEntry::readKeyword
+(
+	iIstream &is,
+	word& keyword,
+	token& tok
+)
+{
+	
+	while
+	(
+		!is.read(tok).bad() &&
+		!is.eof() &&
+		tok.good()
+	)
+	{
+		if(tok == token::END_STATEMENT) continue;
+		
+		if( tok.isWord())
+		{
+			keyword = tok.wordToken();
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	return false;
+}
+
+
+bool pFlow::iEntry::createEntry
+(
+	dictionary& parDict,
+	iIstream& is,
+	bool hasBlockToken
+)
+{
+	is.fatalCheck(FUNCTION_NAME);
+
+	// reads tokens one-by-one
+    word key;
+    token nextTok;
+    
+    if( auto isKey = iEntry::readKeyword(is, key, nextTok ); isKey )
+    {
+	    //output<< key << " "<<nextTok <<endl;
+    	is.read(nextTok);
+    	if( is.eof() || is.bad() || !nextTok.good() )
+    	{
+    		ioErrorInFile(is.name(), is.lineNumber())<<
+    		"expecting a valid token after keyword " << key << endl;
+    		fatalExit;
+    	}
+       // output<< nextTok<<endl;
+    	is.putBack(nextTok);
+    	
+    	if( nextTok == token::BEGIN_BLOCK )
+    	{
+            
+            uniquePtr<iEntry> ptr = makeUnique<dictionary>(key, parDict, is);
+            
+    		if( !parDict.addPtr(key, ptr ))
+    		{
+    			fatalErrorInFunction <<
+    			"unable to add dicrionary " << key << 
+    			" to dictionary " << parDict.globalName() <<endl;
+    			fatalExit;
+    		}
+    	}
+    	else
+    	{
+            uniquePtr<iEntry> ptr = makeUnique<dataEntry>(key, parDict, is);
+            
+    		if( !parDict.addPtr(key, ptr ) )
+    		{
+    			fatalErrorInFunction << 
+    			"unable to add dataEntry " << key << 
+    			" to dictionary " << parDict.globalName() <<endl;
+    			fatalExit;
+    		}
+    	}
+    }
+    else
+    {
+        
+    	if( nextTok.good() )
+    	{
+    		if(hasBlockToken)
+            { 
+                if(nextTok != token::END_BLOCK )
+        		{
+        			ioErrorInFile(is.name(), is.lineNumber())<<
+        			"expecting a } but found "<< nextTok <<endl;
+        			fatalExit;
+        		}else
+                {
+                    return false;
+                }	
+        		
+            }else
+            {
+                ioErrorInFile(is.name(), is.lineNumber())<<
+                "not expecting " << nextTok <<endl;
+                return false;
+            }
+    		
+    	}
+    	else if( !is.eof())
+    	{
+    		ioErrorInFile(is.name(), is.lineNumber())<<
+    		"error in reading next token. \n";
+    		fatalExit;
+    	}
+    	
+    }
+
+    return true;
+}
+
+
+bool pFlow::iEntry::writeKeyword
+(
+    iOstream& os
+)const
+{
+    os.writeWordKeyword(keyword_);
+    os.fatalCheck("pFlow::iEntry::writeKeyword");
+    return true;
+}
+
+
+pFlow::iOstream& pFlow::operator << (iOstream& os, const iEntry& e)
+{
+    if(!e.write(os))
+    {
+        ioErrorInFile(os.name(), os.lineNumber())<<
+        "Error in wrting to file \n";
+        fatalExit;
+    }
+	return os;
+}
+
+pFlow::iIstream& pFlow::operator >> (iIstream& is, iEntry& e)
+{	
+    if( !e.read(is))
+    {
+        ioErrorInFile(is.name(), is.lineNumber())<<
+        "Error in reading from file \n";
+        fatalExit;
+    }
+
+	return is; 
+}
\ No newline at end of file
diff --git a/src/phasicFlow/dictionary/entry/iEntry.H b/src/phasicFlow/dictionary/entry/iEntry.H
new file mode 100644
index 00000000..4d8d7572
--- /dev/null
+++ b/src/phasicFlow/dictionary/entry/iEntry.H
@@ -0,0 +1,160 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+#ifndef __iEntry_H__
+#define __iEntry_H__
+
+
+#include "types.H"
+#include "typeInfo.H"
+#include "uniquePtr.H"
+
+
+namespace pFlow
+{
+
+
+class dictionary;
+
+class iEntry
+{
+
+public:
+	
+	//// - public static methods
+
+		// - read a keyword from stream 
+		static bool readKeyword(iIstream &is, word& keyword, token& tok );
+
+		// - create an entry (dataEntry or dictionary) from stream 
+		static bool createEntry(dictionary& parDict, iIstream& is, bool hasBlockToken = false);
+
+protected:
+
+	// keyWord of entry
+	word keyword_;
+
+	bool writeKeyword(iOstream& os)const;
+
+public:
+	
+
+	TypeName("iEntry");
+
+	//// - Constructors
+
+		// - empty constructor
+		iEntry()
+		{}
+
+		// - construct with a keyword
+		iEntry(const word& key)
+		{
+			// this moved here due to a very strange core dumped error!
+			keyword_ = key;
+		}
+
+		// - destructor
+		virtual ~iEntry()
+		{}
+
+
+	//// - Methods
+
+		// - return keyword
+		virtual const word& keyword() const
+		{
+			return keyword_;
+		}
+
+		// - return keyword
+		virtual word& keyword()
+		{
+			return keyword_;
+		}
+
+		virtual word name()const
+		{
+			return keyword();
+		}
+
+		// global name of entry, separated with dots
+		virtual word globalName()const = 0;
+
+		// - pointer to this dictionary
+		virtual dictionary* dictPtr()
+		{
+			return nullptr;
+		}
+
+		// - const pointer to this dictionary
+		virtual const dictionary* dictPtr() const
+		{
+			return nullptr;
+		}
+
+		// - if this is a dictionary
+		virtual bool isDictionary() const
+		{
+			return false;
+		}
+
+		// - const ref to parrent dictionary 
+		virtual const dictionary& parrentDict() const = 0;
+		
+		// - ref to this dictionary, if it is a dictionary
+		virtual dictionary& dict() = 0;
+
+		// - const ref to this dictionary, if it is a dicrionary
+		virtual const dictionary& dict() const = 0;
+
+		// clone the object
+		virtual iEntry* clonePtr() const = 0;
+
+		virtual uniquePtr<iEntry> clone() const = 0;
+
+		// clone the object and change its ownership to parDict 
+		virtual iEntry* clonePtr(const dictionary& parDict) const = 0;
+
+		virtual uniquePtr<iEntry> clone(const dictionary& parDict)const = 0;
+
+	//// - IO operatoins
+
+		// read from stream
+		virtual bool read(iIstream& is) = 0;
+
+		// write to stream
+		virtual bool write(iOstream& os) const =0;
+
+};
+
+
+iOstream& operator << (iOstream& os, const iEntry& e);
+
+
+iIstream& operator >> (iIstream& is, iEntry& e);
+
+
+}
+
+
+#endif //__iEntry_H__
diff --git a/src/phasicFlow/dictionary/twoPartEntry/twoPartEntry.C b/src/phasicFlow/dictionary/twoPartEntry/twoPartEntry.C
new file mode 100644
index 00000000..2b83db0d
--- /dev/null
+++ b/src/phasicFlow/dictionary/twoPartEntry/twoPartEntry.C
@@ -0,0 +1,48 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+
+#include "twoPartEntry.H"
+
+
+pFlow::twoPartEntry::twoPartEntry
+(
+	dataEntry entry
+)
+:
+	keyword_(entry.keyword()),
+	secondPart_(keyword_)
+{
+	iTstream& iT = entry.stream();
+
+	iT >> firstPart_;
+
+	token t;
+
+	while(true)
+	{
+		iT.read(t);
+		secondPart_.appendToken(t);
+		if(iT.eof())break;
+	}
+
+}
\ No newline at end of file
diff --git a/src/phasicFlow/dictionary/twoPartEntry/twoPartEntry.H b/src/phasicFlow/dictionary/twoPartEntry/twoPartEntry.H
new file mode 100644
index 00000000..c3c45870
--- /dev/null
+++ b/src/phasicFlow/dictionary/twoPartEntry/twoPartEntry.H
@@ -0,0 +1,70 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+// based on OpenFOAM dictionary, with some modifications/simplifications
+// to be tailored to our needs
+
+
+#ifndef __twoPartEntry_H__
+#define __twoPartEntry_H__
+
+
+
+#include "dataEntry.H"
+
+
+namespace pFlow
+{
+
+
+class twoPartEntry
+{
+protected:
+	word 		keyword_;
+	word 		firstPart_;
+	mutable iTstream	secondPart_; 
+public:
+
+	twoPartEntry(dataEntry entry);
+
+	const word& keyword()const
+	{
+		return keyword_;
+	}
+
+	const word& firstPart()const
+	{
+		return firstPart_;
+	}
+
+	template<typename T>
+	T	secondPartVal()const
+	{
+		T val;
+		secondPart_.rewind();
+		secondPart_ >> val;
+		return val;
+	}
+
+};
+	
+
+}
+
+#endif
diff --git a/src/phasicFlow/eventSubscriber/eventMessage.H b/src/phasicFlow/eventSubscriber/eventMessage.H
new file mode 100644
index 00000000..6e84edd6
--- /dev/null
+++ b/src/phasicFlow/eventSubscriber/eventMessage.H
@@ -0,0 +1,116 @@
+/*------------------------------- 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 __eventMessage_H__
+#define __eventMessage_H__
+
+
+namespace pFlow
+{
+
+class eventMessage
+{
+public:
+	enum event : unsigned int
+	{
+		DELETE	 		= 1,
+		INSERT  		= 2,
+		REARRANGE  		= 4,
+		SIZE_CHANGED 	= 8,
+		CAP_CHANGED 	= 16,
+		RANGE_CHANGED   = 32
+	};
+
+protected:
+
+	 unsigned int message_;
+
+public:
+
+	eventMessage()
+	:
+		message_(0)
+	{}
+
+	eventMessage(unsigned int msg)
+	:
+		message_(msg)
+	{}
+
+	inline unsigned int get()const
+	{
+		return message_;
+	}
+
+	inline void set(unsigned int msg)
+	{
+		message_= msg;
+	}
+
+	inline void add(unsigned int msg)
+	{
+		message_ = message_+ msg;
+	}
+
+	inline bool equivalentTo( const event& evt )const
+	{
+		return (message_ & evt) == evt;
+	}
+
+	inline bool isNull()const
+	{
+		return message_ == 0u;
+	}	
+	inline bool isDeleted()const
+	{
+		return equivalentTo(event::DELETE);
+	}
+
+	inline bool isInsert()const
+	{
+		return equivalentTo(event::INSERT);
+	}
+
+	inline bool isRearranged()const
+	{
+		return equivalentTo(event::REARRANGE);
+	}
+
+	inline bool isSizeChanged()const
+	{
+		return equivalentTo(event::SIZE_CHANGED);
+	}
+
+	inline bool isCapacityChanged()const
+	{
+		return equivalentTo(event::CAP_CHANGED);
+	}
+
+	inline bool isRangeChanged()const
+	{
+		return equivalentTo(event::RANGE_CHANGED);
+	}
+
+};
+
+}
+
+#endif // __eventMessage_H__
diff --git a/src/phasicFlow/eventSubscriber/eventObserver.C b/src/phasicFlow/eventSubscriber/eventObserver.C
new file mode 100644
index 00000000..69d117e9
--- /dev/null
+++ b/src/phasicFlow/eventSubscriber/eventObserver.C
@@ -0,0 +1,56 @@
+/*------------------------------- 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 "eventObserver.H"
+#include "eventSubscriber.H" 
+
+pFlow::eventObserver::eventObserver():
+	subscriber_(nullptr),
+	subscribed_(false)
+{}
+
+pFlow::eventObserver::eventObserver
+(
+	const eventSubscriber& subscriber,
+	bool subscribe
+)
+:
+	subscriber_(&subscriber),
+	subscribed_(false)
+{
+	if(subscribe && subscriber_)
+	{
+		subscribed_ = subscriber_->subscribe(this);
+	}
+}
+
+pFlow::eventObserver::~eventObserver()
+{
+	if(subscribed_ && subscriber_)
+		subscriber_->unsubscribe(this);
+}
+
+bool pFlow::eventObserver::subscribe(const eventSubscriber& subscriber)
+{
+	subscriber_ = &subscriber;
+	subscribed_ = subscriber_->subscribe(this);
+	return subscribed_;
+}
+
diff --git a/src/phasicFlow/eventSubscriber/eventObserver.H b/src/phasicFlow/eventSubscriber/eventObserver.H
new file mode 100644
index 00000000..9ef0891f
--- /dev/null
+++ b/src/phasicFlow/eventSubscriber/eventObserver.H
@@ -0,0 +1,65 @@
+/*------------------------------- 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 __eventObserver_H__
+#define __eventObserver_H__
+
+#include "eventMessage.H"
+
+namespace pFlow
+{
+
+class eventSubscriber;
+
+
+class eventObserver
+{
+protected:
+	
+	const eventSubscriber* subscriber_ = nullptr;
+	
+	// if this object is linked to subscriber 
+	bool subscribed_ = false;
+
+public:
+
+	eventObserver();
+
+	eventObserver(const eventSubscriber& subscriber, bool subscribe = true );
+
+	virtual ~eventObserver();
+
+	inline bool subscribed()const {return subscribed_;}
+
+	bool subscribe(const eventSubscriber& subscriber);
+	
+	inline void invalidateSubscriber()
+	{
+		subscribed_ = false;
+	}
+
+	virtual bool update(const eventMessage& msg)=0;
+};
+
+} // pFlow
+
+
+#endif // __eventObserver_H__
diff --git a/src/phasicFlow/eventSubscriber/eventSubscriber.C b/src/phasicFlow/eventSubscriber/eventSubscriber.C
new file mode 100644
index 00000000..0a804b4d
--- /dev/null
+++ b/src/phasicFlow/eventSubscriber/eventSubscriber.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#include "eventSubscriber.H"
+#include "Set.H"
+
+pFlow::eventSubscriber::~eventSubscriber()
+{
+	for(auto& observer:observerList_)
+	{
+		observer->invalidateSubscriber();
+	}
+}
+
+bool pFlow::eventSubscriber::subscribe
+(
+	eventObserver* observer
+)const
+{
+	if(observer)
+	{
+		observerList_.push_back(observer);
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+bool pFlow::eventSubscriber::unsubscribe
+(
+	eventObserver* observer
+)const
+{
+	if(observer)
+	{
+		observerList_.remove(observer);
+	}
+	return true;
+}
+
+bool pFlow::eventSubscriber::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/eventSubscriber/eventSubscriber.H b/src/phasicFlow/eventSubscriber/eventSubscriber.H
new file mode 100644
index 00000000..6d2d112b
--- /dev/null
+++ b/src/phasicFlow/eventSubscriber/eventSubscriber.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#ifndef __eventSubscriber_H__
+#define __eventSubscriber_H__
+
+#include "List.H"
+#include "eventObserver.H"
+#include "eventMessage.H"
+
+namespace pFlow
+{
+
+
+
+class eventSubscriber
+{
+protected:
+
+	// - list of subsribed objectd that recieve updage messages 
+	mutable List<eventObserver*> observerList_;
+
+public:
+
+	eventSubscriber()
+	{}
+
+	virtual ~eventSubscriber();
+
+	virtual bool subscribe(eventObserver* observer)const;
+
+	virtual bool unsubscribe(eventObserver* observer)const;
+
+	bool notify(const eventMessage& msg);
+
+	bool notify(const eventMessage& msg, const List<eventObserver*>& exclutionList );
+
+
+
+};
+
+} // pFlow
+
+
+
+#endif // __eventSubscriber_H__
diff --git a/src/phasicFlow/globals/error.C b/src/phasicFlow/globals/error.C
new file mode 100644
index 00000000..f725f9e5
--- /dev/null
+++ b/src/phasicFlow/globals/error.C
@@ -0,0 +1,96 @@
+/*------------------------------- 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 <iostream>
+#include <stdlib.h>
+
+#include "error.H"
+#include "streams.H"
+
+
+static pFlow::Ostream& errorStream   = pFlow::errReport;
+
+
+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';
+	return errorStream;
+
+}
+
+pFlow::iOstream& fatalErrorInMessage(const char* fnName, const char* fileName, int linNumber )
+{	
+
+	errorStream<<"\n>>> Fatal error in phasicFlow\n" <<
+	 			 " Error is issued in function " << redText(fnName)<<
+	 			 ", located in file "<< redText(fileName) <<
+	             " at line "<< redText(linNumber) << '\n';
+	return errorStream;
+}
+
+pFlow::iOstream& notImplementedErrorMessage(const char*fnName, const char* fileName, int lineNumber)
+{
+
+	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';
+	return errorStream;
+}
+
+
+pFlow::iOstream& ioErrorMessage(const char* fileName, int fileLineNumber, const char* fnName, const char* fName, int lNumber)
+{
+	
+	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';
+	return errorStream;
+}
+
+pFlow::iOstream& ioErrorMessage(const pFlow::word& fileName, int fileLineNumber, const char* fnName, const char* fName, int lNumber)
+{
+	return ioErrorMessage( fileName.c_str(), fileLineNumber, fnName, fName, lNumber);
+}
+
+
+pFlow::iOstream& warningMessage(const char* fnName, const char* fileName, int linNumber )
+{
+	
+	errorStream<<"\n>>> Warning in phasicFlow\n"<<
+				 " Warning is issued in function " << yellowText(fnName)<<
+	             " in source file "<< yellowText(fileName) <<
+	             " at line "<< yellowText(linNumber) <<'\n';
+	return errorStream;
+}
+
+pFlow::iOstream& reportAndExit()
+{
+	errorStream<<"\n>>> phasicFlow is exiting . . ." << pFlow::endl;
+	exit(EXIT_FAILURE);
+	return errorStream;
+}
+
+
diff --git a/src/phasicFlow/globals/error.H b/src/phasicFlow/globals/error.H
new file mode 100644
index 00000000..a18580b6
--- /dev/null
+++ b/src/phasicFlow/globals/error.H
@@ -0,0 +1,68 @@
+/*------------------------------- 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 __error_H__
+#define __error_H__
+
+
+#include "builtinTypes.H"
+
+
+namespace pFlow
+{
+	class iOstream;	
+}
+
+
+// reports a fatal error and exit the applicaiton 
+#define fatalError \
+	fatalErrorMessage(__FILE__, __LINE__)
+
+#define fatalErrorIn( functionName ) \
+	fatalErrorInMessage((functionName), __FILE__, __LINE__ )
+
+#define fatalErrorInFunction fatalErrorIn(FUNCTION_NAME)
+
+#define notImplemented(functionName) \
+    notImplementedErrorMessage ((functionName), __FILE__, __LINE__ )
+        
+#define notImplementedFunction notImplemented(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()
+
+pFlow::iOstream& fatalErrorMessage(const char* fileName, int linNumber );
+pFlow::iOstream& fatalErrorInMessage(const char* fnName, const char* fileName, int linNumber );
+pFlow::iOstream& notImplementedErrorMessage(const char*fnName, const char* fileName, int lineNumber);
+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();
+
+#endif
diff --git a/src/phasicFlow/globals/globalSettings.H b/src/phasicFlow/globals/globalSettings.H
new file mode 100755
index 00000000..2a1c35f5
--- /dev/null
+++ b/src/phasicFlow/globals/globalSettings.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef __globalSettings_H__
+#define __globalSettings_H__
+
+
+
+namespace pFlow
+{
+
+const inline double vectorGrowthFactor__ = 1.1;
+
+
+}
+
+
+#endif // __globalSettings_H__
diff --git a/src/phasicFlow/globals/pFlowMacros.H b/src/phasicFlow/globals/pFlowMacros.H
new file mode 100755
index 00000000..ccd1db28
--- /dev/null
+++ b/src/phasicFlow/globals/pFlowMacros.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef __pFlowMacros_H__
+#define __pFlowMacros_H__
+
+#include "phasicFlowConfig.H"
+
+#ifdef __GNUC__
+    #define FUNCTION_NAME __PRETTY_FUNCTION__
+#else
+    #define FUNCTION_NAME __func__
+#endif
+
+#ifdef __GNUC__
+#  define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
+#else
+#  define UNUSED(x) UNUSED_ ## x
+#endif
+
+#define CONSUME_PARAM(x) (void)(x);
+
+#ifdef __CUDACC__
+    #define INLINE_FUNCTION_HD inline __host__ __device__
+    #define INLINE_FUNCTION_D  inline __device__
+    #define INLINE_FUNCTION_H  inline __host__ 
+    #define LAMBDA_HD       [=]   __host__ __device__
+    #define LAMBDA_D        [=]   __device__
+    #define CLASS_LAMBDA_HD [=,*this] __host__ __device__
+    #define FUNCTION_HD     __host__ __device__
+    #define FUNCTION_H      __host__
+    #define FUNCTION_D      __device__
+#else
+    #define INLINE_FUNCTION_HD inline 
+    #define INLINE_FUNCTION_D  inline 
+    #define INLINE_FUNCTION_H  inline 
+    #define LAMBDA_HD [=]
+    #define LAMBDA_D        [=] 
+    #define CLASS_LAMBDA_HD [=,*this]
+    #define FUNCTION_HD
+    #define FUNCTION_H      
+    #define FUNCTION_D      
+#endif
+
+#define INLINE_FUNCTION inline
+
+#ifdef BUILD_SHARED_LIBS
+    #define USE_INSTANTIATION 1
+#else
+    #define USE_INSTANTIATION 0
+#endif
+
+
+#define forAll(i, container) for(auto i=0; i < container.size(); ++i)
+
+#ifdef USE_STD_PARALLEL_ALG
+static inline const bool useStdParallel__ = true;
+#else
+static inline const bool useStdParallel__ = false;
+#endif
+
+
+#endif //__pFlowMacros_H__
diff --git a/src/phasicFlow/globals/vocabs.H b/src/phasicFlow/globals/vocabs.H
new file mode 100755
index 00000000..68fa1e52
--- /dev/null
+++ b/src/phasicFlow/globals/vocabs.H
@@ -0,0 +1,58 @@
+/*------------------------------- 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 __vocabs_H__
+#define __vocabs_H__
+
+
+namespace pFlow
+{
+
+	// folders / repositories
+const inline char* settingsFolder__ 		= "settings";
+const inline char* settingsRepository__		= "settings";
+const inline char* caseSetupFolder__ 		= "caseSetup";
+const inline char* caseSetupRepository__	= "caseSetup";
+const inline char* geometryFolder__ 		= "geometry";
+const inline char* geometryRepository_      = "geometry";
+const inline char* integrationRepository__  = "integration";
+const inline char* integrationFolder__  	= "integration";
+
+// file names
+const inline char* settingsFile__			= "settingsDict";
+const inline char* insertionFile__ 			= "particleInsertion";
+const inline char* sphereShapeFile__  		= "sphereShape";
+const inline char* pointStructureFile__ 	= "pStructure";
+const inline char* triSurfaceFile__ 		= "triSurface";
+const inline char* createParticles__		= "createParticles";
+const inline char* motionModelFile__        = "motionModel";
+const inline char* contactSearchFile__		= "contactSearch";
+const inline char* propertyFile__ 			= "interaction";
+const inline char* interactionFile__		= "interaction";
+
+
+const inline char* uniform__ 		= "uniform";
+const inline char* nonUniform__		= "nonUniform";
+
+
+}
+
+
+#endif // __vocabs_H__
diff --git a/src/phasicFlow/random/randomReal/RandomReal.C b/src/phasicFlow/random/randomReal/RandomReal.C
new file mode 100644
index 00000000..e3e0e7c8
--- /dev/null
+++ b/src/phasicFlow/random/randomReal/RandomReal.C
@@ -0,0 +1,53 @@
+/*------------------------------- 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 "RandomReal.H"
+
+
+template<typename DistributionType>
+pFlow::RandomReal<DistributionType>::RandomReal
+(
+	word distribution
+)
+:
+	randomReal(distribution),
+	distribution_()
+{
+
+}
+
+template<typename DistributionType>
+pFlow::real  pFlow::RandomReal<DistributionType>::randomNumber
+(
+	real a, real b
+)
+{
+	return distribution_.randomNumber(a,b);
+}
+
+template<typename DistributionType>
+pFlow::realx3 pFlow::RandomReal<DistributionType>::randomNumber
+(
+	realx3 a,
+	realx3 b
+)
+{
+	return	distribution_.randomNumber(a,b);	
+}
\ No newline at end of file
diff --git a/src/phasicFlow/random/randomReal/RandomReal.H b/src/phasicFlow/random/randomReal/RandomReal.H
new file mode 100644
index 00000000..7c03264b
--- /dev/null
+++ b/src/phasicFlow/random/randomReal/RandomReal.H
@@ -0,0 +1,73 @@
+/*------------------------------- 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 __RandomReal_H__
+#define __RandomReal_H__
+
+//#include <random>
+
+#include "randomReal.H"
+#include "uniformRandomReal.H"
+
+
+namespace pFlow
+{
+
+template<typename DistributionType>
+class RandomReal
+:
+	public randomReal 
+{
+protected:
+
+ 	DistributionType distribution_;
+
+public:
+
+	// type info
+	TypeNameTemplate("randomReal", DistributionType);
+
+
+	RandomReal(word distribution);
+
+	add_vCtor
+	(
+		randomReal,
+		RandomReal,
+		word
+	);
+
+	virtual ~RandomReal()= default;
+
+	virtual real  randomNumber(real a, real b)override;
+
+	virtual realx3 randomNumber(realx3 a, realx3 b)override;
+	
+
+};
+
+
+}
+
+#include "RandomReal.C"
+
+
+
+#endif
diff --git a/src/phasicFlow/random/randomReal/randomReal.C b/src/phasicFlow/random/randomReal/randomReal.C
new file mode 100644
index 00000000..1425929e
--- /dev/null
+++ b/src/phasicFlow/random/randomReal/randomReal.C
@@ -0,0 +1,51 @@
+/*------------------------------- 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 "randomReal.H"
+
+
+pFlow::uniquePtr<pFlow::randomReal> pFlow::randomReal::create
+(
+	word distribution
+)
+{
+	word dist = angleBracketsNames("randomReal", distribution);
+
+	if( wordvCtorSelector_.search(dist) )
+	{
+		return wordvCtorSelector_[dist] (distribution);
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< dist << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			wordvCtorSelector_
+		);
+		fatalExit();
+	}
+
+	return nullptr;
+}
+
+
diff --git a/src/phasicFlow/random/randomReal/randomReal.H b/src/phasicFlow/random/randomReal/randomReal.H
new file mode 100644
index 00000000..a9e1ccbe
--- /dev/null
+++ b/src/phasicFlow/random/randomReal/randomReal.H
@@ -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 __randomReal_H__
+#define __randomReal_H__
+
+#include "types.H"
+#include "virtualConstructor.H"
+
+namespace pFlow
+{
+
+
+class randomReal
+{
+
+protected:
+
+public:
+
+	TypeName("randomReal");
+
+	randomReal(word UNUSED(distribution)){}
+
+	create_vCtor
+	(
+		randomReal,
+		word,
+		(word distribution),
+		(distribution)
+	);
+
+	virtual ~randomReal()= default;
+
+	virtual real  randomNumber(real a, real b) = 0;
+
+	virtual realx3 randomNumber(realx3 a, realx3 b) = 0;
+
+	
+	
+	
+	static
+	uniquePtr<randomReal> create(word distribution);
+};
+
+
+
+}
+
+#endif
diff --git a/src/phasicFlow/random/randomReal/randomReals.C b/src/phasicFlow/random/randomReal/randomReals.C
new file mode 100644
index 00000000..34b71ca7
--- /dev/null
+++ b/src/phasicFlow/random/randomReal/randomReals.C
@@ -0,0 +1,23 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#include "randomReals.H"
+
+template class pFlow::RandomReal<pFlow::uniformRandomReal>;
\ No newline at end of file
diff --git a/src/phasicFlow/random/randomReal/randomReals.H b/src/phasicFlow/random/randomReal/randomReals.H
new file mode 100644
index 00000000..d8b4381d
--- /dev/null
+++ b/src/phasicFlow/random/randomReal/randomReals.H
@@ -0,0 +1,34 @@
+/*------------------------------- 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 __randomReals_H__
+#define __randomReals_H__
+
+#include "RandomReal.H"
+#include "uniformRandomReal.H"
+
+namespace pFlow
+{
+
+typedef RandomReal<uniformRandomReal> uniformRandomRealDistribution;
+
+}
+
+#endif
diff --git a/src/phasicFlow/random/randomReal/uniformRandomReal.H b/src/phasicFlow/random/randomReal/uniformRandomReal.H
new file mode 100644
index 00000000..37fab81b
--- /dev/null
+++ b/src/phasicFlow/random/randomReal/uniformRandomReal.H
@@ -0,0 +1,84 @@
+/*------------------------------- 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 __uniformRandomReal_H__
+#define __uniformRandomReal_H__
+
+#include <random>
+
+#include "types.H"
+#include "typeInfo.H"
+
+namespace pFlow
+{
+
+class uniformRandomReal
+{
+protected:
+
+ 	std::mt19937_64 engineGen_;
+
+ 	std::uniform_real_distribution<double> distrbution_;
+
+public:
+
+	// type info
+	TypeNameNV("uniform");
+
+	explicit uniformRandomReal()
+	:
+		engineGen_(std::random_device()()),
+		distrbution_(0.0, 1.0)
+	{}
+
+	~uniformRandomReal()= default;
+
+	inline real  randomNumber(real a, real b) 
+	{
+		return  a + (b-a)*distrbution_(engineGen_);
+	}
+	
+	inline realx3 randomNumber(const realx3& a, const realx3& b)
+	{
+		realx3 r3
+		(
+			randomNumber(0.0,1.0),
+			randomNumber(0.0,1.0),
+			randomNumber(0.0,1.0)
+		);
+
+		return a + (b-a)*r3;
+	}	
+
+	inline realx3 operator()(const realx3& a, const realx3& b)
+	{
+		return randomNumber(a,b);
+	}
+
+	inline real operator()(real a, real b)
+	{
+		return randomNumber(a,b);
+	}
+
+};
+
+}
+
+#endif
diff --git a/src/phasicFlow/ranges/combinedRange.H b/src/phasicFlow/ranges/combinedRange.H
new file mode 100644
index 00000000..c5891dd9
--- /dev/null
+++ b/src/phasicFlow/ranges/combinedRange.H
@@ -0,0 +1,151 @@
+/*------------------------------- 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 __combinedRange_H__
+#define __combinedRange_H__
+
+
+#include "stridedRange.H"
+#include "intervalRange.H"
+#include "Lists.H"
+#include "Vectors.H"
+#include "Set.H"
+
+namespace pFlow
+{
+
+template<typename T>
+class combinedRange
+{
+public:
+
+	using StridedRangeType = stridedRange<T>;
+
+	using IntervalRangeType = intervalRange<T>;
+
+protected:
+	
+	List<StridedRangeType> 	sRanges_;
+
+	List<IntervalRangeType> iRanges_;
+
+	Set<T> 					individuals_;
+
+public:
+	
+	combinedRange(){}
+
+	combinedRange(const wordVector& strRanges)
+	{
+		if(!addRanges(strRanges))
+		{
+			fatalExit;
+		}
+	}
+
+	bool addRanges(const wordVector& strRanges)
+	{
+		for(auto& sR: strRanges)
+		{
+			if( !(addStridedRange(sR) || 
+				addIntervalRange(sR)||
+				addIndividual(sR)) )
+			{
+				fatalErrorInFunction<<
+				"bad systax for range defintion "<< sR<<endl;
+				return false;
+			}
+		}
+		return true;
+	}
+
+	bool addStridedRange(const word& strRange)
+	{
+		T begin, end, stride;
+		if(StridedRangeType::parseRange(strRange, begin, end, stride))
+		{
+			sRanges_.emplace_back(begin, end, stride);
+			return true;
+		}
+		return false;
+	}
+
+	bool addStridedRange(T begin, T end, T stride)
+	{
+		sRanges_.emplace_back(begin, end, stride);
+		return true;
+	}
+
+	bool addIntervalRange(const word& strRange)
+	{
+		T begin, end;
+		if( IntervalRangeType::parseRange(strRange, begin, end)	)
+		{
+			iRanges_.emplace_back(begin,end);
+			return true;
+		}
+		
+		return false;
+	}
+
+	bool addIntervalRange(T begin, T end)
+	{
+		iRanges_.emplace_back(begin,end);
+		return true;
+	}
+
+	bool addIndividual(const T& val)
+	{
+		individuals_.insert(val);
+		return true;
+	}
+
+	bool addIndividual(const word& strVal)
+	{
+		T val;
+		if(readValue(strVal , val))
+		{
+			return addIndividual(val);
+		}
+		return false;
+	}
+
+	bool isMember(T val)const
+	{
+		for(auto& sR:sRanges_)
+		{
+			if(sR.isMember(val))return true;
+		}
+
+		for(auto& iR:iRanges_)
+		{
+			if(iR.isMember(val)) return true;
+		}
+
+		if( individuals_.count(val) ) return true;
+
+		return false;
+	}
+};
+
+}
+
+
+#endif //__combinedRange_H__
diff --git a/src/phasicFlow/ranges/intervalRange.H b/src/phasicFlow/ranges/intervalRange.H
new file mode 100644
index 00000000..7279b93b
--- /dev/null
+++ b/src/phasicFlow/ranges/intervalRange.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#ifndef __intervalRange_H__
+#define __intervalRange_H__ 
+
+#include "types.H"
+#include "typeInfo.H"
+
+
+namespace pFlow
+{
+
+template<typename T>
+class
+intervalRange
+{
+protected:
+
+	T 		begin_;
+
+	T 		end_;
+
+	static inline const T maxVal = largestPositive<T>();
+	static inline const T minVal = largestNegative<T>();
+public:
+
+	TypeNameTemplateNV("intervalRange",T);
+
+	intervalRange(T begin, T end)
+	:
+		begin_(begin),
+		end_(end)
+	{}
+
+	intervalRange(T beginEnd, bool openEnd )
+	:
+		begin_(openEnd?beginEnd:minVal),
+		end_(openEnd?maxVal:beginEnd)
+	{}
+
+	// it should be in the form of begin:end or :end or begin:
+	intervalRange(const word& rangeString)
+	{
+		if(!parseRange(rangeString,begin_,end_))
+		{
+			fatalErrorInFunction<<
+			"bad input for the range. It should have the form of  begin:end or :end or begin: \n";
+			fatalExit;
+		}
+	}
+
+
+	inline
+	bool isMember(T val)const
+	{
+		if(val<begin_ || val>end_)return false;
+		return true;
+	}
+
+	static
+	bool parseRange(const word& rangeString, T& begin, T& end)
+	{
+		if(std::count(
+			rangeString.begin(),
+			rangeString.end(), 
+			':') != 1)
+			return false;
+
+		auto col1 = rangeString.find_first_of(":");
+		word beginCh;
+		if(col1 == 0) 
+		{
+			begin = minVal;
+		}
+		else
+		{
+			auto beginCh = rangeString.substr(0,col1);
+			if(!readValue(beginCh,begin))return false;
+		}
+    
+    	if(col1 == rangeString.size())
+    	{
+    		end = maxVal;
+    	}
+    	else
+    	{
+    		auto endCh = rangeString.substr(col1+1);
+    		if(!readValue(endCh, end))return false;
+    	}
+    	
+   
+		return true;
+
+	}
+};
+
+}
+
+#endif  //__stridedRange_H__ 
diff --git a/src/phasicFlow/ranges/ranges.H b/src/phasicFlow/ranges/ranges.H
new file mode 100644
index 00000000..d930c88d
--- /dev/null
+++ b/src/phasicFlow/ranges/ranges.H
@@ -0,0 +1,45 @@
+/*------------------------------- 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 __ranges_H__ 
+#define __ranges_H__
+
+#include "stridedRange.H"
+#include "intervalRange.H"
+#include "combinedRange.H"
+
+namespace pFlow
+{
+
+using int32StridedRagne = stridedRange<int32>;
+using int64StridedRange = stridedRange<int64>;
+using realStridedRange  = stridedRange<real>;
+
+using int32IntervalRange = intervalRange<int32>;
+using int64IntervalRange = intervalRange<int64>;
+using realIntervalRange	 = intervalRange<real>;
+
+using int32CombinedRange = combinedRange<int32>;
+using int64CombinedRange = combinedRange<int64>;
+using realCombinedRange  = combinedRange<real>;
+
+}
+
+#endif //__ranges_H__
diff --git a/src/phasicFlow/ranges/stridedRange.H b/src/phasicFlow/ranges/stridedRange.H
new file mode 100644
index 00000000..57d2e725
--- /dev/null
+++ b/src/phasicFlow/ranges/stridedRange.H
@@ -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 __stridedRange_H__
+#define __stridedRange_H__ 
+
+#include "types.H"
+#include "typeInfo.H"
+#include "dictionary.H"
+
+
+namespace pFlow
+{
+
+template<typename T>
+class
+stridedRange
+{
+protected:
+
+	T 		begin_;
+
+	T 		end_;
+
+	T 		stride_;
+
+	static inline const T maxVal = largestPositive<T>();
+	static inline const T minVal = largestNegative<T>();
+
+public:
+
+	TypeNameTemplateNV("stridedRange",T);
+
+	stridedRange(T begin, T end, T stride)
+	:
+		begin_(begin),
+		end_(end),
+		stride_(stride)
+	{}
+
+	stridedRange(T begin, T stride)
+	:
+		begin_(begin),
+		end_(maxVal),
+		stride_(stride)
+	{}
+
+
+	// it should be in the form of begin:stride:end
+	stridedRange(const word& rangeString)
+	{
+		if(!parseRange(rangeString,begin_,end_, stride_))
+		{
+			fatalErrorInFunction<<
+			"bad input for the range. It should have the form of  begin:stride:end \n";
+			fatalExit;
+		}
+	}
+
+	stridedRange(const dictionary& dict)
+	:
+		begin_(dict.getVal<label>("begin")),
+		end_(dict.getVal<label>("end")),
+		stride_(dict.getVal<label>("stride"))
+	{}
+		
+	inline 
+	T begin()const
+	{
+		return begin_;
+	}
+
+	T end()const
+	{
+		return end_;
+	}
+
+	T stride()const
+	{
+		return stride_;
+	}
+	inline
+	bool isMember(T val, T epsilon = 0)const
+	{
+		if(equal(val,begin_))return true;
+		if(equal(val,end_))return true;
+		if(abs(mod(val-begin_,stride_))<= epsilon) return true;
+		return false;
+	}
+
+	static
+	bool parseRange(const word& rangeString, T& begin, T& end, T& stride)
+	{
+		if(std::count(
+			rangeString.begin(),
+			rangeString.end(), 
+			':') != 2)
+			return false;
+
+		auto col1 = rangeString.find_first_of(":");
+
+		if(col1 == 0 || col1==std::string::npos)return false;
+
+		auto beginCh = rangeString.substr(0,col1);
+    
+	    auto col2 = rangeString.find_first_of(":",col1+1);
+
+	    if(col1 == col2 || col2==std::string::npos)return false;
+
+    	auto strideCh = rangeString.substr(col1+1,col2-col1-1);
+    
+    	auto endCh = rangeString.substr(col2+1);
+
+    	if(!readValue(beginCh,begin))return false;
+    	if(!readValue(strideCh, stride))return false;
+    	if(!readValue(endCh, end))return false;
+    
+	return true;
+
+	}
+};
+
+}
+
+#endif  //__stridedRange_H__ 
diff --git a/src/phasicFlow/repository/IOobject/IOfileHeader.C b/src/phasicFlow/repository/IOobject/IOfileHeader.C
new file mode 100644
index 00000000..e4a568e6
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/IOfileHeader.C
@@ -0,0 +1,179 @@
+/*------------------------------- 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 "IOfileHeader.H"
+#include "repository.H"
+
+pFlow::uniquePtr<pFlow::iFstream> pFlow::IOfileHeader::inStream()const
+{
+	if( fileExist() )
+		return makeUnique<iFstream>(path());
+	else
+		return nullptr;
+}
+
+pFlow::uniquePtr<pFlow::oFstream> pFlow::IOfileHeader::outStream()const
+{
+	return makeUnique<oFstream>(path());
+}
+
+pFlow::IOfileHeader::IOfileHeader
+(
+	const objectFile& objf,
+	const repository* owner
+)
+:
+	objectFile(objf),
+	owner_(owner)
+{}
+
+pFlow::fileSystem pFlow::IOfileHeader::path() const
+{
+	fileSystem f;
+
+	if( owner_ )
+	{
+		f = owner_->path()/localPath();	
+
+	}else
+	{
+		f = localPath();
+	}
+	f += name_;
+	return f;
+}
+
+bool pFlow::IOfileHeader::headerOk(bool silent)
+{
+	if(!fileExist())
+	{
+		if(!silent)
+			warningInFunction <<
+			"  the file "<< path() << " does not exist. \n";
+		return false;
+	}
+
+	if( implyRead() )
+	{
+		
+		if( auto ptrIS = inStream(); ptrIS )
+		{
+			return readHeader( ptrIS(), silent );
+		}
+		else
+		{
+			if(!silent)
+				warningInFunction<<
+				"could not open file " << path() <<endl;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool pFlow::IOfileHeader::implyRead() const
+{
+	if (isReadAlways()) return true;
+	return readIfPresent();
+}
+
+bool pFlow::IOfileHeader::implyWrite() const
+{
+	return isWriteAlways();
+}
+
+bool pFlow::IOfileHeader::fileExist() const
+{
+	return path().exist();
+}
+
+bool pFlow::IOfileHeader::readIfPresent()const
+{
+	return fileExist() && isReadIfPresent();
+}
+
+
+bool pFlow::IOfileHeader::writeHeader(iOstream& os, const word& typeName) const
+{
+
+	writeBanner(os);
+
+	os.writeWordEntry("objectType", typeName );
+	os.fatalCheck("writing objectType");
+
+	os.writeWordEntry("objectName", name() );
+	os.fatalCheck("writing objectName");
+
+	writeSeparator(os);
+	return true;
+}
+
+bool pFlow::IOfileHeader::writeHeader(iOstream& os) const
+{
+	return writeHeader(os, objectType_);
+}
+
+bool pFlow::IOfileHeader::readHeader(iIstream& is, bool silent)
+{
+	
+	if( !is.findTokenAndNextSilent("objectName", objectName_) )
+	{
+		if(!silent)
+		{
+			warningInFunction<<
+			"cannot find/error in reading objectName in file " <<
+			is.name()<<endl;
+		}
+		return false;
+	}	
+
+	if( !is.findTokenAndNextSilent("objectType", objectType_) )
+	{
+		if(!silent)
+		{
+			warningInFunction <<
+			"cannot find/error in reading objectType in file "<<
+			is.name()<<endl;
+		}
+		return false;
+	}
+
+	return true;
+}
+
+bool pFlow::IOfileHeader::writeBanner(iOstream& os)const
+{
+	os<< 
+"/* -------------------------------*- C++ -*---------------------------------- *\\ \n"<<
+"|  phasicFlow File                                                            | \n"<<
+"|  copyright: www.cemf.ir                                                     | \n"<<
+"\\* ------------------------------------------------------------------------- */  \n \n";
+
+	return true;
+}
+
+bool pFlow::IOfileHeader::writeSeparator(iOstream& os)const
+{
+	os<< "\n" <<
+"// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // \n \n";
+
+	return true;
+}
diff --git a/src/phasicFlow/repository/IOobject/IOfileHeader.H b/src/phasicFlow/repository/IOobject/IOfileHeader.H
new file mode 100644
index 00000000..5279d408
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/IOfileHeader.H
@@ -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 __IOfileHeader_H__
+#define __IOfileHeader_H__
+
+
+#include "uniquePtr.H"
+#include "objectFile.H"
+#include "streams.H"
+
+namespace pFlow
+{
+
+class repository;
+
+class IOfileHeader
+:
+	public objectFile
+{
+protected:
+	
+
+	//// - data members 
+		// owner repository
+		const repository* 	owner_ = nullptr;
+		
+		// object name read from file 
+		word objectName_;
+
+		// object type read from file 
+		word objectType_;
+
+	//// - methods 
+
+		// - input file stream
+		uniquePtr<iFstream> inStream()const;
+
+		// - ouput file stream
+		uniquePtr<oFstream> outStream()const;
+
+public:
+
+	// with owner 
+	IOfileHeader(const objectFile& objf, const repository* owner = nullptr);
+
+	// - object name
+	const word& objectName()const
+	{
+		return objectName_;
+	}
+
+	// - object type
+	const word& objectType()const
+	{
+		return objectType_;
+	}
+
+	// - pointer to owner repository 
+	const repository* owner()const 
+	{
+		return owner_;
+	}
+
+	// - path to file name 
+	fileSystem path() const;
+
+	// - should be used for read operations 
+	//   check if the file exist,
+	//   read the header of the file to check if it is ok
+	bool headerOk(bool silent = false);
+	
+	// - imply read 
+	bool implyRead() const;
+
+	// - imply write 
+	bool implyWrite() const;
+	
+	// - check if file exists
+	bool fileExist() const;
+	
+	// - 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;
+
+	// - 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 
+	bool readHeader(iIstream& is, bool silent=false);
+	
+	// - write the banner 
+	bool writeBanner(iOstream& os)const;
+
+	// - wirte a separator line 
+	bool writeSeparator(iOstream& os)const;
+
+};
+
+
+}
+
+#endif //__objectFile_H__
diff --git a/src/phasicFlow/repository/IOobject/IOobject.C b/src/phasicFlow/repository/IOobject/IOobject.C
new file mode 100644
index 00000000..ccf4668c
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/IOobject.C
@@ -0,0 +1,119 @@
+/*------------------------------- 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 "IOobject.H"
+#include "repository.H"
+
+
+pFlow::IOobject::IOobject
+(
+	const objectFile& objf,
+	const repository* owner,
+	uniquePtr<iObject>&& obj
+)
+:
+	IOfileHeader(objf, owner),
+	object_(obj.release())
+{
+
+	if(!read(this->readWriteHeader()))
+	{
+		fatalErrorInFunction<<
+		"error in reading " << name() << " from path " << path()<<endl;
+		fatalExit;
+	}
+}
+
+
+pFlow::IOobject::IOobject
+(
+	const objectFile& objf,
+	const repository* owner,
+	uniquePtr<IOobject>&& obj
+)
+:
+	IOfileHeader(objf, owner),
+	object_( obj->object_.release())
+{
+}
+
+
+bool pFlow::IOobject::isObjectValid()const
+{
+	return object_.get() != nullptr;
+}
+
+bool pFlow::IOobject::read(bool rdHdr)
+{
+
+	if( implyRead() )
+	{
+		if( auto ptrIS = inStream(); ptrIS )
+		{	
+			return read( ptrIS(), rdHdr);
+		}
+		else
+		{
+			warningInFunction<<
+			"could not open file " << path() <<endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+
+bool pFlow::IOobject::write() const
+{
+	if(implyWrite())
+	{
+		if(auto ptrOS = outStream(); ptrOS )
+		{
+			return write(ptrOS());
+		}
+		else
+		{
+			warningInFunction<< 
+			"error in opening file "<< path() <<endl;
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+bool pFlow::IOobject::read(iIstream& is, bool rdHdr)
+{
+	if(rdHdr)
+	{
+		if(!readHeader(is))return false;
+	}
+	return object_->read_object_t(is);
+}
+
+
+bool pFlow::IOobject::write(iOstream& os) const
+{
+	if(this->readWriteHeader())
+		writeHeader(os, typeName());
+	
+	return (object_->write_object_t(os) && writeSeparator(os));
+}
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/IOobject.H b/src/phasicFlow/repository/IOobject/IOobject.H
new file mode 100644
index 00000000..494377d4
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/IOobject.H
@@ -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 __IOobject_H__
+#define __IOobject_H__
+
+
+
+#include "IOfileHeader.H"
+
+
+namespace pFlow
+{
+
+class repository;
+
+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_;
+
+
+public:
+
+	// - typeinfo
+	word typeName()const
+	{
+		return object_->typeName();
+	}
+
+	//// - 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 );
+
+		// - 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);
+		
+
+	//// - Access to data object 
+
+		// - is object valid 
+		bool isObjectValid()const;
+
+		// - ref to data object
+		template<typename T>
+		auto& getObject();
+
+		// - const ref to data object 
+		template<typename T>
+		const auto& getObject()const;
+	
+		
+
+	//// - IO operations 
+
+		// - read from file 
+		bool read(bool rdHdr = true);
+
+		// - write to file 
+		bool write() const;
+
+		// - read from istream 
+		bool read(iIstream& is, bool rdHdr = true);
+
+		// - write to istream 
+		bool write(iOstream& os) const;
+		
+
+};
+
+}
+
+#include "IOobjectTemplates.C"
+
+#endif //__IOobject_H__
diff --git a/src/phasicFlow/repository/IOobject/IOobjectTemplates.C b/src/phasicFlow/repository/IOobject/IOobjectTemplates.C
new file mode 100644
index 00000000..4c8f20e1
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/IOobjectTemplates.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+template<typename T, typename... Args>
+auto pFlow::IOobject::make
+(
+	const objectFile& objf,
+	Args&&... args
+)
+{
+	return makeUnique<IOobject>
+		(
+			objf, nullptr , make_object_t<T>(std::forward<Args>(args)...)
+		);
+}
+
+template<typename T, typename... Args>
+auto pFlow::IOobject::make_object_t(Args&&... args)
+{
+	auto ptr = makeUnique<object_t<T>>(std::forward<Args>(args)...);
+	return ptr;
+}
+
+template<typename T>
+auto& pFlow::IOobject::getObject()
+{
+	if( !isObjectValid() )
+	{
+		fatalErrorInFunction<<
+		"accessing an invalid objecct "<< name() <<endl;
+		fatalExit;
+	}
+	return  dynamic_cast<object_t<T>&>(*object_).data_;
+}
+
+
+template<typename T>
+const auto& pFlow::IOobject::getObject()const
+{
+	if( !isObjectValid() )
+	{
+		fatalErrorInFunction<<
+		"accessing an invalid objecct "<< name() <<endl;
+		fatalExit;
+	}
+	return  dynamic_cast<const object_t<T>&>(*object_).data_;	
+}
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/objectFile.C b/src/phasicFlow/repository/IOobject/objectFile.C
new file mode 100644
index 00000000..34d53d6f
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/objectFile.C
@@ -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 "objectFile.H"
+
+pFlow::objectFile::objectFile
+(
+	const word& name
+)
+:
+	name_(name),
+	rFlag_(READ_NEVER),
+	wFlag_(WRITE_NEVER),
+	localPath_("")
+{}
+
+pFlow::objectFile::objectFile
+(
+	const word& 			name,
+	const fileSystem& 		localPath,
+	const readFlag&   		rf, 
+	const writeFlag&  		wf,
+	bool  rwHeader
+)
+:
+	name_(name),
+	rFlag_(rf),
+	wFlag_(wf),
+	localPath_(localPath),
+	readWriteHeader_(rwHeader)
+{
+}
\ No newline at end of file
diff --git a/src/phasicFlow/repository/IOobject/objectFile.H b/src/phasicFlow/repository/IOobject/objectFile.H
new file mode 100644
index 00000000..4d561de5
--- /dev/null
+++ b/src/phasicFlow/repository/IOobject/objectFile.H
@@ -0,0 +1,153 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef __objectFile_H__
+#define __objectFile_H__
+
+#include "types.H"
+#include "fileSystem.H"
+
+
+namespace pFlow
+{
+
+
+
+class objectFile
+{
+public:
+
+	enum readFlag
+	{
+		READ_ALWAYS,
+		READ_NEVER,
+		READ_IF_PRESENT
+	};
+
+	enum writeFlag
+	{
+		WRITE_ALWAYS,
+		WRITE_NEVER
+	};
+
+protected:
+
+	// name of the entity
+	word 	name_;
+
+	// read flag
+	readFlag  rFlag_;
+
+	// write flag
+	writeFlag wFlag_;
+
+	// local path of entity
+	fileSystem localPath_;
+
+	bool readWriteHeader_ = true;
+
+public:
+
+
+	
+	// constructors
+	objectFile
+	(
+		const word& name
+	);
+
+
+	objectFile
+	(
+		const word& name,
+		const fileSystem& localPath,
+		const readFlag&   rf = READ_NEVER,
+		const writeFlag&  wf = WRITE_NEVER,
+		bool  rwHeader = true
+	);
+
+	// copy construct 
+	objectFile( const objectFile & src) = default;
+
+	objectFile( objectFile&& src) = default;
+	
+	objectFile& operator = (const objectFile & rhs) = default;
+
+	objectFile& operator = (objectFile && rhs) = default;
+
+	virtual ~objectFile()=default;
+
+	virtual word name() const
+	{
+		return name_;
+	}
+
+	virtual fileSystem localPath()const
+	{
+		return localPath_;
+	}
+
+	readFlag rFlag()const
+	{
+		return rFlag_;
+	}
+
+	writeFlag wFlag()const
+	{
+		return wFlag_;
+	}
+
+	bool isReadAlways()const
+	{
+		return rFlag_ == READ_ALWAYS;
+	}
+
+	bool isReadNever()const
+	{
+		return rFlag_ == READ_NEVER;
+	}
+
+	bool isReadIfPresent()const
+	{
+		return rFlag_ == READ_IF_PRESENT;
+	}
+
+	bool isWriteAlways()const
+	{
+		return wFlag_ == WRITE_ALWAYS;
+	}
+
+	bool isWriteNever()const
+	{
+		return wFlag_ == WRITE_NEVER;
+	}
+
+	bool readWriteHeader()const
+	{
+		return readWriteHeader_;
+	}
+
+};
+
+
+
+}
+
+#endif //__objectFile_H__
diff --git a/src/phasicFlow/repository/Time/Time.C b/src/phasicFlow/repository/Time/Time.C
new file mode 100644
index 00000000..990da321
--- /dev/null
+++ b/src/phasicFlow/repository/Time/Time.C
@@ -0,0 +1,61 @@
+/*------------------------------- 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.H"
+#include "dictionary.H"
+#include "vocabs.H"
+
+pFlow::Time::Time
+(
+	repository* owner,
+	const dictionary& setiingsDict
+)
+:
+	repository("Time", "", owner),
+	timeControl(setiingsDict),
+	geometry_
+	(
+		geometryRepository_,
+		geometryFolder__,
+		this
+	),
+	integration_
+	(
+		integrationRepository__,
+		integrationFolder__,
+		this
+	)
+{
+	
+}
+
+bool pFlow::Time::write
+(
+	bool verbose
+) const
+{
+	if(outputToFile())
+	{
+		Report(0)<<"\nWriting to file at time: "<< cyanText(currentTime())<<endReport;
+		return repository::write(verbose);
+	}
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/repository/Time/Time.H b/src/phasicFlow/repository/Time/Time.H
new file mode 100644
index 00000000..119a75fb
--- /dev/null
+++ b/src/phasicFlow/repository/Time/Time.H
@@ -0,0 +1,95 @@
+/*------------------------------- 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 __Time_H__
+#define __Time_H__
+
+
+#include "types.H"
+#include "error.H"
+
+#include "timeControl.H"
+#include "repository.H"
+
+
+
+namespace pFlow
+{
+
+class dictionary;
+
+class Time
+:
+	public repository,
+	public timeControl
+{
+
+protected:
+
+	// - geometry folder/repository 
+	repository 		geometry_;
+
+	// - integration folder/repository 
+	repository 		integration_;
+
+public:
+
+	// Constructor with owner and settings dict
+	Time( repository* owner,  const dictionary& setiingsDict);
+
+
+	//// -  Methods
+		virtual fileSystem localPath()const
+		{
+			real ct = currentTime();
+			word lp = real2Word( ct, timePrecision());
+			return lp;
+		}
+	
+		// - geometry repository 
+		const repository& geometry()const
+		{
+			return geometry_;
+		}
+
+		repository& geometry()
+		{
+			return geometry_;
+		}
+
+		const repository& integration()const
+		{
+			return integration_;
+		}
+
+		repository& integration()
+		{
+			return integration_;
+		}
+		// override the base write to manage write operation 
+		// based on the valid write time intervals 
+		virtual bool write(bool verbose = false) const;
+	
+};
+
+} // pFlow
+
+#endif // __Time_H__
diff --git a/src/phasicFlow/repository/Time/timeControl.C b/src/phasicFlow/repository/Time/timeControl.C
new file mode 100644
index 00000000..87891d6e
--- /dev/null
+++ b/src/phasicFlow/repository/Time/timeControl.C
@@ -0,0 +1,95 @@
+/*------------------------------- 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 "timeControl.H"
+#include "dictionary.H"
+
+
+bool pFlow::timeControl::screenReport()const
+{
+	return screenReportInterval_.isMember(currentIter_);
+}
+
+pFlow::timeControl::timeControl
+(
+	const dictionary& dict
+)
+:
+	dt_
+	(
+		dict.getVal<real>("dt")
+	),
+	startTime_
+	(
+		dict.getVal<real>("startTime")
+	),
+	endTime_
+	(
+		dict.getVal<real>("endTime")
+	),
+	currentTime_(startTime_),
+	saveInterval_
+	(
+		dict.getVal<real>("saveInterval")
+	),
+	lastSaved_(startTime_),
+	currentIter_(0),
+	timePrecision_
+	(
+		dict.getValOrSet("timePrecision", 4)
+	),
+	timersReportInterval_
+	(
+		startTime_,
+		dict.getValOrSet("timersReportInterval", 0.04)
+	)
+
+{
+
+	checkForOutputToFile();
+}
+
+
+void pFlow::timeControl::checkForOutputToFile()
+{
+	bool save = false;
+	
+	if ( abs(currentTime_ - lastSaved_ - saveInterval_) < 0.5 * dt_ )
+	{	
+		lastSaved_ = currentTime_;
+		save = true;
+	}
+	else if( abs(currentTime_ - lastSaved_) < min( pow(10.0,-1.0*timePrecision_), 0.5 *dt_) )
+	{
+		lastSaved_ = currentTime_;
+		save = true;
+	}
+
+	outputToFile_ = save;
+}
+
+bool pFlow::timeControl::timersReportTime()const
+{
+	if(currentIter_<=1)return false;
+	return timersReportInterval_.isMember(currentTime_, dt_);
+}
+
+
diff --git a/src/phasicFlow/repository/Time/timeControl.H b/src/phasicFlow/repository/Time/timeControl.H
new file mode 100644
index 00000000..5f311a93
--- /dev/null
+++ b/src/phasicFlow/repository/Time/timeControl.H
@@ -0,0 +1,157 @@
+/*------------------------------- 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 __timeControl_H__
+#define __timeControl_H__
+
+#include "types.H"
+#include "ranges.H"
+#include "streams.H"
+
+
+namespace pFlow
+{
+
+
+class dictionary;
+
+
+class timeControl
+{
+protected:
+
+
+	//// - Data members
+
+	// - integration time step
+	real dt_;
+	
+	// - start time of simulation
+	real startTime_;
+
+	// - end time of simulation 
+	real endTime_;
+
+	// - current time of simulation
+	real currentTime_;	
+
+	// - time interval for time folder output 
+	real saveInterval_;
+
+	// - the last time folder that was saved
+	real lastSaved_;
+
+	// - current iteration number (for this execution)
+	int32 currentIter_;
+
+	// - time precision for output time folders
+	int32 timePrecision_;
+
+	realStridedRange  timersReportInterval_;
+
+	int32StridedRagne screenReportInterval_ ={0,100};
+
+	bool outputToFile_ = false;
+
+	void checkForOutputToFile();
+	
+	bool screenReport()const;
+	
+public:
+
+	timeControl(const dictionary& dict);
+	
+	virtual ~timeControl()
+	{}
+
+
+	real dt()const
+	{
+		return dt_;
+	}
+
+	real setTime(real t)
+	{
+		real tmp = currentTime_;
+		currentTime_ = t;
+		lastSaved_ = t;
+		checkForOutputToFile();
+		return tmp;
+	}
+
+
+	real currentTime() const 
+	{
+		return currentTime_;
+	}
+
+	int32 currentIter()const
+	{
+		return currentIter_;
+	}
+
+	bool finished()const
+	{
+		if( currentTime_ >= endTime_ ) return true;
+		return false;
+	}
+
+	bool outputToFile()const
+	{
+		return outputToFile_;
+	}
+
+	bool timersReportTime()const;
+	
+
+	bool operator ++(int)
+	{
+
+		if( finished() ) return false;
+		// increament iteration number 
+		currentIter_++;
+
+		currentTime_ += dt_;
+		if(screenReport())
+		{
+			Report(0)<<"Time (s): "<<cyanText(currentTime_)<<endReport;
+		}
+		// switch outputToFile_ on/off
+		checkForOutputToFile();
+
+		return true;
+	}
+
+	
+	int32 timePrecision()const
+	{
+		return timePrecision_;
+	}
+
+
+
+
+};
+
+
+} // pFlow
+
+#endif // __timeControl_H__
diff --git a/src/phasicFlow/repository/repository/repository.C b/src/phasicFlow/repository/repository/repository.C
new file mode 100644
index 00000000..a962a809
--- /dev/null
+++ b/src/phasicFlow/repository/repository/repository.C
@@ -0,0 +1,279 @@
+/*------------------------------- 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 "repository.H"
+
+
+pFlow::repository::repository
+(
+	const word& name,
+	const fileSystem& localPath,
+	repository* owner
+)
+:
+	name_(name),
+	localPath_(localPath),
+	owner_(owner)
+{
+
+	if(owner)
+	{
+		owner->addToRepository(this);
+	}
+}
+
+pFlow::repository::~repository()
+{
+	if(owner_)
+	{
+		owner_->removeRepository(this);
+	}
+}
+
+pFlow::word pFlow::repository::name()const
+{
+	return name_;
+}
+
+pFlow::fileSystem pFlow::repository::localPath()const
+{
+	return localPath_;
+}
+
+pFlow::fileSystem pFlow::repository::path()const 
+{
+	if(owner_)
+	{
+		return owner_->path()/localPath();
+	}
+	else
+	{
+		return localPath();
+	}
+}
+
+const pFlow::repository* pFlow::repository::owner()const
+{
+	return owner_;
+}
+
+pFlow::repository* pFlow::repository::owner()
+{
+	return owner_;
+}
+
+const pFlow::repository& pFlow::repository::thisRepository()const
+{
+	return *this;
+}
+
+pFlow::repository& pFlow::repository::thisRepository()
+{
+	return *this;
+}
+
+bool pFlow::repository::addToRepository(repository* rep)
+{
+	if( !repositories_.insertIf(rep->name(), rep) )
+	{
+
+		warningInFunction<<
+    	"Failed to add repository " << rep->name() <<
+    	" to repository " << this->name() << 
+    	". It is already in this repository. \n";
+    	return false;
+		
+	}
+
+	return true;
+}	
+
+bool pFlow::repository::removeRepository(repository* rep)
+{
+	auto name = rep->name();
+	return repositories_.erase(name) == 1; 
+}
+
+
+
+bool pFlow::repository::lookupObjectName(const word& nm)const
+{
+	return objects_.search(nm);
+}
+
+pFlow::word pFlow::repository::lookupObjectTypeName(
+	const word& nm
+	)const
+{
+	if(auto [iter, found] = objects_.findIf(nm); found)
+	{
+		return iter->second.typeName();
+	}
+	else
+	{
+		fatalErrorInFunction<<
+		"Object name " << nm << " is not found in repository "<< name() <<endl;
+		fatalExit;
+		return "";
+	}
+}
+
+bool pFlow::repository::globalLookupObjectName
+(
+	const word& nm,
+	bool  downward
+)const
+{	
+
+	
+	
+	if(!downward)
+	{	
+		// the object to start search and its owner 
+		auto object = this;
+		auto owner = object->owner();
+
+		// get to the top-most repository 
+		while(!owner)
+		{
+			object = owner;
+			owner = object->owner();
+		}
+
+		return object->globalLookupObjectName(nm, true);
+	}
+
+	if( lookupObjectName(nm) ) return true;
+
+	for(auto& rep:repositories_ )
+	{
+		if(rep.second)
+		{
+			if(rep.second->globalLookupObjectName(nm, true))return true;
+		}
+	}
+
+	return false;
+
+}
+
+bool pFlow::repository::lookupRepositoryName(const word& nm)const
+{
+	return repositories_.search(nm);
+}
+
+bool pFlow::repository::lookupName(const word nm)const
+{
+	if(lookupObjectName(nm))	return true;
+	if(lookupRepositoryName(nm))return true;
+	return false;
+}
+
+size_t pFlow::repository::numObjects()const
+{
+	return objects_.size();
+}
+
+size_t pFlow::repository::numRepositories()const
+{
+	return repositories_.size();
+}
+
+pFlow::repository& pFlow::repository::lookupRepository(const word& name)
+{
+
+	if( auto [iter, success] = repositories_.findIf(name); success )
+    {
+    	return *iter->second;   
+    }
+    else
+    {
+    	fatalErrorInFunction << 
+		"repository with name " << name << " is not found in repository " << this->name()<<endl <<
+		"list of avaiable repositories is \n" << repositoryNames();
+        fatalExit;
+        return *iter->second;
+    }
+}
+
+pFlow::wordList pFlow::repository::objectNames()const
+{
+	wordList names;
+	for(auto& ob:objects_)
+	{
+		names.push_back(ob.first);
+	}
+	return names;
+}
+
+pFlow::wordList pFlow::repository::repositoryNames()const
+{
+	wordList names;
+	for(auto& rep:repositories_)
+	{
+		names.push_back(rep.first);
+	}
+	return names;
+}
+
+
+bool pFlow::repository::write
+(
+	bool verbose
+) const
+{
+	
+	for(auto& obj:objects_)
+	{
+		if(verbose)
+		{
+			Report(1)<< "Writing to " << obj.second.path()<<endReport;
+		}
+		
+		if(!obj.second.write())
+		{
+			return false;
+		}
+	}
+
+	// - write sub-repositories 
+	for(auto& rep:repositories_)
+	{
+		
+		if( rep.second )
+		{
+			if(! rep.second->write(verbose) )
+			{
+				fatalErrorInFunction<< 
+				"  error in writing repository " << rep.first <<endl;
+				return false;
+			}
+		}
+		else
+		{
+			fatalErrorInFunction<<
+			"  repository " << rep.first << " is not a valid object to be referenced. \n";
+			return false;
+		}
+	}
+
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/repository/repository/repository.H b/src/phasicFlow/repository/repository/repository.H
new file mode 100644
index 00000000..67c55e2d
--- /dev/null
+++ b/src/phasicFlow/repository/repository/repository.H
@@ -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 __repository_H__
+#define __repository_H__
+
+
+#include "fileSystem.H"
+#include "Maps.H"
+#include "Lists.H"
+#include "IOobject.H"
+
+namespace pFlow
+{
+
+class repository
+{
+protected:
+	
+	// - repository name
+	word 		name_;
+
+	// - local path of repository, relative to owner
+	fileSystem localPath_;
+	
+	// - owner of this repository, if any
+	repository* 	 owner_;
+
+	// - sorted names of objects with object index in vector of objects
+	wordMap<IOobject>  	objects_;
+
+	// - list of repositories that this repository owns
+	// - it is not a managed list of pointers!
+	wordMap<repository*> repositories_;
+
+
+	template <typename Type1>
+		word reportTypeError (IOobject& object);
+
+	template <typename Type>
+		bool checkForObjectType(IOobject& object);
+
+public:
+
+	TypeName("repository");
+	
+	//// - Constructors
+
+		// - from a name, local path, and owner 
+		repository(const word& name, const fileSystem& localPath, repository* owner = nullptr);
+
+		// - no copy
+		repository(const repository&) = delete;
+
+		// - no assignment
+		repository& operator=(const repository& )= delete;
+
+		// - destructor 
+		virtual ~repository();
+
+
+	//// - Methods
+
+		// - name of repository 
+		word name()const;
+		
+		// - local path of repository
+		virtual fileSystem localPath()const;
+		
+		// full path of repository 
+		virtual fileSystem path()const ;
+		
+		// - const pointer to the owner
+		const repository* owner()const;
+		
+		// - pointer to the owner
+		repository* owner();
+		
+		// - const ref to this repository 
+		const repository& thisRepository()const;
+		
+		// - ref to this repository 
+		repository& thisRepository();
+		
+		// - add rep 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);
+	
+
+	//// - Add/remove objects 
+
+		// - 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);
+
+		// - 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);
+		
+
+		// - 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;
+		}
+
+
+	//// - lookups and queries
+	
+		// - check if name of object exists
+		bool lookupObjectName(const word& nm)const;
+
+		// - find the object and return the typeName of the object 
+		word lookupObjectTypeName(const word& nm)const;
+
+		// - check if name of object exists
+		//   search all the repositories under the hood of Control (master repository)
+		bool globalLookupObjectName(const word& nm, bool downward = false)const;
+
+		// - check if name of the repository exists 
+		bool lookupRepositoryName(const word& nm)const;
+		
+		// - check if name (object and repository) exists
+		bool lookupName(const word nm)const;
+		
+		// - return number of objects 
+		size_t numObjects()const;
+		
+		// - return number of repositories 
+		size_t numRepositories()const;
+		
+		// - return a ref to the underlaying data in the object 
+		template<typename T>
+		T& lookupObject(const word& name);
+		
+		// - search the name and return a ref to repository
+		repository& lookupRepository(const word& name);
+
+		// list of object names in this repository 
+		wordList objectNames()const;
+		
+		// list of repository names in this repository 
+		wordList repositoryNames()const;
+
+	//// - IO operations 
+		virtual bool write(bool verbose = false) const;
+		
+};
+
+}
+
+#include "repositoryTemplates.C"
+
+#endif //__repository_H__
diff --git a/src/phasicFlow/repository/repository/repositoryTemplates.C b/src/phasicFlow/repository/repository/repositoryTemplates.C
new file mode 100644
index 00000000..b7e514d7
--- /dev/null
+++ b/src/phasicFlow/repository/repository/repositoryTemplates.C
@@ -0,0 +1,172 @@
+/*------------------------------- 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 Type1>
+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();
+
+	return err;
+}
+
+template <typename Type>
+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)
+{
+	if( auto [iter, success] = objects_.findIf(name); success )
+    {
+
+    	if( checkType<T>(iter->second) )
+    	{
+    		return iter->second.template getObject<T>();
+
+    	}else
+    	{
+    		fatalErrorInFunction << 
+    		reportTypeError<T>(iter->second)<<endl;
+    		fatalExit;
+    		return iter->second.template getObject<T>();
+    	}
+        
+    }
+    else
+    {
+    	fatalErrorInFunction << 
+		"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>();
+    }
+}
\ No newline at end of file
diff --git a/src/phasicFlow/repository/systemControl/Control.H b/src/phasicFlow/repository/systemControl/Control.H
new file mode 100644
index 00000000..d9aa3018
--- /dev/null
+++ b/src/phasicFlow/repository/systemControl/Control.H
@@ -0,0 +1,47 @@
+/*------------------------------- 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 __Control_H__
+#define __Control_H__
+
+
+// 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 "systemControl.H"
+#include "timeFolder.H"
+
+namespace pFlow
+{
+
+
+inline systemControl& Control()
+{
+	static systemControl control_;
+	return control_;
+}
+
+} // pFlow
+
+
+#endif // __Control_H__
diff --git a/src/phasicFlow/repository/systemControl/systemControl.C b/src/phasicFlow/repository/systemControl/systemControl.C
new file mode 100644
index 00000000..3226f837
--- /dev/null
+++ b/src/phasicFlow/repository/systemControl/systemControl.C
@@ -0,0 +1,214 @@
+/*------------------------------- 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.H"
+#include "iOstream.H"
+#include "error.H"
+#include "systemControl.H"
+#include "vocabs.H"
+
+
+pFlow::word pFlow::systemControl::getRunName
+(
+	const fileSystem& path
+)
+{
+
+	// gets the canonical form of path
+	word wPath = path.canonical().wordPath()+"/";
+
+	auto first = wPath.find_first_of('/');
+    auto last  = wPath.find_last_of('/');
+
+    if( first == word::npos)
+    {
+    	fatalErrorInFunction <<
+    	"path is empty \n";
+    	fatalExit; 
+    }
+    
+    if( last == wPath.size()-1)
+    {
+    	wPath = wPath.substr(0,last);
+    	last = wPath.find_last_of('/');
+    }
+	
+    word rName = wPath.substr(last+1);
+    
+	return rName;
+
+}
+
+pFlow::word pFlow::systemControl::getTopFolder
+(
+	const fileSystem& path
+)
+{
+
+	// gets the canonical form of path
+	word wPath = path.canonical().wordPath();
+
+	auto first = wPath.find_first_of('/');
+    auto last  = wPath.find_last_of('/');
+
+    if( first == word::npos)
+    {
+    	fatalErrorInFunction <<
+    	"path is empty \n";
+    	fatalExit; 
+    }
+
+    if( last == wPath.size()-1)
+    {
+    	wPath = wPath.substr(0,last);
+    	last = wPath.find_last_of('/');
+    }
+
+    word tFolder = wPath.substr(0,last);
+    
+	return tFolder;
+
+}
+
+
+pFlow::systemControl::systemControl
+(
+	const fileSystem path
+)
+:
+	repository
+	(
+		"systemControl",
+		path, 		// local path
+		nullptr    // no owner
+	),
+	runName_
+	(
+		getRunName(path)
+	),
+	topLevelFolder_
+	(	
+		getTopFolder(path)
+	),
+	settings_
+	(
+		settingsRepository__,
+		settingsFolder__,
+		this
+	),
+	caseSetup_
+	(
+		caseSetupRepository__,
+		caseSetupFolder__,
+		this
+	),
+	settingsDict_
+	(
+		settings().emplaceObject<dictionary>
+		(
+			objectFile
+			(
+				settingsFile__,
+				"",
+				objectFile::READ_ALWAYS,
+				objectFile::WRITE_NEVER
+			),
+			settingsFile__,
+			true
+		)
+	),
+	Time_
+	(
+		this,
+		settingsDict_
+	),
+	g_(
+		settingsDict_.getVal<realx3>("g")
+	),
+	domain_(
+		settingsDict_.subDict("domain")
+	),
+	timers_(runName_),
+	timersReport_
+	(
+		settingsDict_.getValOrSet("timersReport", Logical("Yes"))
+	),
+	writeToFileTimer_("Write to file", &timers_)	
+{}
+
+bool pFlow::systemControl::operator ++(int)
+{
+
+	// skip writing to file for the first iteration 
+	writeToFileTimer_.start();
+	if(time().currentIter() != 0)
+	{
+		//- save the results to file  
+		if( !time().write() )
+		{
+			fatalErrorInFunction;
+			return false;
+		}
+	}
+	else if( time().finished() )
+	{
+		if( !time().write() )
+		{
+			fatalErrorInFunction;
+			return false;
+		}
+	}
+	writeToFileTimer_.end();
+
+	if( time().timersReportTime() &&
+		timersReport() )
+	{
+		timers_.write(output, true);
+	}
+		
+	return time()++;
+
+}
+
+pFlow::Map<pFlow::real, pFlow::fileSystem> 
+	pFlow::systemControl::getTimeFolders()const
+{
+	Map<real, fileSystem> tFolders;
+
+	auto subDirs = subDirectories(this->path());
+
+	for(auto& subD: subDirs)
+	{
+		auto timeName = tailName(subD.wordPath(), '/');
+		real TIME;
+		if( auto success = readReal(timeName, TIME); success)
+		{
+			if(!tFolders.insertIf(TIME, subD))
+			{
+				fatalErrorInFunction<<
+				" duplicate time folder! time = " << TIME <<endl;
+				fatalExit;
+			}
+		}
+	}
+
+	return tFolders;
+}
diff --git a/src/phasicFlow/repository/systemControl/systemControl.H b/src/phasicFlow/repository/systemControl/systemControl.H
new file mode 100644
index 00000000..e6ece5b6
--- /dev/null
+++ b/src/phasicFlow/repository/systemControl/systemControl.H
@@ -0,0 +1,171 @@
+/*------------------------------- 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 __systemControl_H__
+#define __systemControl_H__
+
+
+// top-level entity repository for the whole application 
+// Each application that is executed in pFlow, should have 
+// settings/systemControl file in it. 
+
+
+#include "types.H"
+#include "Time.H"
+#include "dictionary.H"
+#include "box.H"
+#include "Timers.H"
+
+namespace pFlow
+{
+
+class systemControl
+:
+	public repository
+{
+protected:
+
+	// run name 
+	const word 	   		runName_;
+
+	// - path to top-level folder 
+	const fileSystem 	topLevelFolder_;
+
+	// - settings folder repository
+	repository 			settings_;
+
+	// - caseSetup folder repository
+	repository 			caseSetup_;
+
+	// - settingsDict fileDictionary
+	dictionary& 		settingsDict_;
+
+	// - time repository
+	Time 			Time_;
+
+	// - acceleration 
+	realx3 			g_;
+
+	// - domain for dem world
+	box  			domain_;
+
+	// all timers
+	Timers 			timers_;
+
+	Logical			timersReport_;
+
+	Timer 			writeToFileTimer_;
+
+	static word getRunName( const fileSystem& path);
+	
+	static word getTopFolder(const fileSystem& path);
+
+public:
+
+	systemControl( const fileSystem path = CWD() );
+	
+	const repository& settings() const{
+		return settings_;
+	}
+
+	repository& settings(){
+		return settings_;
+	}
+
+	const repository& caseSetup()const{
+		return caseSetup_;
+	}
+
+	repository& caseSetup(){
+		return caseSetup_;
+	}
+
+	
+	const Time& time() const
+	{
+		return const_cast<Time&>(Time_);
+	}
+
+	Time& time()
+	{
+		return Time_;
+	}
+
+	const repository& geometry()const
+	{
+		return Time_.geometry();
+	}
+
+	repository& geometry()
+	{
+		return Time_.geometry();
+	}
+
+	const Timers& timers()const
+	{
+		return timers_;
+	}
+
+	Timers& timers()
+	{
+		return timers_;
+	}
+
+	inline bool timersReport()const
+	{
+		return timersReport_();
+	}
+
+	const dictionary& settingsDict()const{
+		return settingsDict_;
+	}
+
+	dictionary& settingsDict(){
+		return settingsDict_;
+	}
+
+	virtual word runName() const
+	{
+		return runName_;
+	}
+
+	inline const realx3& g()const
+	{
+		return g_;
+	}
+
+	inline const box& domain()const
+	{
+		return domain_;
+	}
+
+	bool operator ++(int);
+
+	Map<real, fileSystem> getTimeFolders()const;
+
+};
+
+
+
+} // pFlow
+
+
+#endif // __systemControl_H__
diff --git a/src/phasicFlow/repository/systemControl/timeFolder.H b/src/phasicFlow/repository/systemControl/timeFolder.H
new file mode 100644
index 00000000..111ada38
--- /dev/null
+++ b/src/phasicFlow/repository/systemControl/timeFolder.H
@@ -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 __timeFolder_H__
+#define __timeFolder_H__
+
+
+#include "systemControl.H"
+
+namespace pFlow
+{
+
+
+class timeFolder
+{
+	using timeList = Map<real, fileSystem>;
+protected:
+	const systemControl& control_;
+
+	timeList 			folders_;
+	
+	timeList::iterator currentFolder_;
+
+	
+public:
+
+	timeFolder(const systemControl& control ):
+		control_(control),
+		folders_(control.getTimeFolders()),
+		currentFolder_(folders_.begin())
+	{}
+
+	real time()const
+	{
+		return currentFolder_->first;
+	}
+
+	fileSystem folder()const
+	{
+		return currentFolder_->second;
+	}
+
+	bool operator ++(int)
+	{
+		if(!finished()) currentFolder_++;
+		return !finished();
+	}
+
+	explicit operator bool()const
+	{
+		return !finished();
+	}
+
+	bool operator !()const
+	{
+		return finished();
+	}
+
+	void rewind()
+	{
+		currentFolder_ = folders_.begin();
+	}
+
+	bool finished()const
+	{
+		if(currentFolder_ == folders_.end()) return true;
+		return false;
+	}
+
+	real startTime()const
+	{
+		auto [t,f] = *folders_.begin();
+		return t;
+	}
+
+	real endTime()const
+	{
+		auto [t,f] = *(--folders_.end());
+		return t;
+	}
+};
+
+
+} // pFlow
+
+
+#endif // __Control_H__
diff --git a/src/phasicFlow/setFieldList/setFieldEntry.C b/src/phasicFlow/setFieldList/setFieldEntry.C
new file mode 100644
index 00000000..7e1c4222
--- /dev/null
+++ b/src/phasicFlow/setFieldList/setFieldEntry.C
@@ -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 "setFieldEntry.H"
+
+pFlow::setFieldEntry::setFieldEntry
+(
+	const dataEntry& entry
+)
+:
+	entry_(entry)
+{}
+
+pFlow::word pFlow::setFieldEntry::fieldName()const
+{
+	return entry_.keyword();
+}
+
+bool pFlow::setFieldEntry::checkForTypeAndValueAll()const
+{
+	if( 
+		!(
+			checkForTypeAndValue<int8>() ||
+			checkForTypeAndValue<int16>() ||
+			checkForTypeAndValue<int32>() ||
+			checkForTypeAndValue<int64>() ||
+			checkForTypeAndValue<uint32>() ||
+			checkForTypeAndValue<label>() ||
+			checkForTypeAndValue<real>()  ||
+			checkForTypeAndValue<realx3>()
+		 )
+	   )
+	{
+		fatalErrorInFunction<< 
+		"  un-supported data type "<<entry_.firstPart() << " in setField for field " << fieldName() <<endl;
+		return false;
+	}
+
+	return true;
+}
+
+bool pFlow::setFieldEntry::setPointFieldDefaultValueNewAll
+(
+	repository& owner,
+	pointStructure& pStruct,
+	bool verbose
+)
+{
+	if( 
+		!(
+			setPointFieldDefaultValueNew<int8> (owner, pStruct, verbose) ||
+			setPointFieldDefaultValueNew<int16>(owner, pStruct, verbose) ||
+			setPointFieldDefaultValueNew<int32> (owner, pStruct, verbose) ||
+			setPointFieldDefaultValueNew<int64> (owner, pStruct, verbose) ||
+			setPointFieldDefaultValueNew<uint32> (owner, pStruct, verbose) ||
+			setPointFieldDefaultValueNew<label>(owner, pStruct, verbose) ||
+			setPointFieldDefaultValueNew<real>(owner, pStruct, verbose)  ||
+			setPointFieldDefaultValueNew<realx3>(owner, pStruct, verbose) ||
+			setPointFieldDefaultValueStdNew<word>(owner, pStruct, verbose)
+		 )
+	   )
+	{
+		fatalErrorInFunction<< 
+		"  un-supported data type "<<entry_.firstPart() << " in setField for field " << fieldName() <<endl;
+		return false;
+	}
+
+	return true;
+}
+
+bool pFlow::setFieldEntry::setPointFieldSelectedAll
+(
+	repository& owner,
+	int32IndexContainer& selected,
+	bool verbose
+)
+{
+
+	if( 
+		!(
+			setPointFieldSelected<int8> (owner, selected, verbose) ||
+			setPointFieldSelected<int16>(owner, selected, verbose) ||
+			setPointFieldSelected<int32> (owner, selected, verbose) ||
+			setPointFieldSelected<int64> (owner, selected, verbose) ||
+			setPointFieldSelected<uint32> (owner, selected, verbose) ||
+			setPointFieldSelected<label>(owner, selected, verbose) ||
+			setPointFieldSelected<real>(owner, selected, verbose)  ||
+			setPointFieldSelected<realx3>(owner, selected, verbose) ||
+			setPointFieldSelectedStd<word>(owner, selected, verbose)
+		 )
+	   )
+	{
+		fatalErrorInFunction<< 
+		"  un-supported data type "<<entry_.firstPart() << " in setField for field " << fieldName() <<endl;
+		return false;
+	}
+
+	return true;
+
+}
diff --git a/src/phasicFlow/setFieldList/setFieldEntry.H b/src/phasicFlow/setFieldList/setFieldEntry.H
new file mode 100644
index 00000000..62f16112
--- /dev/null
+++ b/src/phasicFlow/setFieldList/setFieldEntry.H
@@ -0,0 +1,120 @@
+/*------------------------------- 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 __setFieldEntry_H__
+#define __setFieldEntry_H__
+
+#include "twoPartEntry.H"
+#include "pointFields.H"
+#include "repository.H"
+#include "indexContainer.H"
+
+namespace pFlow
+{
+
+class setFieldEntry
+{
+protected:
+		
+	twoPartEntry 	entry_;
+
+public:
+
+	//// Constructors 
+		
+		setFieldEntry(const dataEntry& entry);
+
+		setFieldEntry(const setFieldEntry&) = default;
+
+		setFieldEntry(setFieldEntry&&) = default;
+
+		setFieldEntry& operator=(const setFieldEntry&) = default;
+
+		setFieldEntry& operator=(setFieldEntry&&) = default;
+
+		~setFieldEntry()=default;
+
+	//// - Methods 
+	
+		word fieldName()const;
+
+		template <typename Type>
+		bool checkForType()const;
+
+		template <typename Type>
+		bool checkForTypeAndValue()const;
+
+		bool checkForTypeAndValueAll()const;
+		
+		template <typename Type>
+		bool setPointFieldDefaultValueNew
+		(
+			repository& owner,
+			pointStructure& pStruct,
+			bool verbose = false
+		);
+
+		template<typename Type>
+		bool setPointFieldDefaultValueStdNew
+		(
+			repository& owner,
+			pointStructure& pStruct,
+			bool verbose = false
+		);
+
+		bool setPointFieldDefaultValueNewAll
+		(
+			repository& owner,
+			pointStructure& pStruct,
+			bool verbose = false
+		);
+
+		template <typename Type>
+		bool setPointFieldSelected
+		(
+			repository& owner,
+			int32IndexContainer& selected,
+			bool verbose = false
+		);
+
+		template <typename Type>
+		bool setPointFieldSelectedStd
+		(
+			repository& owner,
+			int32IndexContainer& selected,
+			bool verbose = false
+		);
+
+		bool setPointFieldSelectedAll
+		(
+			repository& owner,
+			int32IndexContainer& selected,
+			bool verbose = false
+		);
+
+};
+
+} // pFlow
+
+
+#include "setFieldEntryTemplates.C"
+
+#endif
diff --git a/src/phasicFlow/setFieldList/setFieldEntryTemplates.C b/src/phasicFlow/setFieldList/setFieldEntryTemplates.C
new file mode 100644
index 00000000..99ed6745
--- /dev/null
+++ b/src/phasicFlow/setFieldList/setFieldEntryTemplates.C
@@ -0,0 +1,202 @@
+/*------------------------------- 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 Type>
+bool pFlow::setFieldEntry::checkForType()const
+{
+	word typeName( entry_.firstPart() );
+	return basicTypeName<Type>() == typeName;
+};
+
+template <typename Type>
+bool pFlow::setFieldEntry::checkForTypeAndValue()const
+{
+	if( !checkForType<Type>() ) return false;
+	
+	Type defValue = entry_.secondPartVal<Type>();
+	CONSUME_PARAM(defValue);
+	return true;
+}
+
+template <typename Type>
+bool pFlow::setFieldEntry::setPointFieldDefaultValueNew
+(
+	repository& owner,
+	pointStructure& pStruct,
+	bool verbose
+)
+{
+
+	if( !checkForType<Type>() ) return false;
+	
+	Type defValue = entry_.secondPartVal<Type>();
+	
+	if(verbose)
+		Report(2)<<"Creating pointField " << greenText(fieldName())<< " with default value " << cyanText(defValue)<<
+	             " in repository "<< owner.name() <<endReport;
+
+	
+	owner.emplaceObject<pointField<VectorSingle,Type>>
+	(
+		objectFile
+		(
+			fieldName(),
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_ALWAYS
+		),
+		pStruct,
+		defValue
+	);
+
+	return true;
+}
+
+template <typename Type>
+bool pFlow::setFieldEntry::setPointFieldDefaultValueStdNew
+(
+	repository& owner,
+	pointStructure& pStruct,
+	bool verbose
+)
+{
+
+	if( !checkForType<Type>() ) return false;
+	
+	Type defValue = entry_.secondPartVal<Type>();
+	
+	if(verbose)
+		Report(2)<<"Creating pointField " << greenText(fieldName())<< " with default value " << cyanText(defValue)<<
+	             " in repository "<< owner.name() <<endReport;
+
+	// by default we perform operations on host
+	owner.emplaceObject<pointField<Vector,Type, vecAllocator<Type>>>
+	(
+		objectFile
+		(
+			fieldName(),
+			"",
+			objectFile::READ_NEVER,
+			objectFile::WRITE_ALWAYS
+		),
+		pStruct,
+		defValue
+	);
+
+	return true;
+}
+
+template <typename Type>
+bool pFlow::setFieldEntry::setPointFieldSelected
+(
+	repository& owner,
+	int32IndexContainer& selected,
+	bool verbose
+)
+{
+	if( !checkForType<Type>() ) return false;
+
+	
+	auto fName = fieldName();
+
+	if( !owner.lookupObjectName(fName) )
+	{
+		fatalErrorInFunction<<
+		"Cannot find "<< fName << " in repository " << owner.name() << ". \n";
+		return false;
+	}
+
+	Type value = entry_.secondPartVal<Type>();
+
+	if(verbose)
+		Report(2)<< "Setting selected points of " << greenText(fName)
+		 		 << " to value " << cyanText(value) <<endReport;
+	
+	
+	auto fieldTypeName = owner.lookupObjectTypeName(fName);
+
+	if( pointField<VectorSingle,Type>::TYPENAME() == fieldTypeName )
+	{
+		
+		auto& field = owner.lookupObject<pointField<VectorSingle,Type>>(fName);
+		return field.insertSetElement(selected, value);	
+	}
+
+	if( pointField<VectorSingle,Type, HostSpace>::TYPENAME() == fieldTypeName )
+	{
+		
+		auto& field = owner.lookupObject<pointField<VectorSingle,Type,HostSpace>>(fName);
+		return field.insertSetElement(selected, value);	
+	}
+
+	if( pointField<VectorDual,Type>::TYPENAME() == fieldTypeName )
+	{
+		
+		auto& field = owner.lookupObject<pointField<VectorDual,Type>>(fName);
+		return field.insertSetElement(selected, value);	
+	}
+
+	fatalErrorInFunction<<
+	fieldTypeName<< " is not a supported field type for setFieldEntry.\n";
+	return false;
+	
+}
+
+template <typename Type>
+bool pFlow::setFieldEntry::setPointFieldSelectedStd
+(
+	repository& owner,
+	int32IndexContainer& selected,
+	bool verbose
+)
+{
+	
+	if( !checkForType<Type>() ) return false;
+
+	
+	auto fName = fieldName();
+
+	if( !owner.lookupObjectName(fName) )
+	{
+		fatalErrorInFunction<<
+		"  Cannot find "<< fName << " in repository " << owner.name() << ". \n";
+		return false;
+	}
+
+	
+	Type value = entry_.secondPartVal<Type>();
+
+	if(verbose)
+		Report(2)<< "Setting selected points of " << greenText(fName)
+		 		 << " to value " << cyanText(value) <<endReport;
+	
+	
+	auto fieldTypeName = owner.lookupObjectTypeName(fName);
+
+	if( pointField<Vector, Type, vecAllocator<Type>>::TYPENAME() == fieldTypeName )
+	{
+		auto& field = owner.lookupObject<pointField<Vector,Type, vecAllocator<Type>>>(fName);
+		return field.insertSetElement(selected, value);	
+	}
+
+
+	return false;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/setFieldList/setFieldList.C b/src/phasicFlow/setFieldList/setFieldList.C
new file mode 100644
index 00000000..adc28259
--- /dev/null
+++ b/src/phasicFlow/setFieldList/setFieldList.C
@@ -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 "setFieldList.H"
+
+bool pFlow::setFieldList::readSetFieldList(const dictionary& dict)
+{
+	this->clear();
+	wordList Keys = dict.dataEntryKeywords();
+
+	for(const auto& key:Keys)
+	{
+		this->emplace_back( dict.dataEntryRef(key));
+	}
+
+	return true;
+}
+
+bool pFlow::setFieldList::writeSetFieldList
+(
+	dictionary& dict
+)const
+{
+	dict = dict_;
+	return true;
+}
+
+pFlow::setFieldList::setFieldList
+(
+	const dictionary& dict
+)
+:
+	dict_(dict)
+{
+	if(!readSetFieldList(dict_))
+	{
+		fatalExit;
+	}
+}
+
+
+bool pFlow::setFieldList::read
+(
+	const dictionary& dict
+)
+{
+	dict_ = dict;
+	return readSetFieldList(dict);
+}
+
+bool pFlow::setFieldList::write
+(
+	dictionary& dict
+)const
+{
+	return writeSetFieldList(dict);
+}
diff --git a/src/phasicFlow/setFieldList/setFieldList.H b/src/phasicFlow/setFieldList/setFieldList.H
new file mode 100644
index 00000000..2827cf28
--- /dev/null
+++ b/src/phasicFlow/setFieldList/setFieldList.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#ifndef __setFieldList_H__
+#define __setFieldList_H__
+
+#include "List.H"
+#include "setFieldEntry.H"
+#include "dictionary.H"
+
+namespace pFlow
+{
+
+class setFieldList
+:
+	public List<setFieldEntry>
+{
+protected:
+	
+	// setFields dictionary 
+	dictionary dict_;
+
+	bool readSetFieldList(const dictionary& dict);
+
+	bool writeSetFieldList(dictionary& dict)const;
+
+public:
+
+	setFieldList(const dictionary& dict);
+
+	setFieldList(const setFieldList&) = default;
+
+	setFieldList(setFieldList&&) = default;
+
+
+	setFieldList& operator=(const setFieldList&) = default;
+
+	setFieldList& operator=(setFieldList&&) = default;
+
+	auto clone()const
+	{
+		return makeUnique<setFieldList>(*this);
+	}
+
+	setFieldList* clonePtr()const
+	{
+		return new setFieldList(*this);
+	}
+
+	~setFieldList() = default;
+	
+	bool read(const dictionary& dict);
+
+	bool write(dictionary& dict)const;
+
+};
+
+}
+
+
+
+#endif //__setFieldList_H__
diff --git a/src/phasicFlow/smartPointers/uniquePtr.H b/src/phasicFlow/smartPointers/uniquePtr.H
new file mode 100644
index 00000000..0f164af1
--- /dev/null
+++ b/src/phasicFlow/smartPointers/uniquePtr.H
@@ -0,0 +1,110 @@
+/*------------------------------- 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 __uniquePtr_H__
+#define __uniquePtr_H__
+
+
+#include <memory>
+#include <typeinfo>
+
+#include "pFlowMacros.H"
+#include "error.H"
+
+// just for preventing the use of std namespace and adding some minor functionalities
+
+
+namespace pFlow
+{
+
+
+
+template<
+	typename T, 
+	typename Deleter = std::default_delete<T>
+>
+class uniquePtr
+:
+	public std::unique_ptr<T, Deleter>
+{
+public:
+
+	typedef std::unique_ptr<T,Deleter>  uniquePtrType;
+
+	// 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)...));
+    }
+
+    void clear()
+    {
+    	if( ! (*this) )
+    	{
+    		auto p = this->release();
+    		delete p;
+    	}
+    }
+
+    // ref to the object of type T
+	T& operator ()()
+	{
+		if(!this->get())
+		{
+			fatalErrorInFunction <<
+			"uniquePtr is empty, and you are trying to get its reference. \n" <<
+			"Type name is "<< typeid(T).name()<<"\n";
+			fatalExit;
+		}
+		return *this->get();
+	}
+
+	// const ref to the object of type T
+	const T& operator() () const
+	{
+		if(!this->get())
+		{
+			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());
+	}
+
+};
+
+template<class T, class... Args>
+inline uniquePtr<T> makeUnique(Args&&... args)
+{
+    return uniquePtr<T>(new T(std::forward<Args>(args)...));
+}
+
+}
+
+
+
+
+#endif
diff --git a/src/phasicFlow/streams/Stream/Ostream.H b/src/phasicFlow/streams/Stream/Ostream.H
index c1cdf6b0..aff7faf8 100755
--- a/src/phasicFlow/streams/Stream/Ostream.H
+++ b/src/phasicFlow/streams/Stream/Ostream.H
@@ -27,7 +27,7 @@ Licence:
 #include <iostream>
 
 
-namespace dFlow
+namespace pFlow
 {
 
 
@@ -162,7 +162,7 @@ public:
 
 
 
-} // dFlow
+} // pFlow
 
 
 #endif
diff --git a/src/phasicFlow/streams/TStream/iTstream.C b/src/phasicFlow/streams/TStream/iTstream.C
index b9d853bb..cf9f8b0b 100755
--- a/src/phasicFlow/streams/TStream/iTstream.C
+++ b/src/phasicFlow/streams/TStream/iTstream.C
@@ -3,17 +3,17 @@
 #include "error.H"
 #include "iOstream.H"
 
-bool dFlow::iTstream::isLastToken()
+bool pFlow::iTstream::isLastToken()
 {
     return currentToken_ == tokenList_.end();
 }
  
-void dFlow::iTstream::setFirstToken() 
+void pFlow::iTstream::setFirstToken() 
 {
     currentToken_ = tokenList_.begin();
 }
 
-void dFlow::iTstream::validate()
+void pFlow::iTstream::validate()
 {
 	for (auto it = tokenList_.begin(); it != tokenList_.end(); )
 	{
@@ -28,7 +28,7 @@ void dFlow::iTstream::validate()
     }
 }
 
-dFlow::iTstream::iTstream
+pFlow::iTstream::iTstream
 (
     const word& streamName
 )
@@ -43,7 +43,7 @@ dFlow::iTstream::iTstream
     rewind();
 }
 
-dFlow::iTstream::iTstream
+pFlow::iTstream::iTstream
 (
     const word& streamName,
     const tokenList& tList
@@ -61,7 +61,7 @@ dFlow::iTstream::iTstream
     rewind();
 }
 
-dFlow::iTstream::iTstream
+pFlow::iTstream::iTstream
 (
     const word& streamName,
     tokenList&& tList
@@ -81,7 +81,7 @@ dFlow::iTstream::iTstream
 }
 
 // copy assignment from tokenList
-void dFlow::iTstream::operator=(const tokenList& tList)
+void pFlow::iTstream::operator=(const tokenList& tList)
 {
     tokenList_ = tList;
     validate();
@@ -89,25 +89,25 @@ void dFlow::iTstream::operator=(const tokenList& tList)
 }
     
 // move assignment from tokenList
-void dFlow::iTstream::operator=(tokenList&& tList)
+void pFlow::iTstream::operator=(tokenList&& tList)
 {
     tokenList_ = std::move(tList);
     validate();
     rewind();
 }
 
-const dFlow::word& dFlow::iTstream::name() const
+const pFlow::word& pFlow::iTstream::name() const
 {
     return name_;
 }
 
-dFlow::word& dFlow::iTstream::name()
+pFlow::word& pFlow::iTstream::name()
 {
     return name_;
 }
 
 
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     token& t
 )
@@ -164,7 +164,7 @@ dFlow::iIstream& dFlow::iTstream::read
 
 
 
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     char& c
 )
@@ -176,7 +176,7 @@ dFlow::iIstream& dFlow::iTstream::read
 }
 
     
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     word& str
 )
@@ -188,7 +188,7 @@ dFlow::iIstream& dFlow::iTstream::read
 }
 
  
-dFlow::iIstream& dFlow::iTstream::readString
+pFlow::iIstream& pFlow::iTstream::readString
 (
     word& str
 )
@@ -200,7 +200,7 @@ dFlow::iIstream& dFlow::iTstream::readString
 }
 
  
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     int64& val
 )
@@ -211,7 +211,7 @@ dFlow::iIstream& dFlow::iTstream::read
     return *this;
 }
 
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     int32& val
 )
@@ -222,7 +222,7 @@ dFlow::iIstream& dFlow::iTstream::read
     return *this;
 }
 
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     int16& val
 )
@@ -233,7 +233,7 @@ dFlow::iIstream& dFlow::iTstream::read
     return *this;
 }
  
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     int8& val
 )
@@ -244,7 +244,7 @@ dFlow::iIstream& dFlow::iTstream::read
     return *this;
 }
 
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     label& val
 )
@@ -255,7 +255,7 @@ dFlow::iIstream& dFlow::iTstream::read
     return *this;
 }
 
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     uint32& val
 )
@@ -266,7 +266,7 @@ dFlow::iIstream& dFlow::iTstream::read
     return *this;
 }
 
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     uint16& val
 )
@@ -278,7 +278,7 @@ dFlow::iIstream& dFlow::iTstream::read
 }
 
  
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     float& val
 )
@@ -290,7 +290,7 @@ dFlow::iIstream& dFlow::iTstream::read
 }
 
  
-dFlow::iIstream& dFlow::iTstream::read
+pFlow::iIstream& pFlow::iTstream::read
 (
     double& val
 )
@@ -304,7 +304,7 @@ dFlow::iIstream& dFlow::iTstream::read
 
 
 
-void dFlow::iTstream::rewind()
+void pFlow::iTstream::rewind()
 {
     iIstream::resetPutBack();
     setFirstToken();
@@ -312,7 +312,7 @@ void dFlow::iTstream::rewind()
 }
 
 
-void dFlow::iTstream::reset()
+void pFlow::iTstream::reset()
 {
     iIstream::resetPutBack();
     tokenList_.clear();
@@ -320,22 +320,22 @@ void dFlow::iTstream::reset()
     setGood();
 }
 
-const dFlow::tokenList& dFlow::iTstream::tokens()const
+const pFlow::tokenList& pFlow::iTstream::tokens()const
 {
     return tokenList_;
 }
 
-size_t dFlow::iTstream::size()const 
+size_t pFlow::iTstream::size()const 
 {
     return tokenList_.size();
 }
 
-size_t dFlow::iTstream::numTokens()const
+size_t pFlow::iTstream::numTokens()const
 {
     return tokenList_.size();
 }
 
-void dFlow::iTstream::appendTokens
+void pFlow::iTstream::appendTokens
 (
     const tokenList & tList
 )
@@ -348,7 +348,7 @@ void dFlow::iTstream::appendTokens
     rewind();
 }
 
-void dFlow::iTstream::appendToken
+void pFlow::iTstream::appendToken
 (
     const token& t
 )
diff --git a/src/phasicFlow/streams/TStream/iTstream.H b/src/phasicFlow/streams/TStream/iTstream.H
index 7f4f3b60..61d739e1 100755
--- a/src/phasicFlow/streams/TStream/iTstream.H
+++ b/src/phasicFlow/streams/TStream/iTstream.H
@@ -7,7 +7,7 @@
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace dFlow
+namespace pFlow
 {
 
 // helper functions declearation
diff --git a/src/phasicFlow/streams/TStream/oTstream.C b/src/phasicFlow/streams/TStream/oTstream.C
index 3b14c9c3..6113040e 100755
--- a/src/phasicFlow/streams/TStream/oTstream.C
+++ b/src/phasicFlow/streams/TStream/oTstream.C
@@ -2,7 +2,7 @@
 #include "oTstream.H"
 #include "error.H"
 
-dFlow::oTstream::oTstream
+pFlow::oTstream::oTstream
 (
     const word& nm
 )
@@ -15,7 +15,7 @@ dFlow::oTstream::oTstream
     setGood();
 }
 
-dFlow::oTstream::oTstream
+pFlow::oTstream::oTstream
 (
     const oTstream& src
 )
@@ -29,19 +29,19 @@ dFlow::oTstream::oTstream
 }
 
 
-const dFlow::tokenList& dFlow::oTstream::tokens()const
+const pFlow::tokenList& pFlow::oTstream::tokens()const
 {
     return tokenList_;
 }
 
 
-dFlow::tokenList& dFlow::oTstream::tokens()
+pFlow::tokenList& pFlow::oTstream::tokens()
 {
     return tokenList_;
 }
 
 
-bool dFlow::oTstream::write(const token& tok)
+bool pFlow::oTstream::write(const token& tok)
 {
     if (tok.good())
     {
@@ -53,7 +53,7 @@ bool dFlow::oTstream::write(const token& tok)
 }
 
 
-dFlow::iOstream& dFlow::oTstream::write(const char c)
+pFlow::iOstream& pFlow::oTstream::write(const char c)
 {
     if (!std::isspace(c) && std::isprint(c))
     {
@@ -65,7 +65,7 @@ dFlow::iOstream& dFlow::oTstream::write(const char c)
 }
 
 
-dFlow::iOstream& dFlow::oTstream::write(const char* str)
+pFlow::iOstream& pFlow::oTstream::write(const char* str)
 {
     
     append(token(word(str)));
@@ -74,7 +74,7 @@ dFlow::iOstream& dFlow::oTstream::write(const char* str)
 }
 
 
-dFlow::iOstream& dFlow::oTstream::write(const word& str)
+pFlow::iOstream& pFlow::oTstream::write(const word& str)
 {
     append(token(str)); // tokenType::WORD
 
@@ -82,7 +82,7 @@ dFlow::iOstream& dFlow::oTstream::write(const word& str)
 }
 
 
-dFlow::iOstream& dFlow::oTstream::writeQuoted
+pFlow::iOstream& pFlow::oTstream::writeQuoted
 (
     const word& str,
     const bool quoted
@@ -94,14 +94,14 @@ dFlow::iOstream& dFlow::oTstream::writeQuoted
     return *this;
 }
 
-dFlow::iOstream& dFlow::oTstream::write(const int64 val)
+pFlow::iOstream& pFlow::oTstream::write(const int64 val)
 {
     append(token(val)); // tokenType::INT64
 
     return *this;
 }
 
-dFlow::iOstream& dFlow::oTstream::write(const int32 val)
+pFlow::iOstream& pFlow::oTstream::write(const int32 val)
 {
     append(token(val)); // tokenType::INT64
 
@@ -111,21 +111,21 @@ dFlow::iOstream& dFlow::oTstream::write(const int32 val)
 
 
 
-dFlow::iOstream& dFlow::oTstream::write(const label val)
+pFlow::iOstream& pFlow::oTstream::write(const label val)
 {
     append(token(static_cast<int64>(val))); // tokenType::INT64
 
     return *this;
 }
 
-dFlow::iOstream& dFlow::oTstream::write(const uint32 val)
+pFlow::iOstream& pFlow::oTstream::write(const uint32 val)
 {
     append(token(static_cast<int64>(val))); // tokenType::INT64
 
     return *this;
 }
 
-dFlow::iOstream& dFlow::oTstream::write(const uint16 val)
+pFlow::iOstream& pFlow::oTstream::write(const uint16 val)
 {
     append(token(static_cast<int64>(val))); // tokenType::INT64
 
@@ -133,7 +133,7 @@ dFlow::iOstream& dFlow::oTstream::write(const uint16 val)
 }
 
 
-dFlow::iOstream& dFlow::oTstream::write(const float val)
+pFlow::iOstream& pFlow::oTstream::write(const float val)
 {
     append(token(val)); // tokenType::FLOAT
 
@@ -141,7 +141,7 @@ dFlow::iOstream& dFlow::oTstream::write(const float val)
 }
 
 
-dFlow::iOstream& dFlow::oTstream::write(const double val)
+pFlow::iOstream& pFlow::oTstream::write(const double val)
 {
     append(token(val)); // tokenType::DOUBLE
 
@@ -150,14 +150,14 @@ dFlow::iOstream& dFlow::oTstream::write(const double val)
 
 
 
-void dFlow::oTstream::append(const token& tok)
+void pFlow::oTstream::append(const token& tok)
 {
     
     if( validTokenForStream(tok) )
     	tokenList_.push_back(tok);
 }
 
-void dFlow::oTstream::append(const tokenList& tLisk)
+void pFlow::oTstream::append(const tokenList& tLisk)
 {
     for(auto& e:tLisk)
     {
@@ -165,13 +165,13 @@ void dFlow::oTstream::append(const tokenList& tLisk)
     }
 }
 
-void dFlow::oTstream::reset()
+void pFlow::oTstream::reset()
 {
     this->rewind();
 }
 
 //- Rewind the output stream
-void dFlow::oTstream::rewind()
+void pFlow::oTstream::rewind()
 {
     tokenList_.clear();
     setGood();
diff --git a/src/phasicFlow/streams/TStream/oTstream.H b/src/phasicFlow/streams/TStream/oTstream.H
index ef71f2c0..5fa660b6 100755
--- a/src/phasicFlow/streams/TStream/oTstream.H
+++ b/src/phasicFlow/streams/TStream/oTstream.H
@@ -8,7 +8,7 @@
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace dFlow
+namespace pFlow
 {
 
 
@@ -187,7 +187,7 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace dFlow
+} // End namespace pFlow
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/phasicFlow/streams/iStream/iIstream.C b/src/phasicFlow/streams/iStream/iIstream.C
index 5951aa30..cff6d954 100755
--- a/src/phasicFlow/streams/iStream/iIstream.C
+++ b/src/phasicFlow/streams/iStream/iIstream.C
@@ -2,7 +2,7 @@
 #include "iIstream.H"
 
 
-void dFlow::iIstream::putBack(const token& tok)
+void pFlow::iIstream::putBack(const token& tok)
 {
     if (bad())
     {
@@ -24,7 +24,7 @@ void dFlow::iIstream::putBack(const token& tok)
 }
 
 
-bool dFlow::iIstream::getBack(token& tok)
+bool pFlow::iIstream::getBack(token& tok)
 {
     
     if (bad())
@@ -43,7 +43,7 @@ bool dFlow::iIstream::getBack(token& tok)
 }
 
 
-bool dFlow::iIstream::peekBack(token& tok)
+bool pFlow::iIstream::peekBack(token& tok)
 {
     if (putBack_)
     {
@@ -57,7 +57,7 @@ bool dFlow::iIstream::peekBack(token& tok)
     return putBack_;
 }
 
-bool dFlow::iIstream::findToken( const word & w )
+bool pFlow::iIstream::findToken( const word & w )
 {
     rewind();
     token next;
@@ -82,7 +82,7 @@ bool dFlow::iIstream::findToken( const word & w )
     return false;
 }
 
-bool dFlow::iIstream::findTokenSilent( const word & w, int32 limitLine )
+bool pFlow::iIstream::findTokenSilent( const word & w, int32 limitLine )
 {
     rewind();
     token next;
@@ -104,7 +104,7 @@ bool dFlow::iIstream::findTokenSilent( const word & w, int32 limitLine )
     return false;   
 }
 
-bool dFlow::iIstream::findTokenAndNext
+bool pFlow::iIstream::findTokenAndNext
 ( 
     const word& w,
     word& nextW,
@@ -151,7 +151,7 @@ bool dFlow::iIstream::findTokenAndNext
     return false;
 }
 
-bool dFlow::iIstream::findTokenAndNextSilent(const word& w, word& nextW, int32 limitLine)
+bool pFlow::iIstream::findTokenAndNextSilent(const word& w, word& nextW, int32 limitLine)
 {
     if( findTokenSilent(w, limitLine) )
     {
@@ -186,7 +186,7 @@ bool dFlow::iIstream::findTokenAndNextSilent(const word& w, word& nextW, int32 l
 }
 
 
-bool dFlow::iIstream::readBegin(const char* funcName)
+bool pFlow::iIstream::readBegin(const char* funcName)
 {   
     
     const token delimiter(*this);
@@ -206,7 +206,7 @@ bool dFlow::iIstream::readBegin(const char* funcName)
 }
 
 
-bool dFlow::iIstream::readEnd(const char* funcName)
+bool pFlow::iIstream::readEnd(const char* funcName)
 {
     const token delimiter(*this);
 
@@ -225,7 +225,7 @@ bool dFlow::iIstream::readEnd(const char* funcName)
     return true;
 }
 
-bool dFlow::iIstream::readBeginSquare(const char* funcName)
+bool pFlow::iIstream::readBeginSquare(const char* funcName)
 {
 	const token delimiter(*this);
 
@@ -244,7 +244,7 @@ bool dFlow::iIstream::readBeginSquare(const char* funcName)
     return true;
 }
 	    
-bool dFlow::iIstream::readEndSquare(const char* funcName)
+bool pFlow::iIstream::readEndSquare(const char* funcName)
 {
 	const token delimiter(*this);
 
@@ -263,7 +263,7 @@ bool dFlow::iIstream::readEndSquare(const char* funcName)
     return true;
 }
 
-char dFlow::iIstream::readBeginList(const char* funcName)
+char pFlow::iIstream::readBeginList(const char* funcName)
 {
     const token delimiter(*this);
 
@@ -284,7 +284,7 @@ char dFlow::iIstream::readBeginList(const char* funcName)
 }
 
 
-char dFlow::iIstream::readEndList(const char* funcName)
+char pFlow::iIstream::readEndList(const char* funcName)
 {
     const token delimiter(*this);
 
@@ -307,7 +307,7 @@ char dFlow::iIstream::readEndList(const char* funcName)
 }
 
 
-char dFlow::iIstream::readEndStatement(const char* funcName)
+char pFlow::iIstream::readEndStatement(const char* funcName)
 {
     CONSUME_PARAM(funcName);
     const token delimiter(*this);
@@ -325,7 +325,7 @@ char dFlow::iIstream::readEndStatement(const char* funcName)
     return delimiter.pToken();
 }
 
-dFlow::iIstream& dFlow::iIstream::operator()() const
+pFlow::iIstream& pFlow::iIstream::operator()() const
 {
     if (!good())
     {
diff --git a/src/phasicFlow/streams/streams.C b/src/phasicFlow/streams/streams.C
index 963ee2e9..7da2819a 100755
--- a/src/phasicFlow/streams/streams.C
+++ b/src/phasicFlow/streams/streams.C
@@ -1,8 +1,8 @@
 #include "streams.H"
 
 
-dFlow::Ostream dFlow::output(std::cout, "dFlow Ostream");
+pFlow::Ostream pFlow::output(std::cout, "pFlow Ostream");
 
-dFlow::Istream dFlow::input( std::cin, "sFlow Istream"); 
+pFlow::Istream pFlow::input( std::cin, "sFlow Istream"); 
 
-dFlow::Ostream dFlow::errReport( std::cerr, "dFlow error report stream");
+pFlow::Ostream pFlow::errReport( std::cerr, "pFlow error report stream");
diff --git a/src/phasicFlow/streams/streams.H b/src/phasicFlow/streams/streams.H
index d64babaf..ea52ed2d 100755
--- a/src/phasicFlow/streams/streams.H
+++ b/src/phasicFlow/streams/streams.H
@@ -13,7 +13,7 @@
 
 #include "iTstream.H"
 
-namespace dFlow
+namespace pFlow
 {
 
 
@@ -34,16 +34,16 @@ namespace dFlow
 #define cyanText(text) 		cyanColor<<text<<defaultColor
 #define boldText(text) 		boldChar<<text<<defaultColor
 
-#define Info dFlow::output<<boldChar<<magentaColor<<"> Info: "<<defaultColor<<magentaColor
-#define endInfo defaultColor<<dFlow::nl
+#define Info pFlow::output<<boldChar<<magentaColor<<"> Info: "<<defaultColor<<magentaColor
+#define endInfo defaultColor<<pFlow::nl
 
-#define Report(n) dFlow::output.space(2*n)
-#define endReport dFlow::nl
+#define Report(n) pFlow::output.space(2*n)
+#define endReport pFlow::nl
 
-#define Warning dFlow::output<<boldChar<<yellowColor<<"> Warning\n"<<defaultColor<<yellowColor<<"  " 
-#define endWarning defaultColor<<dFlow::nl
+#define Warning pFlow::output<<boldChar<<yellowColor<<"> Warning\n"<<defaultColor<<yellowColor<<"  " 
+#define endWarning defaultColor<<pFlow::nl
 
-#define Err dFlow::output<<boldChar<<redColor<<"> Error\n"<<defaultColor<<redColor<<"  " 
-#define endErr defaultColor<<dFlow::nl
+#define Err pFlow::output<<boldChar<<redColor<<"> Error\n"<<defaultColor<<redColor<<"  " 
+#define endErr defaultColor<<pFlow::nl
 
 #endif
diff --git a/src/phasicFlow/structuredData/box/box.C b/src/phasicFlow/structuredData/box/box.C
new file mode 100644
index 00000000..65846b30
--- /dev/null
+++ b/src/phasicFlow/structuredData/box/box.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#include "box.H"
+
+FUNCTION_HD
+pFlow::box::box
+(
+	const realx3& minP,
+	const realx3& maxP
+)
+:
+	min_(minP),
+	max_(maxP)
+{}
+
+FUNCTION_H
+pFlow::box::box
+(
+	const dictionary & dict
+)
+:
+	min_
+	(
+		dict.getVal<realx3>("min")
+	),
+	max_
+	(
+		dict.getVal<realx3>("max")
+	)
+{}
+
+FUNCTION_H
+pFlow::box::box
+(
+	iIstream& is
+)
+{
+	if( !read(is))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"error in reading box from file. \n";
+		fatalExit;
+	}
+}
+
+
+FUNCTION_H
+bool pFlow::box::read(iIstream & is)
+{
+	if(!is.nextData<realx3>("min", min_)) return false;
+	if(!is.nextData<realx3>("max", max_)) return false;
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::box::write(iOstream& os)const
+{
+	os.writeWordEntry("min", min_);
+	os.writeWordEntry("max", max_);
+	return os.check(FUNCTION_NAME);
+}
+
+FUNCTION_H
+bool pFlow::box::read
+(
+	const dictionary& dict
+)
+{
+	min_ = dict.getVal<realx3>("min");
+	max_ = dict.getVal<realx3>("max");
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::box::write
+(
+	dictionary& dict
+)const
+{
+	if(!dict.add("min", min_))
+	{
+		fatalErrorInFunction<<
+		"  error in writing min to dictionary "<<dict.globalName()<<endl;
+		return false;
+	}
+
+	if(!dict.add("max", max_))
+	{
+		fatalErrorInFunction<<
+		"  error in writing max to dictionary "<<dict.globalName()<<endl;
+		return false;
+	}
+	
+	return true;
+}
+
+FUNCTION_H
+pFlow::iIstream& pFlow::operator << (iIstream& is, box& b)
+{
+	if(! b.read(is))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"error in reading box. \n";
+		fatalExit;
+	}
+	return is;
+}
+
+FUNCTION_H
+pFlow::iOstream& pFlow::operator >> (iOstream& os, const box& b)
+{
+	
+	if(! b.write(os))
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+		"error in writing box. \n";
+		fatalExit;
+	}
+	return os;	
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/box/box.H b/src/phasicFlow/structuredData/box/box.H
new file mode 100644
index 00000000..1720c734
--- /dev/null
+++ b/src/phasicFlow/structuredData/box/box.H
@@ -0,0 +1,115 @@
+/*------------------------------- 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 __box_H__
+#define __box_H__
+
+#include "types.H"
+#include "dictionary.H"
+#include "iIstream.H"
+#include "iOstream.H"
+
+namespace pFlow
+{
+
+class box
+{
+protected:
+	
+	// - min point
+	realx3 	min_;
+	
+	// - max point 
+	realx3 	max_;
+
+public:
+
+	// - type info
+	TypeNameNV("box");
+
+	//// - Constructors 
+		FUNCTION_HD 
+		box(const realx3& minP, const realx3& maxP);
+
+		FUNCTION_H
+		box(const dictionary& dict);
+
+		FUNCTION_H
+		box(iIstream& is);
+
+		FUNCTION_HD
+		box(const box&) = default;
+
+		FUNCTION_HD
+		box(box&&) = default;
+
+		FUNCTION_HD
+		box& operator=(const box&) = default;
+
+		FUNCTION_HD
+		box& operator=(box&&) = default;
+
+		~box()=default;
+
+	//// - Methods 
+
+		INLINE_FUNCTION_HD
+		bool isInside(const realx3& point)const
+		{
+			return point > min_ && point <max_;
+		}
+
+		INLINE_FUNCTION_HD
+		const realx3& minPoint()const
+		{
+			return min_;
+		}
+
+		INLINE_FUNCTION_HD
+		const realx3& maxPoint()const
+		{
+			return max_;
+		}
+
+	//// - IO operation 
+		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;
+};
+
+FUNCTION_H
+iIstream& operator << (iIstream& is, box& b);
+
+FUNCTION_H
+iOstream& operator >> (iOstream& os, const box& b);
+
+
+}
+
+
+#endif
diff --git a/src/phasicFlow/structuredData/iBox/iBox.C b/src/phasicFlow/structuredData/iBox/iBox.C
new file mode 100644
index 00000000..2e5e9989
--- /dev/null
+++ b/src/phasicFlow/structuredData/iBox/iBox.C
@@ -0,0 +1,162 @@
+/*------------------------------- 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 intType>
+INLINE_FUNCTION_HD
+pFlow::iBox<intType>::iBox()
+:
+	min_(0),
+	max_(1)
+{}
+
+
+template<typename intType>
+INLINE_FUNCTION_HD
+pFlow::iBox<intType>::iBox(
+	const triple<intType>& minP,
+	const triple<intType>& maxP)
+:
+	min_(minP),
+	max_(maxP)
+{}
+
+template<typename intType>
+FUNCTION_H
+pFlow::iBox<intType>::iBox
+(
+	const dictionary & dict
+)
+:
+	min_
+	(
+		dict.getVal<triple<intType>>("min")
+	),
+	max_
+	(
+		dict.getVal<triple<intType>>("max")
+	)
+{}
+
+template<typename intType>
+FUNCTION_H
+pFlow::iBox<intType>::iBox
+(
+	iIstream& is
+)
+{
+	if( !read(is))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"error in reading iBox from file. \n";
+		fatalExit;
+	}
+}
+
+template<typename intType>
+INLINE_FUNCTION_HD 
+bool pFlow::iBox<intType>::isInside
+(
+	const triple<intType>& point
+)const
+{
+	return point >= min_ && point <= max_;
+}
+
+template<typename intType>
+FUNCTION_H
+bool pFlow::iBox<intType>::read(iIstream & is)
+{
+	if(!is.nextData<triple<intType>>("min", min_)) return false;
+	if(!is.nextData<triple<intType>>("max", max_)) return false;
+	return true;
+}
+
+template<typename intType>
+FUNCTION_H
+bool pFlow::iBox<intType>::write(iOstream& os)const
+{
+	os.writeWordEntry("min", min_);
+	os.writeWordEntry("max", max_);
+	return os.check(FUNCTION_NAME);
+}
+
+template<typename intType>
+FUNCTION_H
+bool pFlow::iBox<intType>::read
+(
+	const dictionary& dict
+)
+{
+	min_ = dict.getVal<triple<intType>>("min");
+	max_ = dict.getVal<triple<intType>>("max");
+	return true;
+}
+
+template<typename intType>
+FUNCTION_H
+bool pFlow::iBox<intType>::write
+(
+	dictionary& dict
+)const
+{
+	if(!dict.add("min", min_))
+	{
+		fatalErrorInFunction<<
+		"  error in writing min to dictionary "<<dict.globalName()<<endl;
+		return false;
+	}
+
+	if(!dict.add("max", max_))
+	{
+		fatalErrorInFunction<<
+		"  error in writing max to dictionary "<<dict.globalName()<<endl;
+		return false;
+	}
+	
+	return true;
+}
+
+template<typename intType>
+FUNCTION_H
+pFlow::iIstream& pFlow::operator >> (iIstream& is, iBox<intType>& b)
+{
+	if(! b.read(is))
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"error in reading iBox. \n";
+		fatalExit;
+	}
+	return is;
+}
+
+template<typename intType>
+FUNCTION_H
+pFlow::iOstream& pFlow::operator << (iOstream& os, const iBox<intType>& b)
+{
+	
+	if(! b.write(os))
+	{
+		ioErrorInFile(os.name(), os.lineNumber())<<
+		"error in writing iBox. \n";
+		fatalExit;
+	}
+	return os;	
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/iBox/iBox.H b/src/phasicFlow/structuredData/iBox/iBox.H
new file mode 100644
index 00000000..8c4e8853
--- /dev/null
+++ b/src/phasicFlow/structuredData/iBox/iBox.H
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef __iBox_H__
+#define __iBox_H__
+
+#include "types.H"
+#include "dictionary.H"
+#include "iIstream.H"
+#include "iOstream.H"
+
+namespace pFlow
+{
+
+template<typename intType>
+class iBox
+{
+protected:
+	
+	// - min point
+	triple<intType> 	min_;
+	
+	// - max point 
+	triple<intType> 	max_;
+
+public:
+
+	// - type info
+	TypeNameTemplateNV("iBox", intType);
+
+	//// - Constructors 
+		INLINE_FUNCTION_HD 
+		iBox();
+
+		INLINE_FUNCTION_HD 
+		iBox(const triple<intType> & minP, const triple<intType> & maxP);
+
+		FUNCTION_H
+		iBox(const dictionary& dict);
+
+		FUNCTION_H
+		iBox(iIstream& is);
+
+		FUNCTION_HD
+		iBox(const iBox&) = default;
+
+		FUNCTION_HD
+		iBox(iBox&&) = default;
+
+		FUNCTION_HD
+		iBox& operator=(const iBox&) = default;
+
+		FUNCTION_HD
+		iBox& operator=(iBox&&) = default;
+
+		~iBox()=default;
+
+	//// - Methods 
+
+		INLINE_FUNCTION_HD
+		bool isInside(const triple<intType> & point)const;
+
+		INLINE_FUNCTION_HD
+		const triple<intType> & minPoint()const
+		{
+			return min_;
+		}
+
+		INLINE_FUNCTION_HD
+		const triple<intType> & maxPoint()const
+		{
+			return max_;
+		}
+
+	//// - IO operation 
+		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;
+};
+
+template<typename intType>
+FUNCTION_H
+iIstream& operator >> (iIstream& is, iBox<intType>& b);
+
+template<typename intType>
+FUNCTION_H
+iOstream& operator << (iOstream& os, const iBox<intType>& b);
+
+
+
+}
+
+
+#include "iBox.C"
+
+
+#endif
diff --git a/src/phasicFlow/structuredData/iBox/iBoxs.C b/src/phasicFlow/structuredData/iBox/iBoxs.C
new file mode 100644
index 00000000..47cc0622
--- /dev/null
+++ b/src/phasicFlow/structuredData/iBox/iBoxs.C
@@ -0,0 +1,34 @@
+/*------------------------------- 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 "iBox.H"
+
+
+template class pFlow::iBox<pFlow::uint16>;
+
+template class pFlow::iBox<pFlow::uint32>;
+
+template class pFlow::iBox<pFlow::label>;
+
+template class pFlow::iBox<pFlow::int16>;
+
+template class pFlow::iBox<pFlow::int32>;
+
+template class pFlow::iBox<pFlow::int64>;
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/line/line.C b/src/phasicFlow/structuredData/line/line.C
new file mode 100755
index 00000000..a94386a3
--- /dev/null
+++ b/src/phasicFlow/structuredData/line/line.C
@@ -0,0 +1,131 @@
+/*------------------------------- 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 "line.H"
+#include "dictionary.H"
+
+
+FUNCTION_HD
+pFlow::line::line
+(
+	const realx3 &lp1,
+	const realx3 &lp2
+)
+{
+	set(lp1, lp2);
+}
+
+FUNCTION_H
+pFlow::line::line
+(
+	const dictionary& dict
+)
+{
+	if(!read(dict))
+	{
+		fatalExit;
+	}
+}
+
+FUNCTION_H
+bool pFlow::line::read
+(
+	const dictionary& dict
+)
+{
+	realx3 p1 = dict.getVal<realx3>("p1");
+	realx3 p2 = dict.getVal<realx3>("p2");
+	set(p1, p2);
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::line::write(dictionary& dict) const
+{
+	if(!dict.add("p1", point1()))
+	{
+		fatalErrorInFunction <<
+		" error in writing p1 to dictionary " << dict.globalName()<<endl;
+		return false;
+	}
+
+	if(!dict.add("p2", point2()))
+	{
+		fatalErrorInFunction <<
+		" error in writing p2 to dictionary " << dict.globalName()<<endl;
+		return false;
+	}
+
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::line::read
+(
+	iIstream& is
+)
+{
+	word p1w;
+	realx3 p1;
+	is >> p1w >> p1;
+	if( !is.check(FUNCTION_NAME))
+	{
+		ioErrorInFile(is.name(), is.lineNumber());
+		return false;
+	}
+	if(p1w != "p1")
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"  expected p1 but found "<< p1w<<endl;
+		return false;
+	}
+	is.readEndStatement(FUNCTION_NAME);
+
+	word p2w;
+	realx3 p2;
+	is >> p2w >> p2;
+
+	if( !is.check(FUNCTION_NAME))
+	{
+		ioErrorInFile(is.name(), is.lineNumber());
+		return false;
+	}
+	if(p2w != "p2")
+	{
+		ioErrorInFile(is.name(), is.lineNumber())<<
+		"  expected p2 but found "<< p2w<<endl;
+		return false;
+	}
+	is.readEndStatement(FUNCTION_NAME);
+	set(p1,p2);
+	return true;
+}
+
+FUNCTION_H
+bool pFlow::line::write
+(
+	iOstream& os
+)const
+{
+	os.writeWordEntry("p1", point1());
+	os.writeWordEntry("p2", point2());
+	return os.check(FUNCTION_NAME);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/line/line.H b/src/phasicFlow/structuredData/line/line.H
new file mode 100755
index 00000000..56e5bb97
--- /dev/null
+++ b/src/phasicFlow/structuredData/line/line.H
@@ -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 __line_H__
+#define __line_H__
+
+#include "types.H"
+#include "typeInfo.H"
+
+namespace pFlow
+{
+
+
+class dictionary;
+
+
+// pLine 
+class line
+{
+protected:
+	
+	// point 1
+	realx3 p1_;
+
+	// vector pointing from 1 to 2
+	realx3 v21_; 
+
+public:
+
+	TypeNameNV("line");
+
+	//// - Constructors 
+		FUNCTION_HD
+		line()
+		{}
+
+		FUNCTION_HD
+		line(const realx3 &lp1, const realx3 &lp2);
+
+		FUNCTION_H
+		line(const dictionary& dict);
+
+		FUNCTION_HD
+		line(const line& src) = default;
+
+		FUNCTION_HD
+		line(line&& src) = default;
+
+		FUNCTION_HD
+		line& operator = (const line&) = default;
+
+		FUNCTION_HD
+		line& operator = (line&&) = default;
+
+	
+	//// - Methods 
+		
+		// set two points of line 
+		INLINE_FUNCTION_HD
+		void set(const realx3 &lp1, const realx3 &lp2)
+		{
+			v21_ = lp2 - lp1;
+			p1_ = lp1;
+		}
+
+		// return point 1
+		INLINE_FUNCTION_HD
+		realx3 point1()const { return p1_; }
+
+		// return point 2
+		INLINE_FUNCTION_HD
+		realx3 point2()const { return point(1.0); }
+
+		// get a point on the line based on input  0<= t <= 1
+		INLINE_FUNCTION_HD
+		realx3 point(real t)const  { return v21_ * t + p1_; }
+
+		// length of line 
+		INLINE_FUNCTION_HD
+		real length()const { return pFlow::length(v21_); }
+
+		// get unit vector of the line direction vector  
+		INLINE_FUNCTION_HD
+		realx3 unitVector() const{ return normalize(v21_); }
+
+		// return the projected point of point p on line
+		INLINE_FUNCTION_HD
+		realx3 projectPoint(const realx3 &p) const
+		{
+			return point(projectNormalizedLength(p));
+		}
+
+		// calculates the normalized distance between projected p and p1 
+		INLINE_FUNCTION_HD
+		real projectNormalizedLength(realx3 p) const 
+		{
+			realx3 w = p - p1_;
+			return dot(w,v21_) / dot(v21_,v21_);
+		}
+
+	//// - IO operation 
+		FUNCTION_H
+		bool read(const dictionary& dict);
+
+		FUNCTION_H
+		bool write(dictionary& ditc) const;
+		
+		FUNCTION_H
+		bool read(iIstream& is);
+
+		FUNCTION_H
+		bool write(iOstream& os)const;
+
+
+};
+
+
+}
+
+
+#endif // 
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/peakableRegion/PeakableRegion/PeakableRegion.C b/src/phasicFlow/structuredData/peakableRegion/PeakableRegion/PeakableRegion.C
new file mode 100644
index 00000000..f178026b
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/PeakableRegion/PeakableRegion.C
@@ -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<typename RegionType>
+pFlow::PeakableRegion<RegionType>::PeakableRegion
+(
+	const word& type, 
+	const dictionary& dict
+)
+:
+	peakableRegion(type, dict),
+	region_(dict)
+{
+	
+}
+
+template<typename RegionType>
+bool  pFlow::PeakableRegion<RegionType>::isInside
+(
+	const realx3& point
+)const
+{
+	return region_.isInside(point);
+}
+
+
+template<typename RegionType>
+pFlow::realx3 pFlow::PeakableRegion<RegionType>::peek()const
+{
+	return region_.peek();
+}
+	
+template<typename RegionType>
+bool pFlow::PeakableRegion<RegionType>::read(const dictionary& dict)
+{
+	return region_.read(dict);
+}
+
+template<typename RegionType>
+bool pFlow::PeakableRegion<RegionType>::write(dictionary& dict)const
+{
+	return region_.write(dict);
+}
+
+
diff --git a/src/phasicFlow/structuredData/peakableRegion/PeakableRegion/PeakableRegion.H b/src/phasicFlow/structuredData/peakableRegion/PeakableRegion/PeakableRegion.H
new file mode 100644
index 00000000..bab2f04d
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/PeakableRegion/PeakableRegion.H
@@ -0,0 +1,90 @@
+/*------------------------------- 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 __PeakableRegion_H__
+#define __PeakableRegion_H__
+
+
+#include "peakableRegion.H"
+#include "dictionary.H"
+
+namespace pFlow
+{
+
+
+
+
+template<typename RegionType>
+class PeakableRegion
+:
+	public peakableRegion
+{
+protected:
+
+	RegionType 		region_;
+
+public:
+
+	// type info
+	TypeNameTemplate("peakableRegion", RegionType);
+
+	//// - Constructors 
+		PeakableRegion(const word& type, const dictionary& dict);
+
+		add_vCtor(
+			peakableRegion,
+			PeakableRegion,
+			word
+			);
+
+		virtual uniquePtr<peakableRegion> clone()const override
+		{
+			return makeUnique<PeakableRegion<RegionType>>(*this);
+		}
+		
+		virtual peakableRegion* clonePtr()const override
+		{
+			return new PeakableRegion<RegionType>(*this);
+		}
+
+
+		virtual ~PeakableRegion() = default;
+
+	//// - Methods
+
+		virtual bool  isInside(const realx3& point)const override;
+
+		virtual realx3 peek()const override;
+
+
+	//// - IO operatoins 
+
+		virtual bool read(const dictionary& dict) override;
+
+		virtual bool write(dictionary& dict)const override;
+
+};
+
+} // pFlow
+
+#include "PeakableRegion.C"
+
+#endif
diff --git a/src/phasicFlow/structuredData/peakableRegion/boxRegion/boxRegion.C b/src/phasicFlow/structuredData/peakableRegion/boxRegion/boxRegion.C
new file mode 100644
index 00000000..375046f2
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/boxRegion/boxRegion.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+#include "boxRegion.H"
+
+
+pFlow::boxRegion::boxRegion
+(
+	const dictionary& dict
+)
+:
+	box_(dict),
+	random_()
+{
+
+}
+
+bool pFlow::boxRegion::isInside
+(
+	const realx3& p
+) const
+{
+	return box_.isInside(p);
+}
+
+pFlow::realx3 pFlow::boxRegion::peek()const
+{
+	return random_.randomNumber(box_.minPoint(), box_.maxPoint());
+}
+
+
+bool pFlow::boxRegion::read
+(
+	const dictionary& dict
+)
+{
+	return box_.read(dict);
+}
+
+bool pFlow::boxRegion::write
+(
+	dictionary& dict
+)const
+{
+	return box_.write(dict);
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/peakableRegion/boxRegion/boxRegion.H b/src/phasicFlow/structuredData/peakableRegion/boxRegion/boxRegion.H
new file mode 100644
index 00000000..ef04f36b
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/boxRegion/boxRegion.H
@@ -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 __boxRegion_H__
+#define __boxRegion_H__
+
+#include "box.H"
+#include "uniformRandomReal.H"
+
+namespace pFlow
+{
+
+class boxRegion
+{
+protected:
+	box 			  box_;
+
+	mutable uniformRandomReal random_;
+public:
+
+	// - type info
+	TypeNameNV("boxRegion");
+
+	boxRegion(const dictionary& dict);
+
+	~boxRegion() = default;
+
+	//// - methods 
+	bool isInside(const realx3& p) const;
+
+	realx3 peek()const;
+
+
+	//// IO operation
+	bool read(const dictionary& dict);
+
+	bool write(dictionary& dict)const;
+
+
+};
+
+}
+
+#endif
diff --git a/src/phasicFlow/structuredData/peakableRegion/peakableRegion/peakableRegion.C b/src/phasicFlow/structuredData/peakableRegion/peakableRegion/peakableRegion.C
new file mode 100644
index 00000000..7ab3bee6
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/peakableRegion/peakableRegion.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#include "peakableRegion.H"
+#include "dictionary.H"
+
+pFlow::peakableRegion::peakableRegion
+(
+	const word& type, const dictionary& dict
+)
+{
+	CONSUME_PARAM(type);
+	CONSUME_PARAM(dict);
+}
+
+
+pFlow::uniquePtr<pFlow::peakableRegion> pFlow::peakableRegion::create
+(
+	const word& type,
+	const dictionary& dict
+)
+{
+	word regionType = angleBracketsNames("peakableRegion", type);
+
+	if( wordvCtorSelector_.search(regionType) )
+	{
+		return wordvCtorSelector_[regionType] (type, dict);
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< regionType << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			wordvCtorSelector_
+		);
+		fatalExit;
+	}
+
+	return nullptr;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/peakableRegion/peakableRegion/peakableRegion.H b/src/phasicFlow/structuredData/peakableRegion/peakableRegion/peakableRegion.H
new file mode 100644
index 00000000..ae673906
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/peakableRegion/peakableRegion.H
@@ -0,0 +1,82 @@
+/*------------------------------- 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 __peakableRegion_H__
+#define __peakableRegion_H__
+
+#include "types.H"
+#include "virtualConstructor.H"
+
+
+namespace pFlow
+{
+
+
+class dictionary;
+
+class peakableRegion
+{
+protected:
+
+	
+public:
+
+	// type info
+	TypeName("peakableRegion");
+
+		peakableRegion(const word& type, const dictionary& dict);
+
+		create_vCtor(
+			peakableRegion,
+			word,
+			(const word& type, const dictionary& dict),
+			(type, dict)
+			);
+
+		virtual uniquePtr<peakableRegion> clone()const = 0;
+		
+		virtual peakableRegion* clonePtr()const = 0;
+
+		virtual ~peakableRegion() = default;
+
+	//// - Methods
+
+		virtual bool  isInside(const realx3& point)const = 0;
+
+		virtual realx3 peek()const = 0;
+
+
+	//// - IO operatoins 
+
+		virtual bool read(const dictionary& dict) = 0;
+
+		virtual bool write(dictionary& dict)const = 0;
+
+	// - static create 
+	static uniquePtr<peakableRegion> 
+		create(const word& type, const dictionary& dict);
+
+};
+
+} // pFlow
+
+
+#endif
diff --git a/src/phasicFlow/structuredData/peakableRegion/peakableRegionInstantiate.C b/src/phasicFlow/structuredData/peakableRegion/peakableRegionInstantiate.C
new file mode 100644
index 00000000..d2741163
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/peakableRegionInstantiate.C
@@ -0,0 +1,27 @@
+/*------------------------------- 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 "boxRegion.H"
+#include "sphereRegion.H"
+
+
+template class pFlow::PeakableRegion<pFlow::boxRegion>;
+
+template class pFlow::PeakableRegion<pFlow::sphereRegion>;
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/peakableRegion/peakableRegions.C b/src/phasicFlow/structuredData/peakableRegion/peakableRegions.C
new file mode 100644
index 00000000..4413a63b
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/peakableRegions.C
@@ -0,0 +1,27 @@
+/*------------------------------- 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 "peakableRegions.H"
+
+ 
+#ifdef BUILD_SHARED_LIBS
+	#include "peakableRegionInstantiate.C"
+#endif
diff --git a/src/phasicFlow/structuredData/peakableRegion/peakableRegions.H b/src/phasicFlow/structuredData/peakableRegion/peakableRegions.H
new file mode 100644
index 00000000..d96859e7
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/peakableRegions.H
@@ -0,0 +1,45 @@
+/*------------------------------- 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 __peakableRegions_H__
+#define __peakableRegions_H__
+
+#include "PeakableRegion.H"
+#include "boxRegion.H"
+#include "sphereRegion.H"
+
+namespace pFlow
+{
+
+
+typedef PeakableRegion<boxRegion> boxPeakableRegion;
+
+typedef PeakableRegion<sphereRegion> spherePeakableRegion;
+
+} // pFlow
+
+#ifndef BUILD_SHARED_LIBS
+	#include "peakableRegionInstantiate.C"
+#endif
+
+
+
+#endif
diff --git a/src/phasicFlow/structuredData/peakableRegion/sphereRegion/sphereRegion.C b/src/phasicFlow/structuredData/peakableRegion/sphereRegion/sphereRegion.C
new file mode 100644
index 00000000..edecfe18
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/sphereRegion/sphereRegion.C
@@ -0,0 +1,90 @@
+/*------------------------------- 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 "sphereRegion.H"
+#include "dictionary.H"
+
+pFlow::sphereRegion::sphereRegion
+(
+	const dictionary& dict
+)
+:
+	center_(dict.getVal<realx3>("center")),
+	radius_(dict.getVal<real>("radius")),
+	random_()
+{
+
+}
+
+bool pFlow::sphereRegion::isInside
+(
+	const realx3& p
+) const
+{
+	return length(center_-p) <= radius_;
+}
+
+pFlow::realx3 pFlow::sphereRegion::peek()const
+{
+	for(int32 i=0; i<100; ++i)
+	{
+		auto p = random_.randomNumber(center_ - realx3(radius_), center_ + realx3(radius_));
+		if(isInside(p)) return p;
+	}
+		
+	fatalErrorInFunction<<
+	"cannot peek a random point from sphereRegion. \n";
+	fatalExit;
+	return 0;
+
+}
+
+
+bool pFlow::sphereRegion::read
+(
+	const dictionary& dict
+)
+{
+	center_ = dict.getVal<realx3>("center");
+	radius_ = dict.getVal<real>("radius");
+	return true;
+}
+
+bool pFlow::sphereRegion::write
+(
+	dictionary& dict
+)const
+{
+	if(!dict.add("center", center_))
+	{
+		fatalErrorInFunction<<
+		"  error in writing center to dictionary "<<dict.globalName()<<endl;
+		return false;
+	}
+
+	if(!dict.add("radius", radius_))
+	{
+		fatalErrorInFunction<<
+		"  error in writing radius to dictionary "<<dict.globalName()<<endl;
+		return false;
+	}
+
+	return true;
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/peakableRegion/sphereRegion/sphereRegion.H b/src/phasicFlow/structuredData/peakableRegion/sphereRegion/sphereRegion.H
new file mode 100644
index 00000000..da3a35c8
--- /dev/null
+++ b/src/phasicFlow/structuredData/peakableRegion/sphereRegion/sphereRegion.H
@@ -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 __sphereRegion_H__
+#define __sphereRegion_H__
+
+#include "types.H"
+#include "uniformRandomReal.H"
+
+namespace pFlow
+{
+
+class dictionary;
+
+class sphereRegion
+{
+protected:
+	
+	realx3 			  center_;
+
+	real 			  radius_;
+
+	mutable uniformRandomReal random_;
+public:
+
+	// - type info
+	TypeNameNV("sphereRegion");
+
+	sphereRegion(const dictionary& dict);
+
+	~sphereRegion() = default;
+
+	//// - methods 
+	bool isInside(const realx3& p) const;
+
+	realx3 peek()const;
+
+
+	//// IO operation
+	bool read(const dictionary& dict);
+
+	bool write(dictionary& dict)const;
+
+
+};
+
+}
+
+#endif
diff --git a/src/phasicFlow/structuredData/pointStructure/pointStructure.C b/src/phasicFlow/structuredData/pointStructure/pointStructure.C
new file mode 100644
index 00000000..9126c384
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/pointStructure.C
@@ -0,0 +1,476 @@
+/*------------------------------- 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 "pointStructure.H"
+#include "pointStructureKernels.H"
+#include "error.H"
+#include "iOstream.H"
+#include "Time.H"
+
+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
+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 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();
+
+	// changes the active rage based on the new inserted points 
+	activeRange_ = { min(activeRange_.first, minInd ),
+					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, exclusionList) ) 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))
+	{
+		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;
+}*/
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/pointStructure/pointStructure.H b/src/phasicFlow/structuredData/pointStructure/pointStructure.H
new file mode 100644
index 00000000..9d53890c
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/pointStructure.H
@@ -0,0 +1,357 @@
+/*------------------------------- 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 __pointStructure_H__
+#define __pointStructure_H__
+
+
+
+#include "Vectors.H"
+#include "VectorSingles.H"
+#include "VectorDuals.H"
+#include "Fields.H"
+#include "eventSubscriber.H"
+#include "indexContainer.H"
+
+
+
+namespace pFlow
+{
+
+//forward
+class box;
+
+class pointStructure
+:
+	public eventSubscriber
+{
+public:
+	
+	enum PointFlag: int8
+	{
+		DELETED 	= -1,
+		ACTIVE 		= 1
+	};
+
+	
+	inline static const size_t maxSizeDefault_ = 10000;
+
+	class activePointsDevice
+	{
+	protected:
+		ViewType1D<int8> 	flag_;
+
+		bool allActive_;
+
+		range activeRange_;
+
+	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:
+
+	//// - data members 
+
+		// number of points / size of structure
+		size_t 			numPoints_ 		= 0;	
+
+		// maximum number of points
+		size_t 			maxPoints_ 		= maxSizeDefault_;
+
+		// 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_;
+	
+
+	//// - 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;
+
+public:
+
+	friend class dynamicPointStructure;
+	
+	// - type info
+	TypeName("pointStructure");
+	
+
+	//// - Constructors 
+
+		// - an empty pointStructure, good for reading from file 
+		pointStructure();
+
+		// - construct from components
+		pointStructure(const int8Vector& flgVec, const realx3Vector& posVec);
+
+		// - construct from point positions, assume all points are active
+		pointStructure(const realx3Vector& posVec);
+
+		// - 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;
+
+		// - no move assignment 
+		pointStructure& operator=(pointStructure&&) = delete;
+
+		// - destructor 
+		virtual ~pointStructure() = default;
+
+
+	//// - Methods
+		activePointsDevice activePointsMaskD()const
+		{
+			return activePointsDevice(
+				this->allActive(),
+				activeRange(),
+				pointFlag_.deviceVectorAll()
+				);
+		}
+
+		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;
+
+		// - size of data structure
+		FUNCTION_H
+		label size()const;
+		
+		// - maximum capacity of data structure 
+		FUNCTION_H
+		label capacity()const;
+		
+		// - number of active points 
+		FUNCTION_H
+		label numActive() const;
+				
+		// - if all points are active 
+		FUNCTION_H
+		bool allActive()const;
+
+		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();
+
+		///////////////////////////////////////////////////////////////////////////////////////////////////
+		
+		// - 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();
+		}
+
+
+		// - 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}
+		);
+
+	
+	//// - 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);
+		}
+
+};
+
+
+} // pFlow
+
+
+
+
+#endif //__pointStructure_H__
diff --git a/src/phasicFlow/structuredData/pointStructure/pointStructureKernels.H b/src/phasicFlow/structuredData/pointStructure/pointStructureKernels.H
new file mode 100644
index 00000000..6bf027bb
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/pointStructureKernels.H
@@ -0,0 +1,144 @@
+/*------------------------------- 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 __pointStructureKernels_H__
+#define __pointStructureKernels_H__
+
+#include "pointStructure.H"
+#include "box.H"
+
+namespace pFlow::pointStructureKernels
+{
+
+
+int32 markDeleteOutOfBox(
+	box 		domain,
+	int32 		start,
+	int32 		end,
+	int8 		deleteFlag,
+	deviceViewType1D<realx3> 	points,
+	deviceViewType1D<int8> 		flags,
+	pointStructure::activePointsDevice activePoint,
+	int32 & minRange,
+	int32 & maxRange
+	)
+{
+	
+	using rpMark = 
+		Kokkos::RangePolicy<Kokkos::IndexType<int32>>;
+
+	int32 numMarked = 0;
+	int32 minR = start-1, maxR = end+1;
+
+	if(start<end)
+	{
+		
+		Kokkos::parallel_reduce(
+			"pointStructureKernels::markDeleteOutOfBox",
+			rpMark(start,end),
+			LAMBDA_HD(int32 i, int32& minUpdate, int32& maxUpdate, int32& valToUpdate){
+				if(activePoint(i))
+				{
+					if( !domain.isInside(points[i]) )
+					{
+						flags[i] = deleteFlag;
+						valToUpdate++;
+					}
+					else
+					{
+						minUpdate = min(minUpdate,i);
+						maxUpdate = max(maxUpdate,i);
+					}
+				}
+			},
+			Kokkos::Min<int32>(minR), 
+			Kokkos::Max<int32>(maxR),
+			numMarked);
+
+	}
+	
+	// means either range was empty or all points have been deleted.
+	if(minR<start || maxR>end)
+	{
+		minRange = 0;
+		maxRange = 0;
+	}
+	else
+	{
+		minRange = minR;
+		maxRange = maxR+1; // add one to make it half
+	}
+	return numMarked;
+}
+
+int32 scanPointFlag(
+	int32 start,
+	int32 end,
+	int8 		activeFlag,
+	deviceViewType1D<int8> 		flags,
+	int32 & minRange,
+	int32 & maxRange
+	)
+{
+	
+	using rpScanFlag = 
+		Kokkos::RangePolicy<Kokkos::IndexType<int32>>;
+
+	int32 numActive = 0;
+
+	if(start < end )
+		Kokkos::parallel_reduce(
+			"pointStructureKernels::scanPointFlag",
+			rpScanFlag(start, end),
+			LAMBDA_HD(
+				int32 i, 
+				int32& minUpdate, 
+				int32& maxUpdate, 
+				int32& sumToUpdate){
+				if(flags[i] == activeFlag)
+				{
+					sumToUpdate++;
+					minUpdate = min(minUpdate,i);
+					maxUpdate = max(maxUpdate,i);
+				}
+			},
+			Kokkos::Min<int32>(minRange), 
+			Kokkos::Max<int32>(maxRange),
+			numActive);
+
+	if(numActive==0)
+	{
+		minRange = 0;
+		maxRange = 0;
+	}
+	else
+	{
+		// add one to maxRange to make it half-open
+		maxRange ++;
+	}
+
+	return numActive;
+}
+
+}
+
+#endif
+
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/boxAll/boxAll.C b/src/phasicFlow/structuredData/pointStructure/selectors/boxAll/boxAll.C
new file mode 100644
index 00000000..847ea3f5
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/boxAll/boxAll.C
@@ -0,0 +1,58 @@
+/*------------------------------- 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 "boxAll.H"
+
+
+void pFlow::boxAll::selectAllPointsInBox()
+{
+	// to reduct allocations
+	selectedPoints_.reserve
+	(
+		static_cast<size_t>(0.2*pStruct().size())
+	);
+
+	selectedPoints_.clear();
+	auto pPos = pStruct().pointPosition().hostVector();
+	
+	forAll(i , pPos)
+	{
+		if( box_.isInside( pPos[i] )) selectedPoints_.push_back(i);
+	}
+}
+
+pFlow::boxAll::boxAll
+(
+	const pointStructure& pStruct,
+	const dictionary& dict
+)
+:
+	pStructSelector
+	(
+		pStruct, dict
+	),
+	box_
+	(
+		dict.subDict("boxAllInfo")
+	)
+{
+	selectAllPointsInBox();
+}
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/boxAll/boxAll.H b/src/phasicFlow/structuredData/pointStructure/selectors/boxAll/boxAll.H
new file mode 100644
index 00000000..10e088e5
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/boxAll/boxAll.H
@@ -0,0 +1,81 @@
+/*------------------------------- 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 __boxAll_H__
+#define __boxAll_H__
+
+#include "pStructSelector.H"
+#include "pointStructure.H"
+#include "box.H"
+
+
+namespace pFlow
+{
+
+class dictionary;
+
+class boxAll
+:
+	public pStructSelector
+{
+protected:
+	
+	int32Vector selectedPoints_;
+
+	box 		box_;
+
+	void selectAllPointsInBox();
+	
+public:
+
+	// - type info
+	TypeName("boxAll");
+
+
+		boxAll(const pointStructure& pStruct, const dictionary& dict);
+
+		add_vCtor
+		(
+			pStructSelector,
+			boxAll,
+			dictionary
+		);
+
+		virtual ~boxAll() = default;
+
+	//// - Methods
+
+		virtual const int32Vector& selectedPoinsts()const override
+		{
+			return selectedPoints_;
+		}
+
+		virtual int32Vector& selectedPoinsts() override
+		{
+			return selectedPoints_;
+		}
+
+};
+
+} // pFlow
+
+
+#endif //__pStructSelector_H__
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.C b/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.C
new file mode 100644
index 00000000..f52f6b18
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.C
@@ -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.
+
+-----------------------------------------------------------------------------*/
+
+
+#include "pStructSelector.H"
+#include "pointStructure.H"
+#include "dictionary.H"
+
+pFlow::pStructSelector::pStructSelector
+(
+	const pointStructure& pStruct,
+	const dictionary& UNUSED(dict)
+)
+:
+	pStruct_(pStruct)
+{}
+
+const pFlow::pointStructure& pFlow::pStructSelector::pStruct()const
+{
+	return pStruct_;
+}
+
+
+pFlow::uniquePtr<pFlow::pStructSelector>
+	pFlow::pStructSelector::create(const pointStructure& pStruct, const dictionary& dict)
+{
+	word selectorMethod = dict.getVal<word>("selector");
+
+	if( dictionaryvCtorSelector_.search(selectorMethod) )
+	{
+		return dictionaryvCtorSelector_[selectorMethod] (pStruct, dict);
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< selectorMethod << " dose not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			dictionaryvCtorSelector_
+		);
+		fatalExit;
+	}
+	return nullptr;
+}
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.H b/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.H
new file mode 100644
index 00000000..b0871950
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/pStructSelector/pStructSelector.H
@@ -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 __pStructSelector_H__
+#define __pStructSelector_H__
+
+
+#include "Vectors.H"
+#include "virtualConstructor.H"
+
+namespace pFlow
+{
+
+
+class dictionary;
+class pointStructure;
+
+class pStructSelector
+{
+protected:
+	
+	const pointStructure& pStruct_;
+
+public:
+
+	// - type info
+	TypeName("pStructSelector");
+
+
+		pStructSelector(const pointStructure& pStruct, const dictionary& UNUSED(dict));
+
+		create_vCtor
+		(
+			pStructSelector,
+			dictionary,
+			(const pointStructure& pStruct, const dictionary& dict),
+			(pStruct, dict)
+		);
+
+		virtual ~pStructSelector() = default;
+
+	//// - Methods
+
+		const pointStructure& pStruct()const;
+
+
+		virtual const int32Vector& selectedPoinsts()const = 0;
+
+		virtual int32Vector& selectedPoinsts() = 0;
+
+
+	static
+	uniquePtr<pStructSelector> create(const pointStructure& pStruct, const dictionary& dict);
+
+};
+
+} // pFlow
+
+
+#endif //__pStructSelector_H__
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/rangeAll/rangeAll.C b/src/phasicFlow/structuredData/pointStructure/selectors/rangeAll/rangeAll.C
new file mode 100644
index 00000000..9946b428
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/rangeAll/rangeAll.C
@@ -0,0 +1,68 @@
+/*------------------------------- 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 "rangeAll.H"
+#include "dictionary.H"
+
+void pFlow::rangeAll::selectAllPointsInRange()
+{
+	// to reduct allocations
+	int32 maxNum = (end_ - begin_)/stride_+2;
+	
+	selectedPoints_.reserve	(maxNum);
+
+	selectedPoints_.clear();
+		
+	for(int32 i = begin_; i<end_; i+= stride_)
+	{
+		selectedPoints_.push_back(i);
+	}
+}
+
+pFlow::rangeAll::rangeAll
+(
+	const pointStructure& pStruct,
+	const dictionary& dict
+)
+:
+	pStructSelector
+	(
+		pStruct, dict
+	),
+	begin_
+	(
+		dict.subDict("rangeAllInfo").getVal<int32>("begin")
+	),
+	end_
+	(
+		dict.subDict("rangeAllInfo").getValOrSet("end", pStruct.size())
+	),
+	stride_
+	(
+		dict.subDict("rangeAllInfo").getValOrSet("stride", 1)
+	)
+{
+	begin_ 	= max(begin_,1);
+	end_ 	= min(end_, static_cast<int32>(pStruct.size()));
+	stride_ = max(stride_,1);
+
+	selectAllPointsInRange();
+}
diff --git a/src/phasicFlow/structuredData/pointStructure/selectors/rangeAll/rangeAll.H b/src/phasicFlow/structuredData/pointStructure/selectors/rangeAll/rangeAll.H
new file mode 100644
index 00000000..169802f5
--- /dev/null
+++ b/src/phasicFlow/structuredData/pointStructure/selectors/rangeAll/rangeAll.H
@@ -0,0 +1,87 @@
+/*------------------------------- 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 __rangeAll_H__
+#define __rangeAll_H__
+
+#include "pStructSelector.H"
+#include "pointStructure.H"
+
+
+namespace pFlow
+{
+
+class dictionary;
+
+class rangeAll
+:
+	public pStructSelector
+{
+protected:
+	
+	int32Vector selectedPoints_;
+
+	// begin index
+	int32 	begin_;
+
+	// end index
+	int32 	end_;
+
+	// stride
+	int32 	stride_;
+
+	void selectAllPointsInRange();
+	
+public:
+
+	// - type info
+	TypeName("rangeAll");
+
+
+		rangeAll(const pointStructure& pStruct, const dictionary& dict);
+
+		add_vCtor
+		(
+			pStructSelector,
+			rangeAll,
+			dictionary
+		);
+
+		virtual ~rangeAll() = default;
+
+	//// - Methods
+
+		virtual const int32Vector& selectedPoinsts()const override
+		{
+			return selectedPoints_;
+		}
+
+		virtual int32Vector& selectedPoinsts() override
+		{
+			return selectedPoints_;
+		}
+
+};
+
+} // pFlow
+
+
+#endif //__pStructSelector_H__
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/bitTransfer.H b/src/phasicFlow/structuredData/trisurfaceStructure/bitTransfer.H
new file mode 100644
index 00000000..f65d3202
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/bitTransfer.H
@@ -0,0 +1,71 @@
+/*------------------------------- 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 __bitTransfer_H__
+#define __bitTransfer_H__
+
+
+#include "types.H"
+#include "Vectors.H"
+
+namespace pFlow
+{
+
+// a simple functor that transfers 3 integers into a long variable and 
+// transfer the long to 3 integers
+
+class bitTransfer
+{
+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;
+
+public:
+
+	bitTransfer(){}
+
+	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
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.C b/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.C
new file mode 100644
index 00000000..e7b8a85f
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.C
@@ -0,0 +1,235 @@
+/*------------------------------- 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.H"
+
+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();
+	
+	// 
+	
+	
+	points_.append(newPoints);
+	
+	
+	// add new vertices to the existing one
+	auto vOldSize = vertices_.size();
+	auto vNewSize =  vOldSize + newVertices.size();
+	vertices_.resize(vNewSize);
+	auto verVec = vertices_.deviceVectorAll();
+	auto newVerVec = newVertices.deviceVectorAll();
+	auto maxIdx = maxIndex();
+
+	Kokkos::parallel_for(
+		"multiTriSurface::addTriSurface",
+		newVertices.size(),
+		LAMBDA_HD(int32 i){
+			verVec[vOldSize+i] = newVerVec[i]+(maxIdx+1);
+		}
+		);
+	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;
+
+	is >> lastPointIndex_;
+	if(!is.check(FUNCTION_NAME) ) return false;
+
+	is >> lastVertexIndex_;
+	if(!is.check(FUNCTION_NAME) ) return false;
+
+	is >> surfaceNames_;
+	if( !is.check(FUNCTION_NAME)) 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.H b/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.H
new file mode 100644
index 00000000..032a0ecb
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/multiTriSurface.H
@@ -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 __multiTriSurface_H__
+#define __multiTriSurface_H__
+
+
+#include "triSurface.H"
+#include "VectorDuals.H"
+
+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
+	TypeNameNV("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/stlFile.C b/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.C
new file mode 100644
index 00000000..b1527396
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.C
@@ -0,0 +1,357 @@
+/*------------------------------- 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 "stlFile.H"
+#include "iFstream.H"
+#include "oFstream.H"
+#include "error.H"
+
+namespace pFlow
+{
+inline bool badInput(iIstream& is, token& tok )
+{
+	return is.bad() || !tok.good();
+}
+
+inline bool checkWordToken(iIstream& is, token& tok, const word& check)
+{
+
+	if( badInput(is, tok) || is.eof() || !tok.isWord() || tok.wordToken() != check ) return false;
+	return true;
+
+}
+
+inline bool checkNumberToken(iIstream& is, token& tok, real& val)
+{
+	if(badInput(is, tok) || is.eof() || !tok.isNumber() )return false;
+	val = tok.number();
+	return true;
+}
+
+}
+
+bool pFlow::stlFile::readSolid
+(
+	iIstream& is,
+	realx3x3Vector & vertecies,
+	word & name
+)
+{
+
+	token tok;
+	is>> tok;
+	if(!checkWordToken(is, tok, "solid")) return false;
+
+	// check if there is a name associated with solid 
+	is >> tok;
+	if( badInput(is, tok) ) return false;
+	if(!tok.isWord()) return false;
+
+	if(tok.wordToken() != "facet" )
+	{
+		name = tok.wordToken();
+	}
+	else
+	{
+		name = "";
+		is.putBack(tok);
+	}	
+	vertecies.clear();
+	while(true )
+	{
+		is>>tok;
+		if( badInput(is,tok) || !tok.isWord() )return false;
+		word wTok = tok.wordToken();
+		if( wTok == "endsolid" ) return true; // end of solid 
+		if( wTok != "facet" ) return false;
+		
+		// read facet 
+		is.putBack(tok);
+		realx3x3 tri;
+		if( !readFacet(is, tri) ) return false;
+
+		vertecies.push_back(tri);
+		
+	}
+
+	return true;	
+}
+
+
+bool pFlow::stlFile::readFacet
+(
+	iIstream& is,
+	realx3x3& tri
+)
+{
+	token tok;
+
+	is>>tok;
+	if( !checkWordToken(is, tok, "facet") ) return false;
+	
+	is >> tok;
+	if( !checkWordToken(is, tok , "normal") ) return false;
+
+	real val;
+	for(uint32 i=0; i<3; i++ )
+	{
+		is>>tok;
+		if( !checkNumberToken(is, tok, val))return false;
+	}
+	
+	is>> tok;
+	if( !checkWordToken(is, tok, "outer")) return false;
+
+	is>> tok;
+	if(!checkWordToken(is, tok, "loop")) return false;
+
+	realx3 v;
+
+	for(uint32 i=0; i<3; i++)
+	{
+		is>>tok;
+		if(!checkWordToken(is, tok, "vertex")) return false;
+		is>>tok;
+		if(!checkNumberToken(is, tok, v.x()))return false;
+		is>>tok;
+		if(!checkNumberToken(is, tok, v.y()))return false;
+		is>>tok;
+		if(!checkNumberToken(is, tok, v.z()))return false;
+		if( i==0 ) tri.x() = v;
+		if( i==1 ) tri.y() = v;
+		if( i==2)  tri.z() = v;
+	}
+	is>> tok;
+	if(!checkWordToken(is, tok, "endloop")) return false;
+	is>> tok;
+	if(!checkWordToken(is, tok, "endfacet")) return false;
+
+	return true;		
+}
+
+bool pFlow::stlFile::writeFacet
+(
+	iOstream& os,
+	const realx3x3& tri
+)const
+{
+	realx3 n = cross( tri.y() - tri.x(), tri.z()-tri.x());
+	n.normalize();
+	os.incrIndent();
+	indent(os) << "facet" << spaceToken() 
+			   << "normal"<<spaceToken() 
+			   << n.x() << spaceToken() 
+			   << n.y() << spaceToken()
+			   << n.z() << endl;
+	os.incrIndent();
+	indent(os) << "outer loop"<<endl; 
+	os.incrIndent();
+	indent(os) << "vertex"<< spaceToken() 
+			   << tri.x().x() << spaceToken() 
+			   << tri.x().y() << spaceToken()
+			   << tri.x().z() << endl;
+
+	indent(os) << "vertex"<< spaceToken() 
+			   << tri.y().x() << spaceToken() 
+			   << tri.y().y() << spaceToken()
+			   << tri.y().z() << endl;
+
+	indent(os) << "vertex"<< spaceToken() 
+			   << tri.z().x() << spaceToken() 
+			   << tri.z().y() << spaceToken()
+			   << tri.z().z() << endl;
+	os.decrIndent();
+	indent(os) << "endloop"<<endl;
+
+	os.decrIndent();
+	indent(os)<< "endfacet"<<endl;
+
+	os.decrIndent();
+
+	return true;
+
+}
+
+
+bool pFlow::stlFile::writeSolid
+(
+	iOstream& os,
+	const realx3x3Vector& vertecies,
+	const word& name
+)const
+{
+	os<< "solid"<<spaceToken()<<name<<endl;
+	for(const auto& tri: vertecies)
+	{
+		writeFacet(os, tri);
+	}
+	os<< "endsolid"<<endl;
+
+	return true;
+}
+
+pFlow::stlFile::stlFile( fileSystem file )
+:
+	file_(file)
+{
+}
+
+pFlow::stlFile::stlFile
+(
+	fileSystem file,
+	const word& name,
+	const realx3x3Vector& vertecies
+)
+:
+	stlFile(file)
+{
+	addSolid(name, vertecies);
+}
+
+
+pFlow::stlFile::stlFile
+(
+	fileSystem file,
+	const word& name,
+	realx3x3Vector&& vertecies
+)
+:
+	stlFile(file)
+{
+	addSolid(name, vertecies);
+}
+
+void pFlow::stlFile::addSolid
+(
+	const word& name,
+	const realx3x3Vector& vertecies
+)
+{
+	solids_.push_backSafe(vertecies);
+	solidNames_.push_back(name);
+}
+
+
+void pFlow::stlFile::addSolid
+(
+	const word& name,
+	realx3x3Vector&& vertecies
+)
+{
+	solids_.push_backSafe(std::move(vertecies));
+	solidNames_.push_back(name);
+}
+
+
+
+bool pFlow::stlFile::read()
+{
+	solids_.clear();
+	solidNames_.clear();
+
+	// open file
+	iFstream is(file_);
+
+	token tok;
+	while (true)
+	{
+		
+		realx3x3Vector vertecies;
+		word name;
+		if(!readSolid(is, vertecies, name))
+		{
+			ioErrorInFile(is.name(), is.lineNumber());
+		 	return false;
+		}
+		
+		addSolid(name, std::move(vertecies));
+	
+		is >> tok;
+		if( is.eof() || !tok.good())return true;
+		is.putBack(tok);
+		
+	}
+
+	return true;
+}
+
+
+bool pFlow::stlFile::write()const
+{
+	oFstream os(file_);
+	os.precision(8);
+	for(label i=0; i<size(); i++)
+	{
+		writeSolid(os, solids_[i], solidNames_[i]);
+	}
+
+	return true;
+}
+
+void pFlow::stlFile::setFile
+(
+	fileSystem file
+) const
+{
+	file_ = file;
+}
+
+const pFlow::wordList& pFlow::stlFile::names()const
+{
+	return solidNames_;
+}
+
+size_t pFlow::stlFile::size()const
+{
+	return solids_.size();
+}
+
+const pFlow::realx3x3Vector& pFlow::stlFile::solid
+(
+	label i
+)const
+{
+	if(i >= size() )
+	{
+		fatalErrorInFunction<<
+		"requested out of range solid from stlFile "<< 
+		file_<<endl;
+		fatalExit;
+	}
+
+	return solids_[i];
+}
+
+const pFlow::word& pFlow::stlFile::name
+(
+	label i
+)const
+{
+	if(i >= size() )
+	{
+		fatalErrorInFunction<<
+		"requested out of range solid name from stlFile "<< 
+		file_<<endl;
+		fatalExit;
+	}
+
+	return solidNames_[i];
+}
\ No newline at end of file
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.H b/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.H
new file mode 100644
index 00000000..f162b688
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/stlFile.H
@@ -0,0 +1,119 @@
+/*------------------------------- 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 __stlFile_H__
+#define __stlFile_H__
+
+#include "types.H"
+#include "Vectors.H"
+#include "Lists.H"
+#include "fileSystem.H"
+
+
+
+namespace pFlow
+{
+
+
+class iIstream;
+
+class stlFile
+{
+protected:
+	
+	//// - data memebrs
+
+		// - list of verticies of all solids
+		ListPtr<realx3x3Vector> solids_;
+
+		// - list of names of all solids
+		wordList 			  solidNames_;
+
+		// - file name of stl file (used for reading and writing)
+		mutable fileSystem file_;
+
+	// - protected members
+
+		bool readSolid(iIstream& is, realx3x3Vector & vertecies, word & name);
+
+		bool readFacet(iIstream& is, realx3x3& tri);
+
+		bool writeSolid(iOstream& os, const realx3x3Vector& vertecies, const word& name)const;
+
+		bool writeFacet(iOstream& os, const realx3x3& tri)const;
+
+
+public:
+
+	//// - Constructors
+		// - construct with file name
+		//   an empty stlFile
+		stlFile( fileSystem file );
+
+		// - construct with file name and one solid (copy)
+		stlFile( fileSystem file, const word& name, const realx3x3Vector& vertecies);
+
+		// - construct with file name and one solid (copy)
+		stlFile( fileSystem file, const word& name, realx3x3Vector&& vertecies);
+
+		// - copy construct
+		stlFile(const stlFile&) = default;
+
+		// - move construct
+		stlFile(stlFile&&) = default;
+
+		~stlFile() = default;
+
+	//// - Methods
+
+		// - add a solid at the end of list, with copy operation 
+		void addSolid(const word& name, const realx3x3Vector& vertecies);
+
+		// - add a solid at the end of list, with move operation 
+		void addSolid(const word& name, realx3x3Vector&& vertecies);
+
+		// - clear current content and read from file
+		bool read();
+
+		// - write the current contnet to file
+		bool write()const;
+
+		// - set stl file path
+		void setFile(fileSystem file) const;
+
+		// - name of solids 
+		const wordList& names()const;
+
+		// - number of solids
+		size_t size()const;
+		
+		// - vertecies of ith solid
+		const realx3x3Vector& solid(label i)const;
+
+		// - name of ith solid 
+		const word& name(label i)const;
+
+};
+
+
+} // pFlow
+
+#endif //__stlFile_H__
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.C b/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.C
new file mode 100644
index 00000000..42b48898
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.C
@@ -0,0 +1,232 @@
+/*------------------------------- 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.H"
+#include "error.H"
+#include "iOstream.H"
+#include "triSurfaceKernels.H"
+
+
+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
+)
+{
+
+	is.fatalCheck(FUNCTION_NAME);
+
+	is >> points_;
+	is.fatalCheck(FUNCTION_NAME);
+
+	is >> vertices_;
+	is.fatalCheck(FUNCTION_NAME);
+
+	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.H b/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.H
new file mode 100644
index 00000000..ded33fca
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/triSurface.H
@@ -0,0 +1,288 @@
+/*------------------------------- 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_H__
+#define __triSurface_H__
+
+#include "eventSubscriber.H"
+#include "types.H"
+#include "Vectors.H"
+#include "VectorSingles.H"
+#include "Fields.H"
+
+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
+	TypeName("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/structuredData/trisurfaceStructure/triSurfaceKernels.H b/src/phasicFlow/structuredData/trisurfaceStructure/triSurfaceKernels.H
new file mode 100644
index 00000000..c26aaa9a
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/triSurfaceKernels.H
@@ -0,0 +1,56 @@
+/*------------------------------- 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 __triSurfaceKernels_H__
+#define __triSurfaceKernels_H__
+
+#include "Fields.H"
+#include "triangleFunctions.H"
+
+namespace pFlow::triSurfaceKernels
+{
+
+INLINE_FUNCTION_H
+bool calculateArea(const realx3Field_D& points, const int32x3Field_D& vertices, realField_D& area)
+{
+	auto numTri = vertices.size();
+	auto areaD = area.deviceVectorAll();
+	auto pointsD = points.deviceVectorAll();
+	auto verticesD = vertices.deviceVectorAll();
+
+	Kokkos::parallel_for(
+		"pFlow::triSurfaceKernels::calculateArea",
+		numTri,
+		LAMBDA_HD(int32 i){
+			auto v = verticesD[i];
+			areaD[i] = pFlow::triangleFunctions::triangleSurface(
+				pointsD[v.x()],
+				pointsD[v.y()],
+				pointsD[v.z()]);
+		});
+
+	return true;
+}
+
+
+}
+
+#endif 
diff --git a/src/phasicFlow/structuredData/trisurfaceStructure/triangleFunctions.H b/src/phasicFlow/structuredData/trisurfaceStructure/triangleFunctions.H
new file mode 100644
index 00000000..3bf58e42
--- /dev/null
+++ b/src/phasicFlow/structuredData/trisurfaceStructure/triangleFunctions.H
@@ -0,0 +1,39 @@
+/*------------------------------- 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_H__
+#define __triangleFunctions_H__
+
+#include "types.H"
+
+namespace pFlow::triangleFunctions
+{
+
+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));	
+}
+
+}
+
+#endif 
diff --git a/src/phasicFlow/types/basicTypes/bTypesFunctions.H b/src/phasicFlow/types/basicTypes/bTypesFunctions.H
index 748b53f0..cd329b27 100755
--- a/src/phasicFlow/types/basicTypes/bTypesFunctions.H
+++ b/src/phasicFlow/types/basicTypes/bTypesFunctions.H
@@ -21,7 +21,7 @@ Licence:
 #ifndef __bTypesFunctions_H__
 #define __bTypesFunctions_H__
 
-#include "dFlowMacros.H"
+#include "pFlowMacros.H"
 #include "numericConstants.H"
 #include "builtinTypes.H"
 #include "math.H"
diff --git a/src/phasicFlow/types/basicTypes/math.H b/src/phasicFlow/types/basicTypes/math.H
index 875e5a9c..95a3254c 100755
--- a/src/phasicFlow/types/basicTypes/math.H
+++ b/src/phasicFlow/types/basicTypes/math.H
@@ -36,7 +36,7 @@ Licence:
 // min, max
 //* * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace dFlow
+namespace pFlow
 {