modify for coupling-cpp and hpp

utilities/postprocessPhasicFlow/CMakeLists.txt

@@ -1,11 +1,11 @@
 
 set(source_files 
-postprocessPhasicFlow.C 
-postprocess.C
-processField.C
-ProcessFields.C
-includeMask.C
-IncludeMasks.C
+postprocessPhasicFlow.cpp 
+postprocess.cpp
+processField.cpp
+ProcessFields.cpp
+includeMask.cpp
+IncludeMasks.cpp
 
 )
 set(link_lib phasicFlow Interaction Kokkos::kokkos Utilities)

utilities/postprocessPhasicFlow/IncludeMask.hpp

@@ -18,11 +18,11 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __IncludeMask_H__
-#define __IncludeMask_H__
+#ifndef __IncludeMask_hpp__
+#define __IncludeMask_hpp__
 
 
-#include "includeMask.H"
+#include "includeMask.hpp"
 
 namespace pFlow
 {
@@ -31,7 +31,7 @@ namespace pFlow
 template<typename T>
 struct greaterThanOp
 {
-	TypeNameNV("greaterThan");
+	TypeInfoNV("greaterThan");
 
  	inline
  	bool operator()(const T &compVal, const T &val) const {
@@ -41,7 +41,7 @@ struct greaterThanOp
 template<typename T>
 struct greaterThanEqOp
 {
-	TypeNameNV("greaterThanEq");
+	TypeInfoNV("greaterThanEq");
 
  	inline
  	bool operator()(const T &compVal, const T &val) const {
@@ -51,7 +51,7 @@ struct greaterThanEqOp
 template<typename T>
 struct lessThanOp
 {
-	TypeNameNV("lessThan");
+	TypeInfoNV("lessThan");
 
 	inline
 	bool operator()(const T &compVal, const T &val) const {
@@ -61,7 +61,7 @@ struct lessThanOp
 template<typename T>
 struct lessThanEqOp
 {
-	TypeNameNV("lessThanEq");
+	TypeInfoNV("lessThanEq");
 
 	inline
 	bool operator()(const T &compVal, const T &val) const {
@@ -71,7 +71,7 @@ struct lessThanEqOp
 template<typename T>
 struct equalOp
 {
-	TypeNameNV("equal");
+	TypeInfoNV("equal");
 
 	inline
 	bool operator()(const T &compVal, const T &val) const {
@@ -82,7 +82,7 @@ struct equalOp
 template<typename T>
 struct betweenOp
 {
-	TypeNameNV("between");
+	TypeInfoNV("between");
 
 	inline
 	bool operator()(const T &compVal1, const T &compVal2 ,const T &val) const {
@@ -93,7 +93,7 @@ struct betweenOp
 template<typename T>
 struct betweenEqOp
 {
-	TypeNameNV("betweenEq");
+	TypeInfoNV("betweenEq");
 
 	inline
 	bool operator()(const T &compVal1, const T &compVal2 ,const T &val) const {
@@ -103,7 +103,7 @@ struct betweenEqOp
 template<typename T>
 struct allOp
 {
-	TypeNameNV("all");
+	TypeInfoNV("all");
 
 	inline
 	bool operator()() const {return true; }
@@ -123,7 +123,7 @@ protected:
 	opertorType 	operator_{};
 public:
 
-	TypeNameNV(Operator<T>::TYPENAME());
+	TypeInfoNV(Operator<T>::TYPENAME());
 
 	compareOne(const dictionary& dict)
 	:
@@ -147,7 +147,7 @@ protected:
 	opertorType 	operator_{};
 public:
 	
-	TypeNameNV(opertorType::TYPENAME());
+	TypeInfoNV(opertorType::TYPENAME());
 
 	compareTwo(const dictionary& dict)
 	:
@@ -168,7 +168,7 @@ protected:
 	Operator 	operator_{};
 public:
 
-	TypeNameNV(Operator::TYPENAME());
+	TypeInfoNV(Operator::TYPENAME());
 	compareZero(const dictionary& dict);
 
 	bool operator()(const T& value) const
@@ -190,7 +190,7 @@ protected:
 
 public:
 
-	TypeNameTemplate2("IncludeMask", T, Operator);
+	TypeInfoTemplate2("IncludeMask", T, Operator);
 
 	IncludeMask(
 		const dictionary& dict,
@@ -221,7 +221,7 @@ class IncludeMask<T,allOp<T>>
 	public includeMask
 {
 public:
-	TypeNameTemplate2("IncludeMask", T, allOp<int8>);
+	TypeInfoTemplate2("IncludeMask", T, allOp<int8>);
 
 	IncludeMask(
 		const dictionary& dict,
@@ -245,6 +245,6 @@ public:
 
 } // pFlow
 
-#endif //__IncludeMask_H__
+#endif //__IncludeMask_hpp__
 
 

utilities/postprocessPhasicFlow/IncludeMasks.cpp

@@ -18,7 +18,7 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "IncludeMask.H"
+#include "IncludeMask.hpp"
 
 // real
 template class pFlow::IncludeMask<pFlow::real, pFlow::compareOne<pFlow::real, pFlow::lessThanOp> >;

utilities/postprocessPhasicFlow/ProcessField.hpp

@@ -18,15 +18,15 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __ProcessField_H__ 
-#define __ProcessField_H__
+#ifndef __ProcessField_hpp__ 
+#define __ProcessField_hpp__
 
 
-#include "processField.H"
-#include "rectMeshFields.H"
-#include "twoPartEntry.H"
-#include "fieldOperations.H"
-#include "rectMeshFieldToVTK.H"
+#include "processField.hpp"
+#include "rectMeshFields.hpp"
+#include "twoPartEntry.hpp"
+#include "fieldOperations.hpp"
+#include "rectMeshFieldToVTK.hpp"
 
 namespace pFlow
 {
@@ -47,7 +47,7 @@ protected:
 
 public:
 
-	TypeNameTemplate("ProcessField", T);
+	TypeInfoTemplate("ProcessField", T);
 
 
 	ProcessField(
@@ -161,4 +161,4 @@ public:
 
 
 
-#endif //__ProcessField_H__
+#endif //__ProcessField_hpp__

utilities/postprocessPhasicFlow/ProcessFields.cpp

@@ -18,7 +18,7 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "ProcessField.H"
+#include "ProcessField.hpp"
 
 
 template class pFlow::ProcessField<pFlow::int8>;

utilities/postprocessPhasicFlow/fieldOperations.hpp

@@ -18,13 +18,13 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __fieldOperations_H__ 
-#define __fieldOperations_H__
+#ifndef __fieldOperations_hpp__ 
+#define __fieldOperations_hpp__
 
-#include "rectMeshFields.H"
-#include "pointFields.H"
-#include "pointRectCell.H"
-#include "includeMask.H"
+#include "rectMeshFields.hpp"
+#include "pointFields.hpp"
+#include "pointRectCell.hpp"
+#include "includeMask.hpp"
 
 namespace pFlow
 {
@@ -105,5 +105,5 @@ rectMeshField_H<T> sumMaksOp( const pointField_H<T> field, const pointRectCell&
 }
 
 
-#endif //__fieldOperations_H__
+#endif //__fieldOperations_hpp__
 

utilities/postprocessPhasicFlow/includeMask.cpp

@@ -19,7 +19,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "includeMask.H"
+#include "includeMask.hpp"
 
 pFlow::includeMask::includeMask(
 	const dictionary& dict,

utilities/postprocessPhasicFlow/includeMask.hpp

@@ -18,12 +18,12 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __includeMask_H__
-#define __includeMask_H__
+#ifndef __includeMask_hpp__
+#define __includeMask_hpp__
 
-#include "virtualConstructor.H"
-#include "readFromTimeFolder.H"
-#include "dictionary.H"
+#include "virtualConstructor.hpp"
+#include "readFromTimeFolder.hpp"
+#include "dictionary.hpp"
 
 
 namespace pFlow
@@ -46,7 +46,7 @@ protected:
 
 public:
 
-	TypeName("includeMask");
+	TypeInfo("includeMask");
 
 	includeMask(const dictionary& dict, const word& opType, readFromTimeFolder& timeFolder);
 
@@ -102,6 +102,6 @@ public:
 
 } // pFlow
 
-#endif //__IncludeMask_H__
+#endif //__IncludeMask_hpp__
 
 

utilities/postprocessPhasicFlow/pointRectCell.hpp

@@ -18,12 +18,12 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __pointRectCell_H__
-#define __pointRectCell_H__
+#ifndef __pointRectCell_hpp__
+#define __pointRectCell_hpp__
 
-#include "mapperNBS.H"
-#include "rectMeshFields.H"
-#include "pointStructure.H"
+#include "mapperNBS.hpp"
+#include "rectMeshFields.hpp"
+#include "pointStructure.hpp"
 
 namespace pFlow
 {
@@ -146,4 +146,4 @@ public:
 
 }
 
-#endif // __pointRectCell_H__ 
+#endif // __pointRectCell_hpp__ 

utilities/postprocessPhasicFlow/postprocess.cpp

@@ -18,11 +18,11 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "postprocess.H" 
-#include "timeFolder.H"
-#include "pointStructure.H"
-#include "vocabs.H"
-#include "vtkFile.H"
+#include "postprocess.hpp" 
+#include "timeFolder.hpp"
+#include "pointStructure.hpp"
+#include "vocabs.hpp"
+#include "vtkFile.hpp"
 
 pFlow::postprocess::postprocess(systemControl& control)
 :

utilities/postprocessPhasicFlow/postprocess.hpp

@@ -18,14 +18,14 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __postprocess_H__ 
-#define __postprocess_H__
+#ifndef __postprocess_hpp__ 
+#define __postprocess_hpp__
 
 
-#include "MapPtr.H"
-#include "systemControl.H"
-#include "pointRectCell.H"
-#include "processField.H"
+#include "MapPtr.hpp"
+#include "systemControl.hpp"
+#include "pointRectCell.hpp"
+#include "processField.hpp"
 	
 
 namespace pFlow
@@ -91,4 +91,4 @@ public:
 
 
 
-#endif //__postprocess_H__
+#endif //__postprocess_hpp__

utilities/postprocessPhasicFlow/postprocessPhasicFlow.cpp

@@ -18,14 +18,14 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "KokkosUtilities.H"
-#include "systemControl.H"
-#include "timeFolder.H"
-#include "commandLine.H"
-#include "ranges.H"
-#include "readControlDict.H"
+#include "KokkosUtilities.hpp"
+#include "systemControl.hpp"
+#include "timeFolder.hpp"
+#include "commandLine.hpp"
+#include "ranges.hpp"
+#include "readControlDict.hpp"
 
-#include "postprocess.H"
+#include "postprocess.hpp"
 
 using pFlow::word;
 using pFlow::wordVector;
@@ -71,7 +71,7 @@ int main(int argc, char** argv )
 
 	if(!cmds.parse(argc, argv)) return 0;
 
-	#include "initialize_Control.H"
+	#include "initialize_Control.hpp"
 
 	
 	pFlow::postprocess post(Control);
@@ -111,7 +111,7 @@ int main(int argc, char** argv )
 
 	}while (folders++);
 
-	#include "finalize.H"
+	#include "finalize.hpp"
 
 	return true;
 }

utilities/postprocessPhasicFlow/processField.cpp

@@ -18,10 +18,10 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "processField.H"
-#include "pointRectCell.H"
-#include "repository.H"
-#include "twoPartEntry.H"
+#include "processField.hpp"
+#include "pointRectCell.hpp"
+#include "repository.hpp"
+#include "twoPartEntry.hpp"
 
 
 pFlow::processField::processField(

utilities/postprocessPhasicFlow/processField.hpp

@@ -18,15 +18,15 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __processField_H__
-#define __processField_H__
+#ifndef __processField_hpp__
+#define __processField_hpp__
 
 
-#include "virtualConstructor.H"
-#include "dictionary.H"
-#include "readFromTimeFolder.H"
-#include "includeMask.H"
-#include "pointRectCell.H"
+#include "virtualConstructor.hpp"
+#include "dictionary.hpp"
+#include "readFromTimeFolder.hpp"
+#include "includeMask.hpp"
+#include "pointRectCell.hpp"
 
 namespace pFlow
 {
@@ -66,7 +66,7 @@ protected:
 
 public:
 
-	TypeName("processField");
+	TypeInfo("processField");
 
 	processField(const dictionary& dict, pointRectCell& pToCell, repository& rep);
 
@@ -166,4 +166,4 @@ public:
 }
 
 
-#endif //__processField_H__
+#endif //__processField_hpp__

utilities/postprocessPhasicFlow/rectMeshField.hpp

@@ -18,11 +18,11 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __rectMeshField_H__
-#define __rectMeshField_H__
+#ifndef __rectMeshField_hpp__
+#define __rectMeshField_hpp__
 
-#include "rectangleMesh.H"
-#include "baseAlgorithms.H"
+#include "rectangleMesh.hpp"
+#include "baseAlgorithms.hpp"
 
 namespace pFlow
 {
@@ -54,7 +54,7 @@ protected:
 public:
 
 
-	TypeNameTemplateNV2("rectMeshField", T, memoerySpaceName());
+	TypeInfoTemplateNV2("rectMeshField", T, memoerySpaceName());
 	
 	rectMeshField(const rectangleMesh& mesh, const word& name ,const T& defVal)
 	:
@@ -170,4 +170,4 @@ public:
 }
 
 
-#endif // __rectMeshField_H__
+#endif // __rectMeshField_hpp__

utilities/postprocessPhasicFlow/rectMeshFieldToVTK.hpp

@@ -18,8 +18,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __rectMeshFieldToVTK_H__
-#define __rectMeshFieldToVTK_H__
+#ifndef __rectMeshFieldToVTK_hpp__
+#define __rectMeshFieldToVTK_hpp__
 
 
 namespace pFlow

utilities/postprocessPhasicFlow/rectMeshFields.hpp

@@ -18,10 +18,10 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __rectMeshFields_H__
-#define __rectMeshFields_H__
+#ifndef __rectMeshFields_hpp__
+#define __rectMeshFields_hpp__
 
-#include "rectMeshField.H"
+#include "rectMeshField.hpp"
 
 namespace pFlow
 {
@@ -42,4 +42,4 @@ using realx3RectMeshField_H	= rectMeshField<realx3, HostSpace>;
 }
 
 
-#endif // __rectMeshFields_H__
+#endif // __rectMeshFields_hpp__

utilities/postprocessPhasicFlow/rectangleMesh.hpp

@@ -18,10 +18,10 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __rectangleMesh_H__
-#define __rectangleMesh_H__
+#ifndef __rectangleMesh_hpp__
+#define __rectangleMesh_hpp__
 
-#include "cells.H"
+#include "cells.hpp"
 
 namespace pFlow
 {
@@ -35,7 +35,7 @@ class rectangleMesh
 	
 public:
 
-	TypeNameNV("rectangleMesh");
+	TypeInfoNV("rectangleMesh");
 	
 
 	INLINE_FUNCTION_HD
@@ -159,4 +159,4 @@ public:
 }
 
 
-#endif // __rectangleMesh_H__
+#endif // __rectangleMesh_hpp__