modify for coupling-cpp and hpp

utilities/Utilities/CMakeLists.txt

@@ -1,8 +1,8 @@
 
 set(SourceFiles 
-vtkFile.C
-readFromTimeFolder.C
-readControlDict.C
+vtkFile.cpp
+readFromTimeFolder.cpp
+readControlDict.cpp
 )
 
 set(link_libs Kokkos::kokkos phasicFlow Particles Geometry)

utilities/Utilities/readControlDict.cpp

@@ -17,9 +17,9 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-#include "readControlDict.H"
-#include "iFstream.H"
-#include "timeFolder.H"
+#include "readControlDict.hpp"
+#include "iFstream.hpp"
+#include "timeFolder.hpp"
 
 pFlow::word pFlow::readControlDict::convertTimeToName(
 	const real t, 

utilities/Utilities/readControlDict.hpp

@@ -18,10 +18,10 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __readControlDict_H__
-#define __readControlDict_H__
+#ifndef __readControlDict_hpp__
+#define __readControlDict_hpp__
 
-#include "fileSystem.H"
+#include "fileSystem.hpp"
 
 
 namespace pFlow
@@ -83,5 +83,5 @@ public:
 
 }
 
-#endif //__readControlDict_H__
+#endif //__readControlDict_hpp__
 

utilities/Utilities/readFromTimeFolder.cpp

@@ -18,7 +18,7 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "readFromTimeFolder.H"
+#include "readFromTimeFolder.hpp"
  
 pFlow::readFromTimeFolder::readFromTimeFolder(repository& rep)
 :

utilities/Utilities/readFromTimeFolder.hpp

@@ -17,13 +17,13 @@ Licence:
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 -----------------------------------------------------------------------------*/
-#ifndef __readFromTimeFolder_H__
-#define __readFromTimeFolder_H__
+#ifndef __readFromTimeFolder_hpp__
+#define __readFromTimeFolder_hpp__
 
 
-#include "repository.H"
-#include "pointFields.H"
-#include "utilityFunctions.H"
+#include "repository.hpp"
+#include "pointFields.hpp"
+#include "utilityFunctions.hpp"
 
 namespace pFlow
 {
@@ -198,4 +198,4 @@ public:
 
 
 
-#endif //__readFromTimeFolder_H__ 
+#endif //__readFromTimeFolder_hpp__ 

utilities/Utilities/utilityFunctions.hpp

@@ -18,8 +18,8 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __utilityFunctions_H__
-#define __utilityFunctions_H__
+#ifndef __utilityFunctions_hpp__
+#define __utilityFunctions_hpp__
 
 #include <regex>
 
@@ -42,4 +42,4 @@ bool inline pointFieldGetType(std::string TYPENAME, std::string& fieldType, std:
 }
 
 
-#endif //__utilityFunctions_H__
+#endif //__utilityFunctions_hpp__

utilities/Utilities/vtkFile.cpp

@@ -19,7 +19,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "vtkFile.H"
+#include "vtkFile.hpp"
 
 bool pFlow::vtkFile::openStream()
 {

utilities/Utilities/vtkFile.hpp

@@ -18,13 +18,13 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __vtkFile_H__
-#define __vtkFile_H__ 
+#ifndef __vtkFile_hpp__
+#define __vtkFile_hpp__ 
 
-#include "types.H"
-#include "uniquePtr.H"
-#include "fileSystem.H"
-#include "streams.H"
+#include "types.hpp"
+#include "uniquePtr.hpp"
+#include "fileSystem.hpp"
+#include "streams.hpp"
 
 namespace pFlow
 {
@@ -87,4 +87,4 @@ public:
 
 }
 
-#endif //__vtkFile_H__
+#endif //__vtkFile_hpp__

utilities/checkPhasicFlow/CMakeLists.txt

@@ -1,6 +1,6 @@
 
 set(source_files 
-checkPhasicFlow.C
+checkPhasicFlow.cpp
 )
 set(link_lib phasicFlow Kokkos::kokkos)
 

utilities/checkPhasicFlow/checkPhasicFlow.cpp

@@ -18,9 +18,9 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "KokkosTypes.H"
-#include "systemControl.H"
-#include "commandLine.H"
+#include "KokkosTypes.hpp"
+#include "systemControl.hpp"
+#include "commandLine.hpp"
 
 
 using pFlow::output;
@@ -37,7 +37,7 @@ int main( int argc, char* argv[] )
 if(!cmds.parse(argc, argv)) return 0;
 
 // this should be palced in each main 
-#include "initialize.H"
+#include "initialize.hpp"
 
 	output<<endl;
 	Report(1)<< "You are using "<<yellowText(cmds.productNameCopyright())<<endReport;
@@ -45,7 +45,7 @@ if(!cmds.parse(argc, argv)) return 0;
 	
 
 // this should be palced in each main 
-#include "finalize.H"
+#include "finalize.hpp"
 
 	return 0;
 } 

utilities/geometryPhasicFlow/CMakeLists.txt

@@ -1,11 +1,11 @@
 
 set(source_files 
-geometryPhasicFlow.C
-Wall/Wall.C 
-planeWall/planeWall.C 
-stlWall/stlWall.C
-cylinderWall/cylinderWall.C
-cuboidWall/cuboidWall.C
+geometryPhasicFlow.cpp
+Wall/Wall.cpp 
+planeWall/planeWall.cpp 
+stlWall/stlWall.cpp
+cylinderWall/cylinderWall.cpp
+cuboidWall/cuboidWall.cpp
 )
 set(link_lib phasicFlow Geometry Kokkos::kokkos Utilities)
 

utilities/geometryPhasicFlow/Wall/Wall.cpp

@@ -19,7 +19,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "Wall.H"
+#include "Wall.hpp"
 
 bool pFlow::Wall::readCommon(const dictionary& dict)
 {

utilities/geometryPhasicFlow/Wall/Wall.hpp

@@ -19,13 +19,13 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __Wall_H__
-#define __Wall_H__
+#ifndef __Wall_hpp__
+#define __Wall_hpp__
 
 
-#include "virtualConstructor.H"
-#include "Vectors.H"
-#include "dictionary.H"
+#include "virtualConstructor.hpp"
+#include "Vectors.hpp"
+#include "dictionary.hpp"
 
 namespace pFlow
 {
@@ -55,7 +55,7 @@ protected:
 public:
 
 	// - type info
-	TypeName("Wall");
+	TypeInfo("Wall");
 
 	//// - Constructors
 

utilities/geometryPhasicFlow/cuboidWall/cuboidWall.cpp

@@ -19,8 +19,8 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "cuboidWall.H"
-#include "planeWall.H"
+#include "cuboidWall.hpp"
+#include "planeWall.hpp"
 
 
 

utilities/geometryPhasicFlow/cuboidWall/cuboidWall.hpp

@@ -19,12 +19,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __cuboidWall_H__
-#define __cuboidWall_H__
+#ifndef __cuboidWall_hpp__
+#define __cuboidWall_hpp__
 
 
-#include "Wall.H"
-#include "types.H"
+#include "Wall.hpp"
+#include "types.hpp"
 
 namespace pFlow
 {
@@ -39,7 +39,7 @@ protected:
 
 public:
 
-	TypeName("cuboidWall");
+	TypeInfo("cuboidWall");
 
 	cuboidWall();
 

utilities/geometryPhasicFlow/cylinderWall/cylinderWall.cpp

@@ -1,5 +1,5 @@
-#include "cylinderWall.H"
-#include "line.H"
+#include "cylinderWall.hpp"
+#include "line.hpp"
 
 
 bool pFlow::cylinderWall::readCylinderWall(const dictionary& dict)

utilities/geometryPhasicFlow/cylinderWall/cylinderWall.hpp

@@ -19,11 +19,11 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __cylinderWall_H__
-#define __cylinderWall_H__
+#ifndef __cylinderWall_hpp__
+#define __cylinderWall_hpp__
 
-#include "Wall.H"
-#include "zAxis.H"
+#include "Wall.hpp"
+#include "zAxis.hpp"
 
 namespace pFlow
 {
@@ -40,7 +40,7 @@ protected:
 
 public:
 
-	TypeName("cylinderWall");
+	TypeInfo("cylinderWall");
 
 	cylinderWall();
 
@@ -60,4 +60,4 @@ public:
 
 
 
-#endif //__cylinderWall_H__
+#endif //__cylinderWall_hpp__

utilities/geometryPhasicFlow/geometryPhasicFlow.cpp

@@ -19,12 +19,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "systemControl.H"
-#include "Wall.H"
-#include "multiTriSurface.H"
-#include "geometryMotion.H"
-#include "commandLine.H"
-#include "readControlDict.H"
+#include "systemControl.hpp"
+#include "Wall.hpp"
+#include "multiTriSurface.hpp"
+#include "geometryMotion.hpp"
+#include "commandLine.hpp"
+#include "readControlDict.hpp"
 
 using pFlow::output;
 using pFlow::endl;
@@ -55,9 +55,9 @@ int main( int argc, char* argv[] )
   if(!cmds.parse(argc, argv)) return 0;
 
 // this should be palced in each main 
-#include "initialize_Control.H"
+#include "initialize_Control.hpp"
 
-	#include "setProperty.H"
+	#include "setProperty.hpp"
 
 	Report(0)<<"\nReading "<<"createGeometryDict"<<" . . ."<<endReport;
 	auto objDict = IOobject::make<dictionary>
@@ -109,7 +109,7 @@ int main( int argc, char* argv[] )
 	Report(0)<< greenText("\nFinished successfully.\n");
 
 // this should be palced in each main 
-#include "finalize.H"
+#include "finalize.hpp"
 
 	return 0;
 } 

utilities/geometryPhasicFlow/planeWall/planeWall.cpp

@@ -19,8 +19,8 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "planeWall.H"
-#include "line.H"
+#include "planeWall.hpp"
+#include "line.hpp"
 
 bool pFlow::planeWall::readPlaneWall
 (

utilities/geometryPhasicFlow/planeWall/planeWall.hpp

@@ -19,12 +19,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __planeWall_H__
-#define __planeWall_H__
+#ifndef __planeWall_hpp__
+#define __planeWall_hpp__
 
 
-#include "Wall.H"
-#include "types.H"
+#include "Wall.hpp"
+#include "types.hpp"
 
 namespace pFlow
 {
@@ -59,7 +59,7 @@ protected:
 
 public:
 
-	TypeName("planeWall");
+	TypeInfo("planeWall");
 
 	planeWall();
 

utilities/geometryPhasicFlow/stlWall/stlWall.cpp

@@ -19,10 +19,10 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "stlWall.H"
-#include "stlFile.H"
+#include "stlWall.hpp"
+#include "stlFile.hpp"
 
-#include "streams.H"
+#include "streams.hpp"
 
 bool pFlow::stlWall::readSTLWall
 (

utilities/geometryPhasicFlow/stlWall/stlWall.hpp

@@ -19,12 +19,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __stlWall_H__
-#define __stlWall_H__
+#ifndef __stlWall_hpp__
+#define __stlWall_hpp__
 
 
-#include "Wall.H"
-#include "types.H"
+#include "Wall.hpp"
+#include "types.hpp"
 
 namespace pFlow
 {
@@ -39,7 +39,7 @@ protected:
 
 public:
 
-	TypeName("stlWall");
+	TypeInfo("stlWall");
 
 	stlWall();
 

utilities/pFlowToVTK/CMakeLists.txt

@@ -1,7 +1,7 @@
 
 set(source_files 
-pFlowToVTK.C 
-geometric.C 
+pFlowToVTK.cpp 
+geometric.cpp 
 )
 set(link_lib phasicFlow Kokkos::kokkos Utilities)
 

utilities/pFlowToVTK/geometric.cpp

@@ -19,7 +19,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "geometric.H"
+#include "geometric.hpp"
 
 
 template<>

utilities/pFlowToVTK/geometric.hpp

@@ -19,13 +19,13 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __geometric_H__
-#define __geometric_H__ 
+#ifndef __geometric_hpp__
+#define __geometric_hpp__ 
 
-#include "vtkFile.H"
-#include "triSurface.H"
-#include "multiTriSurface.H"
-#include "IOobject.H"
+#include "vtkFile.hpp"
+#include "triSurface.hpp"
+#include "multiTriSurface.hpp"
+#include "IOobject.hpp"
 
 namespace pFlow
 {
@@ -75,4 +75,4 @@ bool dataToVTK( vtkFile& vtk, const multiTriSurface& surface );
 
 }
 
-#endif //__geometric_H__
+#endif //__geometric_hpp__

utilities/pFlowToVTK/pFlowToVTK.cpp

@@ -19,13 +19,13 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "systemControl.H"
-#include "pointFieldToVTK.H"
-#include "triSurfaceFieldToVTK.H"
-#include "timeFolder.H"
-#include "commandLine.H"
-#include "ranges.H"
-#include "readControlDict.H"
+#include "systemControl.hpp"
+#include "pointFieldToVTK.hpp"
+#include "triSurfaceFieldToVTK.hpp"
+#include "timeFolder.hpp"
+#include "commandLine.hpp"
+#include "ranges.hpp"
+#include "readControlDict.hpp"
 
 
 using pFlow::word;
@@ -88,7 +88,7 @@ int main(int argc, char** argv )
 	
 	
 // this should be palced in each main 
-#include "initialize_Control.H"
+#include "initialize_Control.hpp"
 
 
 	timeFolder folders(Control);
@@ -171,6 +171,6 @@ int main(int argc, char** argv )
 
 	
 // this should be palced in each main 
-#include "finalize.H"
+#include "finalize.hpp"
 	return 0;
 }

utilities/pFlowToVTK/pointFieldToVTK.hpp

@@ -19,14 +19,14 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __pointFieldToVTK_H__
-#define __pointFieldToVTK_H__
+#ifndef __pointFieldToVTK_hpp__
+#define __pointFieldToVTK_hpp__
 
 #include <regex>
 
-#include "vtkFile.H"
-#include "pointFields.H"
-#include "IOobject.H"
+#include "vtkFile.hpp"
+#include "pointFields.hpp"
+#include "IOobject.hpp"
 
 namespace pFlow::PFtoVTK
 {

utilities/pFlowToVTK/triSurfaceFieldToVTK.hpp

@@ -19,16 +19,16 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __triSurfaceFieldToVTK_H__
-#define __triSurfaceFieldToVTK_H__
+#ifndef __triSurfaceFieldToVTK_hpp__
+#define __triSurfaceFieldToVTK_hpp__
 
 #include <regex>
 
-#include "vtkFile.H"
-#include "triSurface.H"
-#include "multiTriSurface.H"
-#include "triSurfaceFields.H"
-#include "IOobject.H"
+#include "vtkFile.hpp"
+#include "triSurface.hpp"
+#include "multiTriSurface.hpp"
+#include "triSurfaceFields.hpp"
+#include "IOobject.hpp"
 
 namespace pFlow::TSFtoVTK
 {

utilities/particlesPhasicFlow/CMakeLists.txt

@@ -1,10 +1,10 @@
 
 set(source_files
-particlesPhasicFlow.C
-positionParticles/positionParticles.C 
-positionOrdered/positionOrdered.C 
-positionRandom/positionRandom.C
-empty/empty.C
+particlesPhasicFlow.cpp
+positionParticles/positionParticles.cpp 
+positionOrdered/positionOrdered.cpp 
+positionRandom/positionRandom.cpp
+empty/empty.cpp
 )
 set(link_lib phasicFlow Kokkos::kokkos Interaction Utilities)
 

utilities/particlesPhasicFlow/empty/empty.cpp

@@ -18,7 +18,7 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "empty.H"
+#include "empty.hpp"
 
 
 

utilities/particlesPhasicFlow/empty/empty.hpp

@@ -18,11 +18,11 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __empty_H__
-#define __empty_H__
+#ifndef __empty_hpp__
+#define __empty_hpp__
 
-#include "positionParticles.H"
-#include "box.H"
+#include "positionParticles.hpp"
+#include "box.hpp"
 
 namespace pFlow
 {
@@ -42,7 +42,7 @@ protected:
 public:
 
 	// - type Info
-	TypeName("empty");
+	TypeInfo("empty");
 
 	empty(const dictionary& dict);
 
@@ -91,4 +91,4 @@ public:
 
 
 
-#endif // __empety_H__
+#endif // __empety_hpp__

utilities/particlesPhasicFlow/particlesPhasicFlow.cpp

@@ -19,12 +19,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "positionParticles.H"
-#include "pointStructure.H"
-#include "setFields.H"
-#include "systemControl.H"
-#include "commandLine.H"
-#include "readControlDict.H"
+#include "positionParticles.hpp"
+#include "pointStructure.hpp"
+#include "setFields.hpp"
+#include "systemControl.hpp"
+#include "commandLine.hpp"
+#include "readControlDict.hpp"
 
 using pFlow::output;
 using pFlow::endl;
@@ -79,7 +79,7 @@ int main( int argc, char* argv[] )
 	}	
 
 // this should be palced in each main 
-#include "initialize_Control.H"
+#include "initialize_Control.hpp"
 
 	auto objCPDict = IOobject::make<dictionary>
 	(
@@ -195,7 +195,7 @@ int main( int argc, char* argv[] )
 
 
 // this should be palced in each main 
-#include "finalize.H"
+#include "finalize.hpp"
 
 	return 0;
 } 

utilities/particlesPhasicFlow/positionOrdered/positionOrdered.cpp

@@ -18,11 +18,11 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "positionOrdered.H"
-#include "error.H"
+#include "positionOrdered.hpp"
+#include "error.hpp"
 
 
-#include "streams.H"
+#include "streams.hpp"
 
 
 bool pFlow::positionOrdered::findAxisIndex()

utilities/particlesPhasicFlow/positionOrdered/positionOrdered.hpp

@@ -18,10 +18,10 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __positionOrdered_H__
-#define __positionOrdered_H__
+#ifndef __positionOrdered_hpp__
+#define __positionOrdered_hpp__
 
-#include "positionParticles.H"
+#include "positionParticles.hpp"
 
 namespace pFlow
 {
@@ -60,7 +60,7 @@ protected:
 public:
 
 	// - type Info
-	TypeName("positionOrdered");
+	TypeInfo("positionOrdered");
 
 	positionOrdered(const dictionary& dict);
 
@@ -109,4 +109,4 @@ public:
 
 
 
-#endif // __positionOrdered_H__
+#endif // __positionOrdered_hpp__

utilities/particlesPhasicFlow/positionParticles/positionParticles.cpp

@@ -18,14 +18,14 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#include "positionParticles.H"
-#include "box.H"
-#include "cylinder.H"
-#include "sphere.H"
-#include "cells.H"
-#include "contactSearchFunctions.H"
+#include "positionParticles.hpp"
+#include "box.hpp"
+#include "cylinder.hpp"
+#include "sphere.hpp"
+#include "cells.hpp"
+#include "contactSearchFunctions.hpp"
 
-#include "streams.H"
+#include "streams.hpp"
 
 
 pFlow::realx3Vector pFlow::positionParticles::sortByMortonCode(realx3Vector& position)const

utilities/particlesPhasicFlow/positionParticles/positionParticles.hpp

@@ -18,12 +18,12 @@ Licence:
 
 -----------------------------------------------------------------------------*/
 
-#ifndef __positionParticles_H__
-#define __positionParticles_H__
+#ifndef __positionParticles_hpp__
+#define __positionParticles_hpp__
 
-#include "virtualConstructor.H"
-#include "Vectors.H"
-#include "dictionary.H"
+#include "virtualConstructor.hpp"
+#include "Vectors.hpp"
+#include "dictionary.hpp"
 
 namespace pFlow
 {
@@ -116,7 +116,7 @@ protected:
 public:
 
 	// - type Info
-	TypeName("positionParticles");
+	TypeInfo("positionParticles");
 
 	positionParticles(const dictionary& dict);
 
@@ -167,4 +167,4 @@ public:
 
 
 
-#endif // __positionParticles_H__
+#endif // __positionParticles_hpp__

utilities/particlesPhasicFlow/positionRandom/positionRandom.cpp

@@ -19,11 +19,11 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#include "positionRandom.H"
-#include "uniformRandomReal.H"
-#include "NBSLevel0.H"
-#include "unsortedPairs.H"
-#include "box.H"
+#include "positionRandom.hpp"
+#include "uniformRandomReal.hpp"
+#include "NBSLevel0.hpp"
+#include "unsortedPairs.hpp"
+#include "box.hpp"
 
 
 

utilities/particlesPhasicFlow/positionRandom/positionRandom.hpp

@@ -19,12 +19,12 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __positionOrdered_H__
-#define __positionOrdered_H__
+#ifndef __positionOrdered_hpp__
+#define __positionOrdered_hpp__
 
-#include "positionParticles.H"
-#include "VectorSingles.H"
-#include "VectorDuals.H"
+#include "positionParticles.hpp"
+#include "VectorSingles.hpp"
+#include "VectorDuals.hpp"
 
 
 namespace pFlow
@@ -64,7 +64,7 @@ protected:
 public:
 
 	// - type Info
-	TypeName("positionRandom");
+	TypeInfo("positionRandom");
 
 	positionRandom(const dictionary& dict);
 
@@ -115,4 +115,4 @@ public:
 
 
 
-#endif // __positionOrdered_H__
+#endif // __positionOrdered_hpp__

utilities/particlesPhasicFlow/setFields.hpp

@@ -19,13 +19,13 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 
-#ifndef __setFields_H__
-#define __setFields_H__
+#ifndef __setFields_hpp__
+#define __setFields_hpp__
 
-#include "pStructSelector.H"
-#include "pointFields.H"
-#include "setFieldList.H"
-#include "systemControl.H"
+#include "pStructSelector.hpp"
+#include "pointFields.hpp"
+#include "setFieldList.hpp"
+#include "systemControl.hpp"
 
 namespace pFlow
 {
@@ -53,4 +53,4 @@ bool applySelector(systemControl& control, const pointStructure& pStruct, const
 
 } // pFlow
 
-#endif //__setFields_H__
+#endif //__setFields_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__