postprocessPhasicFlow

utilities/Utilities/CMakeLists.txt

@@ -0,0 +1,13 @@
+
+set(SourceFiles 
+vtkFile.C
+readFromTimeFolder.C
+)
+
+set(link_libs Kokkos::kokkos phasicFlow Particles Geometry)
+
+pFlow_add_library_install(Utilities SourceFiles link_libs)
+
+
+
+

utilities/Utilities/readFromTimeFolder.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 "readFromTimeFolder.H"
+ 
+pFlow::readFromTimeFolder::readFromTimeFolder(repository& rep)
+:
+	repository_(rep)
+{}
+
+
+std::pair<bool, pFlow::IOfileHeader> 
+	pFlow::readFromTimeFolder::fieldExists(word fieldName)const
+{
+	IOfileHeader fieldHeader(
+		objectFile(
+			fieldName,
+			repository_.path(),
+			objectFile::READ_ALWAYS,
+			objectFile::WRITE_NEVER)
+		);
+	
+	return std::make_pair( fieldHeader.headerOk(true), fieldHeader);
+}
+
+bool pFlow::readFromTimeFolder::pointFieldFileGetType(
+	word fieldName,
+	word& typeName) const
+{
+	
+	word fileTypeName, space;
+	if( auto [exist, fieldHeader]= fieldExists(fieldName); !exist )
+	{
+		fatalErrorInFunction<< "Folder "<< repository_.path() <<
+		" does not contain " << fieldName << " field."<<endl;
+		fatalExit;
+		return false;
+	}
+	else
+	{
+		fileTypeName = fieldHeader.objectType();
+	}
+
+	typeName.clear();		
+	word flType{};
+	
+	if( !pFlow::utilities::pointFieldGetType(
+		fileTypeName, flType, space) )
+	{
+		fatalErrorInFunction<<
+		"error in extracting type from "<<fileTypeName<<endl;
+		fatalExit;
+		return false;
+	}
+
+	typeName = flType;
+	return true;
+}

utilities/Utilities/readFromTimeFolder.H

@@ -0,0 +1,201 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in 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 __readFromTimeFolder_H__
+#define __readFromTimeFolder_H__
+
+
+#include "repository.H"
+#include "pointFields.H"
+#include "utilityFunctions.H"
+
+namespace pFlow
+{
+
+class readFromTimeFolder
+{
+protected:
+
+	repository& 		repository_;
+
+	bool checkForPointStructure()const
+	{
+		return repository_.lookupObjectName(pointStructureFile__);
+	}
+
+public:
+
+
+	readFromTimeFolder(repository& rep);
+
+	auto path()const
+	{
+		return repository_.path();
+	}
+
+	auto& db()
+	{
+		return repository_;
+	}
+
+	std::pair<bool, IOfileHeader> 
+		fieldExists(word fieldName)const;
+	
+
+
+	bool pointFieldFileGetType(word fieldName, word& typeName) const;
+	
+	template<typename T>
+	bool pointFieldGetType(word& typeName)const
+	{
+		word fieldTYPENAME = pointField_H<T>::TYPENAME();
+		word fldType{}, space{};
+		
+		if( !pFlow::utilities::pointFieldGetType(
+			fieldTYPENAME, fldType, space) )
+		{
+			fatalErrorInFunction<<
+			"error in extracting type from "<<fieldTYPENAME<<endl;
+			return false;
+		}
+	
+		typeName = fldType;
+		return true;
+		
+	}
+
+	template<typename T>
+	bool pointFieldGetCheckType(word fieldName, word& typeName) const
+	{
+		
+		word fieldTYPENAME = pointField_H<T>::TYPENAME();
+		word flType{},fldType{};
+
+		if(!pointFieldFileGetType( fieldName, flType))
+		{
+			fatalExit;
+			return false;
+		}
+		
+		if( !pointFieldGetType<T>(fldType) )
+		{
+			fatalExit;
+			return false;
+		}
+
+		
+		if( flType == fldType )
+		{
+			typeName = flType;
+			return true;
+		}else
+		{	
+			typeName.clear();
+			return false;
+		}
+	}
+
+	template<typename T>
+	pointField_H<T>&  createUniformPointField_H(word name, T value)
+	{
+		if( !checkForPointStructure() )
+		{
+			fatalErrorInFunction<<
+			"cannot find " << pointStructureFile__ << " in repository "<< repository_.name()<<endl;
+			fatalExit;
+		}
+		auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
+
+		word fType;
+		pointFieldGetType<T>(fType);
+		word newName = name + fType;
+
+		auto& field = repository_.emplaceReplaceObject<pointField_H<T>>(
+			objectFile(
+				name,
+				"",
+				objectFile::READ_NEVER,
+				objectFile::WRITE_NEVER
+				),
+			pStruct,
+			value
+			);
+
+		return field;
+
+	}
+
+	template<typename T>
+	pointField_H<T>& readPointField_H(word name) 
+	{
+		if( !checkForPointStructure() )
+		{
+			fatalErrorInFunction<<
+			"cannot find " << pointStructureFile__ << " in repository "<< repository_.name()<<endl;
+			fatalExit;
+		}
+		auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
+
+		auto& field = repository_.emplaceObjectOrGet<pointField_H<T>>(
+			objectFile(
+				name,
+				"",
+				objectFile::READ_IF_PRESENT,
+				objectFile::WRITE_ALWAYS
+				),
+			pStruct,
+			T{}
+			);
+
+		return field;
+
+	}
+
+	template<typename T>
+	pointField_D<T>& readPointField_D(word name) 
+	{
+		if( !checkForPointStructure() )
+		{
+			fatalErrorInFunction<<
+			"cannot find " << pointStructureFile__ << " in repository "<< repository_.name()<<endl;
+			fatalExit;
+		}
+		auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
+
+		auto& field = repository_.emplaceObjectOrGet<pointField_H<T>>(
+			objectFile(
+				name,
+				"",
+				objectFile::READ_IF_PRESENT,
+				objectFile::WRITE_ALWAYS
+				),
+			pStruct,
+			T{}
+			);
+
+		return field;
+	}
+
+};
+
+} //pFlow
+
+
+
+#endif //__readFromTimeFolder_H__ 

utilities/Utilities/utilityFunctions.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 __utilityFunctions_H__
+#define __utilityFunctions_H__
+
+#include <regex>
+
+
+namespace pFlow::utilities
+{
+
+bool inline pointFieldGetType(std::string TYPENAME, std::string& fieldType, std::string& fieldSpace)
+{
+	std::regex match("pointField\\<([A-Za-z1-9_]*)\\,([A-Za-z1-9_]*)\\>");
+    std::smatch search;
+	if(!std::regex_match(TYPENAME, search, match)) return false;
+    if(search.size()!= 3) return false;
+    fieldType  = search[1];
+    fieldSpace = search[2];
+	return true;
+}
+
+
+}
+
+
+#endif //__utilityFunctions_H__

utilities/Utilities/vtkFile.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 "vtkFile.H"
+
+bool pFlow::vtkFile::openStream()
+{
+	oStream_ = makeUnique<oFstream>( fileName() );
+	if( !oStream_ )return false;
+	return writeHeader();
+}
+
+bool pFlow::vtkFile::vtkFile::writeHeader()
+{
+
+	if(!oStream_) return false;
+
+	oStream_() << "# vtk DataFile Version 2.0" << endl;
+	
+	oStream_() << "vtk file for time : " << time_ << endl;
+
+	oStream_() << "ASCII" << endl;
+
+	if( oStream_().fail() ) return false;
+
+	return true;
+
+}
+
+pFlow::vtkFile::vtkFile
+(
+	const fileSystem dir,
+	const word& bName,
+	real time
+)
+:
+	dirPath_(dir),
+	baseName_(bName),
+	time_(time)
+{
+
+	if(!openStream())
+	{
+		fatalErrorInFunction <<
+		"  error in creating vtkFile "<<fileName()<<endl;
+		fatalExit;
+	}
+
+}
+
+
+pFlow::fileSystem pFlow::vtkFile::fileName()const
+{
+	word fName = baseName_ +"-" + int322Word(10000*time_) + ".vtk";
+	return dirPath_ +fName;
+}
+

utilities/Utilities/vtkFile.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 __vtkFile_H__
+#define __vtkFile_H__ 
+
+#include "types.H"
+#include "uniquePtr.H"
+#include "fileSystem.H"
+#include "streams.H"
+
+namespace pFlow
+{
+
+
+class vtkFile
+{
+protected:
+
+	fileSystem dirPath_;
+
+	word       baseName_;
+
+	real  	   time_ = 0.0;
+
+	uniquePtr<oFstream>  oStream_= nullptr;
+
+	bool openStream();
+
+	virtual bool writeHeader();
+
+public:
+
+	vtkFile(const fileSystem dir, const word& bName, real time);
+
+	virtual ~vtkFile() = default;
+
+	inline oFstream& operator ()()
+	{
+		if(!oStream_)
+		{
+			if(!openStream())
+			{
+				fatalErrorInFunction<<
+				"  error in opening vtkFile "<< fileName() <<endl;
+				fatalExit;
+			}
+		}
+		return oStream_();
+	}
+
+	inline explicit operator bool() const
+	{
+		if(!oStream_)return false;
+		if(oStream_().fail())return false;
+		return true;
+	}
+
+	inline bool operator!()const
+	{
+		if( !oStream_) return true;
+		if( oStream_().fail() )return true;
+		
+		return false;
+	}
+
+	virtual fileSystem fileName()const;	
+
+};
+
+}
+
+#endif //__vtkFile_H__