From 6bc180275ef4cfacfe90e1082ac7a92980ae643e Mon Sep 17 00:00:00 2001
From: Hamidreza Norouzi <hamid.r.norouzi@gmail.com>
Date: Sat, 20 Jan 2024 06:05:05 -0800
Subject: [PATCH] pointFieild

---
 src/phasicFlow/CMakeLists.txt                 |  3 +-
 .../containers/pointField/boundaryField.cpp   | 10 +--
 .../containers/pointField/boundaryField.hpp   |  6 +-
 .../pointField/boundaryFieldList.hpp          |  6 +-
 .../pointField/createBoundaryFields.hpp       |  8 +-
 .../pointField/exitBoundaryField.cpp          |  4 +-
 .../pointField/exitBoundaryField.hpp          | 11 ++-
 .../containers/pointField/internalField.cpp   | 37 ++++----
 .../containers/pointField/internalField.hpp   | 15 ++--
 .../containers/pointField/pointField.cpp      | 87 ++++++++-----------
 .../containers/pointField/pointField.hpp      | 17 ++--
 .../containers/pointField/pointFields.cpp     | 24 ++---
 .../containers/pointField/pointFields.hpp     | 12 +--
 13 files changed, 117 insertions(+), 123 deletions(-)

diff --git a/src/phasicFlow/CMakeLists.txt b/src/phasicFlow/CMakeLists.txt
index 952be63b..805a55d0 100644
--- a/src/phasicFlow/CMakeLists.txt
+++ b/src/phasicFlow/CMakeLists.txt
@@ -38,7 +38,7 @@ containers/Vector/Vectors.cpp
 containers/VectorHD/VectorSingles.cpp
 containers/Field/Fields.cpp
 containers/List/anyList/anyList.cpp
-#containers/pointField/pointFields.cpp
+containers/pointField/pointFields.cpp
 
 #setFieldList/setFieldList.cpp
 #setFieldList/setFieldEntry.cpp
@@ -112,6 +112,7 @@ if(pFlow_Build_MPI)
     MPIParallelization/procCommunication.cpp
     MPIParallelization/boundaryProcessor.cpp
     MPIParallelization/scatteredMasterDistributeChar.cpp
+	MPIParallelization/processorBoundaryFields.cpp
 	)
 	
 	list(APPEND link_libs MPI::MPI_CXX ${ZOLTAN_LIBRARY} -lm )
diff --git a/src/phasicFlow/containers/pointField/boundaryField.cpp b/src/phasicFlow/containers/pointField/boundaryField.cpp
index 5ef89d88..230be98b 100644
--- a/src/phasicFlow/containers/pointField/boundaryField.cpp
+++ b/src/phasicFlow/containers/pointField/boundaryField.cpp
@@ -18,8 +18,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::boundaryField<VectorField, T, MemorySpace>::boundaryField
+template<class T, class MemorySpace>
+pFlow::boundaryField<T, MemorySpace>::boundaryField
 (
 	const boundaryBase& boundary, 
 	InternalFieldType& internal
@@ -31,9 +31,9 @@ pFlow::boundaryField<VectorField, T, MemorySpace>::boundaryField
 {}
 
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::uniquePtr<pFlow::boundaryField<VectorField, T, MemorySpace>>
-	pFlow::boundaryField<VectorField, T, MemorySpace>::create
+template<class T, class MemorySpace>
+pFlow::uniquePtr<pFlow::boundaryField<T, MemorySpace>>
+	pFlow::boundaryField<T, MemorySpace>::create
 (
 	const boundaryBase& boundary, 
 	InternalFieldType& internal
diff --git a/src/phasicFlow/containers/pointField/boundaryField.hpp b/src/phasicFlow/containers/pointField/boundaryField.hpp
index eed029c9..90786cbc 100644
--- a/src/phasicFlow/containers/pointField/boundaryField.hpp
+++ b/src/phasicFlow/containers/pointField/boundaryField.hpp
@@ -27,16 +27,16 @@ Licence:
 namespace pFlow
 {
 
-template< template<class, class> class VectorField, class T, class MemorySpace = void>
+template< class T, class MemorySpace = void>
 class boundaryField
 :
     public observer 
 {
 public:
 	
-	using BoundaryFieldType = boundaryField<VectorField, T, MemorySpace>;
+	using BoundaryFieldType = boundaryField<T, MemorySpace>;
 
-	using InternalFieldType = internalField<VectorField, T, MemorySpace>;
+	using InternalFieldType = internalField<T, MemorySpace>;
 
 	using memory_space 		= typename InternalFieldType::memory_space;
 
diff --git a/src/phasicFlow/containers/pointField/boundaryFieldList.hpp b/src/phasicFlow/containers/pointField/boundaryFieldList.hpp
index c457d8ed..8bdf9840 100644
--- a/src/phasicFlow/containers/pointField/boundaryFieldList.hpp
+++ b/src/phasicFlow/containers/pointField/boundaryFieldList.hpp
@@ -27,14 +27,14 @@ Licence:
 namespace pFlow
 {
 
-template< template<class, class> class VectorField, class T, class MemorySpace = void >
+template< class T, class MemorySpace = void >
 class boundaryFieldList
 :
-    ListPtr<boundaryField<VectorField, T, MemorySpace>>
+    public ListPtr< boundaryField<T, MemorySpace> >
 {
 public:
 
-    using BoundaryFieldType = boundaryField<VectorField, T, MemorySpace>;
+    using BoundaryFieldType = boundaryField<T, MemorySpace>;
 
     using InternalFieldType = typename BoundaryFieldType::InternalFieldType;
     
diff --git a/src/phasicFlow/containers/pointField/createBoundaryFields.hpp b/src/phasicFlow/containers/pointField/createBoundaryFields.hpp
index 5200c257..3403149d 100644
--- a/src/phasicFlow/containers/pointField/createBoundaryFields.hpp
+++ b/src/phasicFlow/containers/pointField/createBoundaryFields.hpp
@@ -24,12 +24,12 @@ Licence:
 #include "boundaryField.hpp"
 #include "exitBoundaryField.hpp"
 
-#define createBaseBoundary(VectorFieldType, DataType, MemorySpaceType)          \
-    template class pFlow::boundaryField<VectorFieldType, DataType, MemorySpaceType>;
+#define createBaseBoundary(DataType, MemorySpaceType)          \
+    template class pFlow::boundaryField<DataType, MemorySpaceType>;
     
 
-#define createBoundary(VectorFieldType, DataType, MemorySpaceType, BoundaryType)    \
-    template class pFlow::BoundaryType##BoundaryField<VectorFieldType, DataType, MemorySpaceType>;
+#define createBoundary(DataType, MemorySpaceType, BoundaryType)    \
+    template class pFlow::BoundaryType##BoundaryField<DataType, MemorySpaceType>;
 
 
 #endif //__createBoundaryFields_hpp__
diff --git a/src/phasicFlow/containers/pointField/exitBoundaryField.cpp b/src/phasicFlow/containers/pointField/exitBoundaryField.cpp
index 046a2bec..42f534a5 100644
--- a/src/phasicFlow/containers/pointField/exitBoundaryField.cpp
+++ b/src/phasicFlow/containers/pointField/exitBoundaryField.cpp
@@ -18,8 +18,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-    pFlow::exitBoundaryField<VectorField, T, MemorySpace>::exitBoundaryField
+template<class T, class MemorySpace>
+    pFlow::exitBoundaryField<T, MemorySpace>::exitBoundaryField
 (
 	const boundaryBase& boundary, 
 	InternalFieldType& internal
diff --git a/src/phasicFlow/containers/pointField/exitBoundaryField.hpp b/src/phasicFlow/containers/pointField/exitBoundaryField.hpp
index 104314c1..bcf168d7 100644
--- a/src/phasicFlow/containers/pointField/exitBoundaryField.hpp
+++ b/src/phasicFlow/containers/pointField/exitBoundaryField.hpp
@@ -25,16 +25,16 @@ Licence:
 namespace pFlow
 {
 
-template< template<class, class> class VectorField, class T, class MemorySpace = void>
+template< class T, class MemorySpace = void>
 class exitBoundaryField
 :
-    public boundaryField<VectorField, T, MemorySpace> 
+    public boundaryField<T, MemorySpace> 
 {
 public:
 	
-    using ExitBoundaryFieldType = exitBoundaryField<VectorField, T, MemorySpace>;
+    using ExitBoundaryFieldType = exitBoundaryField<T, MemorySpace>;
 
-	using BoundaryFieldType = boundaryField<VectorField, T, MemorySpace>;
+	using BoundaryFieldType = boundaryField<T, MemorySpace>;
 
 	using InternalFieldType = typename BoundaryFieldType::InternalFieldType;
 
@@ -51,8 +51,7 @@ public:
 	exitBoundaryField(
 		const boundaryBase& boundary, 
 		InternalFieldType& internal);
-	
-	
+		
 
 	add_vCtor
 	(
diff --git a/src/phasicFlow/containers/pointField/internalField.cpp b/src/phasicFlow/containers/pointField/internalField.cpp
index b3c23431..c568589e 100644
--- a/src/phasicFlow/containers/pointField/internalField.cpp
+++ b/src/phasicFlow/containers/pointField/internalField.cpp
@@ -18,8 +18,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::internalField<VectorField, T, MemorySpace>::internalField
+template<class T, class MemorySpace>
+pFlow::internalField<T, MemorySpace>::internalField
 (
 	const word& name, 
 	const internalPoints& internal
@@ -41,8 +41,8 @@ pFlow::internalField<VectorField, T, MemorySpace>::internalField
 	internalPoints_(internal)
 {}
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::internalField<VectorField, T, MemorySpace>::internalField
+template<class T, class MemorySpace>
+pFlow::internalField<T, MemorySpace>::internalField
 (
 	const word &name, 
 	const internalPoints &internal, 
@@ -68,14 +68,22 @@ pFlow::internalField<VectorField, T, MemorySpace>::internalField
 } 
 
 
-template <template <class, class> class VectorField, class T, class MemorySpace>
-pFlow::hostViewType1D<T>
-pFlow::internalField<VectorField, T, MemorySpace>::activeValuesHost() const
+template <class T, class MemorySpace>
+typename pFlow::internalField<T, MemorySpace>::FieldTypeHost 
+	pFlow::internalField<T, MemorySpace>::activeValuesHost() const
 {
 	auto maskH = internalPoints_.activePointsMaskHost();
     auto fieldH = field_.hostVector();
 
-	hostViewType1D<T> aField("Active field", maskH.numActive());
+	FieldTypeHost aField
+	(
+		field_.name(), 
+		field_.fieldKey(),
+		maskH.numActive(),
+		maskH.numActive(),
+		RESERVE()
+	);
+
     auto aRange = maskH.activeRange();
 
 	uint32 n = 0;
@@ -87,12 +95,11 @@ pFlow::internalField<VectorField, T, MemorySpace>::activeValuesHost() const
             n++;
         }
     }
-
     return aField;
 }
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-bool pFlow::internalField<VectorField, T, MemorySpace>::write
+template<class T, class MemorySpace>
+bool pFlow::internalField<T, MemorySpace>::write
 (
 	iOstream& os, 
 	const IOPattern& iop
@@ -104,9 +111,7 @@ bool pFlow::internalField<VectorField, T, MemorySpace>::write
 	}
 	else
 	{
-		auto aValues = activeValuesHost();
-		auto spanValues = makeSpan(aValues);
-		return writeSpan(os, spanValues, iop);
+		auto aField = activeValuesHost();
+		return aField.write(os, iop);
 	}
-}
-
+}
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/internalField.hpp b/src/phasicFlow/containers/pointField/internalField.hpp
index a1ff6b4c..9783fdbc 100644
--- a/src/phasicFlow/containers/pointField/internalField.hpp
+++ b/src/phasicFlow/containers/pointField/internalField.hpp
@@ -23,20 +23,25 @@ Licence:
 #include "internalPoints.hpp"
 #include "Field.hpp"
 #include "observer.hpp"
+#include "dataIO.hpp"
 
 
 namespace pFlow
 {
 
-template<template<class, class> class VectorField, class T, class MemorySpace=void>
+template<class T, class MemorySpace=void>
 class internalField
 :
     public observer
 {
 
 public:
+	
+	using InternalFieldType = internalField<T, MemorySpace>;
 
-	using FieldType         = Field<VectorField, T, MemorySpace>;
+	using FieldType         = Field<T, MemorySpace>;
+
+	using FieldTypeHost 	= Field<T, HostSpace>;
   	
 	using VectorType  		= typename FieldType::VectorType;
 
@@ -81,7 +86,7 @@ public:
 		return field_.hostVector();
 	}
 
-	hostViewType1D<T> activeValuesHost()const;
+	FieldTypeHost activeValuesHost()const;
 
 	inline
 	auto size()const
@@ -131,12 +136,12 @@ public:
 
 };
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
+template<class T, class MemorySpace>
 inline
 iOstream& operator<<
 (
 	iOstream& os, 
-	const internalField<VectorField, T, MemorySpace>& ifeild
+	const internalField<T,  MemorySpace>& ifeild
 )
 {
 	if( !ifeild.write(os, IOPattern::AllProcessorsDifferent) )
diff --git a/src/phasicFlow/containers/pointField/pointField.cpp b/src/phasicFlow/containers/pointField/pointField.cpp
index ec84246f..28bc8c73 100644
--- a/src/phasicFlow/containers/pointField/pointField.cpp
+++ b/src/phasicFlow/containers/pointField/pointField.cpp
@@ -1,3 +1,4 @@
+#include "pointField.hpp"
 /*------------------------------- phasicFlow ---------------------------------
       O        C enter of
      O O       E ngineering and
@@ -18,8 +19,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::pointField<VectorField, T, MemorySpace>::pointField
+template<class T, class MemorySpace>
+pFlow::pointField<T, MemorySpace>::pointField
 (
     const objectFile& objf, 
 	pointStructure& pStruct, 
@@ -44,8 +45,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
 	
 }
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-pFlow::pointField<VectorField, T, MemorySpace>::pointField
+template<class T, class MemorySpace>
+pFlow::pointField<T, MemorySpace>::pointField
 (
 	const objectFile &objf, 
 	pointStructure &pStruct, 
@@ -81,8 +82,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
 
 
 
- template<template<class, class> class VectorField, class T, class MemorySpace>
- pFlow::pointField<VectorField, T, MemorySpace>::pointField
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField
  (
      const pointStructure& pStruct,
      const T& defVal,
@@ -98,8 +99,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
      this->fill(defVal);
  }
 
- template<template<class, class> class VectorField, class T, class MemorySpace>
- pFlow::pointField<VectorField, T, MemorySpace>::pointField
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField
  (
      const pointStructure& pStruct,
      const T& val,
@@ -115,8 +116,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
      this->fill(val);
  }
 
- template<template<class, class> class VectorField, class T, class MemorySpace>
- pFlow::pointField<VectorField, T, MemorySpace>::pointField
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField
  (
      const pointField& src,
      bool subscribe
@@ -128,15 +129,15 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
      defaultValue_(src.defaultValue_)
  {}
 
- template<template<class, class> class VectorField, class T, class MemorySpace>
- pFlow::pointField<VectorField, T, MemorySpace>::pointField(const pointField& src)
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>::pointField(const pointField& src)
  :
-     pointField<VectorField, T, MemorySpace>(src, src.subscribed())
+     pointField<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 =
+ template<class T, class MemorySpace>
+ pFlow::pointField<T, MemorySpace>& pFlow::pointField<T, MemorySpace>::operator =
  (
      const pointField& rhs
  )
@@ -148,8 +149,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
  }
 
 
- template<template<class, class> class VectorField, class T, class MemorySpace>
- bool pFlow::pointField<VectorField, T, MemorySpace>::update(const eventMessage& msg)
+ template<class T, class MemorySpace>
+ bool pFlow::pointField<T, MemorySpace>::update(const eventMessage& msg)
  {
 
      if( msg.isDeleted() )
@@ -173,14 +174,19 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
      return true;
  }*/
 
-template <template <class, class> class VectorField, class T, class MemorySpace>
-bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField(
+template <class T, class MemorySpace>
+bool pFlow::pointField<T, MemorySpace>::readPointField
+(
     iIstream &is,
-    const IOPattern &iop)
+    const IOPattern &iop
+)
 {
-	Field<Vector, T , vecAllocator<T>> 
-        fRead("file_read"+InternalFieldType::name(), InternalFieldType::fieldKey());   
-
+	typename InternalFieldType::FieldTypeHost fRead
+    (
+        InternalFieldType::name(),
+        InternalFieldType::fieldKey()
+    );
+    
 	if( !fRead.read(is, iop))
 	{
 		fatalErrorInFunction<<
@@ -190,10 +196,10 @@ bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField(
 
 	auto thisN = pStruct_.simDomain().initialNumberInThis();
 
-	Field<Vector, T , vecAllocator<T>> internal
+	typename InternalFieldType::FieldTypeHost internal
     (
-        "internalField"+InternalFieldType::name(), 
-        InternalFieldType::fieldKey(), 
+        InternalFieldType::name(),
+        InternalFieldType::fieldKey(),
         thisN, 
         thisN, 
         RESERVE()
@@ -215,35 +221,12 @@ bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField(
 	return true;
 }
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-bool pFlow::pointField<VectorField, T, MemorySpace>::writePointField
+template<class T, class MemorySpace>
+bool pFlow::pointField<T, MemorySpace>::writePointField
 (
 	iOstream& os,
 	const IOPattern& iop
 )const
 {
-	
-    hostViewType1D<T> valuesH;
-
-    if(this->isAllActive())
-    {
-        valuesH = this->fieldHost();
-    }
-    else
-    {
-        valuesH = this->activeValuesHost();
-    }
-
-    auto data = span<T>(valuesH.data(), valuesH.size());
-    
-    if( !writeSpan(os, data, iop) )
-    {
-        fatalErrorInFunction<<
-        "Error in writing pointStructure in stream "<<
-        os.name()<<endl;
-        return false;
-    }
-
-    return true;
-	
+    return InternalFieldType::write(os, iop);
 }
\ No newline at end of file
diff --git a/src/phasicFlow/containers/pointField/pointField.hpp b/src/phasicFlow/containers/pointField/pointField.hpp
index 03633c61..5ebb015d 100644
--- a/src/phasicFlow/containers/pointField/pointField.hpp
+++ b/src/phasicFlow/containers/pointField/pointField.hpp
@@ -26,25 +26,26 @@ Licence:
 #include "internalField.hpp"
 #include "boundaryFieldList.hpp"
 
+
 namespace pFlow
 {
 
-template<template<class, class> class VectorField, class T, class MemorySpace=void>
+template<class T, class MemorySpace=void>
 class pointField
 :
 	public IOobject,
-	public internalField<VectorField, T, MemorySpace>
+	public internalField<T, MemorySpace>
 {
 public:
 	
-	using PointFieldType 	= pointField<VectorField, T, MemorySpace>;
+	using PointFieldType 	= pointField<T, MemorySpace>;
 
-	using InternalFieldType = internalField<VectorField, T, MemorySpace>;
+	using InternalFieldType = internalField<T, MemorySpace>;
+
+	using boundaryFieldListType = boundaryFieldList<T, MemorySpace>;
 
 	using FieldType 		= typename InternalFieldType::FieldType;
 
-    using boundaryFieldListType = boundaryFieldList<VectorField, T, MemorySpace>;
-
 	using VectorType  		= typename InternalFieldType::VectorType;
 
 	using memory_space 		= typename InternalFieldType::memory_space;
@@ -187,8 +188,8 @@ iIstream& operator >> (iIstream & is, pointField<VectorField, T, MemorySpace> &
 	return is;
 }*/
 
-template<template<class, class> class VectorField, class T, class MemorySpace>
-iOstream& operator << (iOstream& os, const pointField<VectorField, T, MemorySpace>& pF )
+template<class T, class MemorySpace>
+iOstream& operator << (iOstream& os, const pointField<T, MemorySpace>& pF )
 {
 	if(! pF.write(os, IOPattern::AllProcessorsDifferent) )
 	{
diff --git a/src/phasicFlow/containers/pointField/pointFields.cpp b/src/phasicFlow/containers/pointField/pointFields.cpp
index 20c65cf0..cb1c8584 100644
--- a/src/phasicFlow/containers/pointField/pointFields.cpp
+++ b/src/phasicFlow/containers/pointField/pointFields.cpp
@@ -23,22 +23,22 @@ Licence:
 #include "createBoundaryFields.hpp"
 
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>; 
-createBaseBoundary(pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace);
-createBoundary(pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace, exit);
+template class pFlow::pointField<pFlow::int8, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::int8, pFlow::HostSpace);
+createBoundary(pFlow::int8, pFlow::HostSpace, exit);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8>; 
-createBaseBoundary(pFlow::VectorSingle, pFlow::int8, void);
-createBoundary(pFlow::VectorSingle, pFlow::int8, void, exit);
+template class pFlow::pointField<pFlow::int8>; 
+createBaseBoundary(pFlow::int8, void);
+createBoundary(pFlow::int8, void, exit);
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>; 
-createBaseBoundary(pFlow::VectorSingle, pFlow::real, pFlow::HostSpace);
-createBoundary(pFlow::VectorSingle, pFlow::real, pFlow::HostSpace, exit);
+template class pFlow::pointField<pFlow::real, pFlow::HostSpace>; 
+createBaseBoundary(pFlow::real, pFlow::HostSpace);
+createBoundary(pFlow::real, pFlow::HostSpace, exit);
 
 
-template class pFlow::pointField<pFlow::VectorSingle, pFlow::real>; 
-createBaseBoundary(pFlow::VectorSingle, pFlow::real, void);
-createBoundary(pFlow::VectorSingle, pFlow::real, void, exit);
+template class pFlow::pointField<pFlow::real>; 
+createBaseBoundary(pFlow::real, void);
+createBoundary(pFlow::real, void, exit);
 
 
 /*template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>; 
diff --git a/src/phasicFlow/containers/pointField/pointFields.hpp b/src/phasicFlow/containers/pointField/pointFields.hpp
index 9e33cbcf..2dc5242a 100644
--- a/src/phasicFlow/containers/pointField/pointFields.hpp
+++ b/src/phasicFlow/containers/pointField/pointFields.hpp
@@ -30,19 +30,19 @@ namespace pFlow
 {
 
 template<typename T>
-  using pointField_H = pointField<VectorSingle, T, HostSpace>;
+  using pointField_H = pointField<T, HostSpace>;
 
 template<typename T>
-  using pointField_D = pointField<VectorSingle, T>;
+  using pointField_D = pointField<T>;
 
 
-using int8PointField_D 		= pointField<VectorSingle, int8>;
+using int8PointField_D 		= pointField<int8>;
 
-using int8PointField_H 		= pointField<VectorSingle, int8, HostSpace>;
+using int8PointField_H 		= pointField<int8, HostSpace>;
 
-using realPointField_D 		= pointField<VectorSingle, real>;
+using realPointField_D 		= pointField<real>;
 
-using realPointField_H 		= pointField<VectorSingle, real, HostSpace>;
+using realPointField_H 		= pointField<real, HostSpace>;
 
 //using int32PointField_D 	= pointField<VectorSingle, int32>;