# PhasicFlow: utilities/Utilities/readFromTimeFolder.hpp Source File
PhasicFlow is an open-source parallel DEM (discrete element method) package for simulating granular flow. It is developed in C++ and can be exectued on both GPU (like CUDA) and CPU.

readFromTimeFolder.hpp
Go to the documentation of this file.
/*------------------------------- 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_hpp__
#define __readFromTimeFolder_hpp__
#include "vocabs.hpp"
#include "repository.hpp"
#include "pointFields.hpp"
#include "utilityFunctions.hpp"
namespace pFlow
{
class readFromTimeFolder
{
protected:
repository& repository_;
bool checkForPointStructure()const
{
return repository_.lookupObjectName(pointStructureFile__);
}
public:
explicit 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{};
if(word space{}; !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 const& fieldName, word& typeName) const
{
word fieldTYPENAME = pointField_H<T>::TYPENAME();
word flType{};
if(!pointFieldFileGetType( fieldName, flType))
{
fatalExit;
return false;
}
word fldType{};
if( !pointFieldGetType<T>(fldType) )
{
fatalExit;
return false;
}
if( flType == fldType )
{
typeName = flType;
return true;
}else
{
typeName.clear();
return false;
}
}
template<typename T>
uniquePtr<pointField_H<T>> createUniformPointField_H(word const& name, T value, bool regRep = true)
{
if( !checkForPointStructure() )
{
fatalErrorInFunction<<
"cannot find " << pointStructureFile__ << " in repository "<< repository_.name()<<endl;
fatalExit;
}
auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
if(regRep)
{
auto Ptr = makeUnique<pointField_H<T>>
(
objectFile
(
name,
"",
objectFile::READ_NEVER,
objectFile::WRITE_NEVER
),
pStruct,
T{},
value
);
return Ptr;
}
else
{
auto Ptr = makeUnique<pointField_H<T>>
(
objectFile
(
name,
"",
objectFile::READ_NEVER,
objectFile::WRITE_NEVER
),
nullptr,
pStruct,
value
);
Ptr().fill(value);
return Ptr;
}
return nullptr;
}
template<typename T>
uniquePtr<pointField_H<T>> readPointField_H(word const& name)
{
if( !checkForPointStructure() )
{
fatalErrorInFunction<<
"cannot find " << pointStructureFile__ << " in repository "<< repository_.name()<<endl;
fatalExit;
}
auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
auto Ptr = makeUnique<pointField_H<T>>
(
objectFile
(
name,
"",
objectFile::READ_IF_PRESENT,
objectFile::WRITE_ALWAYS
),
pStruct,
T{}
);
return Ptr;
}
template<typename T>
uniquePtr<pointField_D<T>> readPointField_D(word const& name)
{
if( !checkForPointStructure() )
{
fatalErrorInFunction<<
"cannot find " << pointStructureFile__ << " in repository "<< repository_.name()<<endl;
fatalExit;
}
auto& pStruct = repository_.lookupObject<pointStructure>(pointStructureFile__);
auto Ptr = makeUnique<pointField_D<T>>
(
objectFile
(
name,
"",
objectFile::READ_IF_PRESENT,
objectFile::WRITE_ALWAYS
),
pStruct,
T{}
);
return Ptr;
}
};
} //pFlow
#endif //__readFromTimeFolder_hpp__
pFlow::readFromTimeFolder::fieldExists
std::pair< bool, IOfileHeader > fieldExists(word fieldName) const
Definition: readFromTimeFolder.cpp:30
pFlow::readFromTimeFolder::path
auto path() const
Definition: readFromTimeFolder.hpp:47
fatalExit
#define fatalExit
Fatal exit.
Definition: error.hpp:98
pFlow::readFromTimeFolder::readPointField_H
uniquePtr< pointField_H< T > > readPointField_H(word const &name)
Definition: readFromTimeFolder.hpp:167
pFlow::repository::lookupObject
T & lookupObject(const word &name)
return a ref to the underlaying data in the object
Definition: repositoryTemplates.cpp:40
pFlow::readFromTimeFolder
Definition: readFromTimeFolder.hpp:31
pFlow::readFromTimeFolder::pointFieldFileGetType
bool pointFieldFileGetType(word fieldName, word &typeName) const
Definition: readFromTimeFolder.cpp:43
pFlow::repository::lookupObjectName
bool lookupObjectName(const word &nm) const
Definition: repository.cpp:157
pFlow::word
std::string word
Definition: builtinTypes.hpp:64
pointFields.hpp
pFlow::readFromTimeFolder::db
auto & db()
Definition: readFromTimeFolder.hpp:52
pFlow::objectFile::WRITE_ALWAYS
@ WRITE_ALWAYS
Definition: objectFile.hpp:43
pFlow::endl
iOstream & endl(iOstream &os)
Add newline and flush stream.
Definition: iOstream.hpp:341
pFlow::readFromTimeFolder::pointFieldGetType
bool pointFieldGetType(word &typeName) const
Definition: readFromTimeFolder.hpp:65
pFlow
Definition: demGeometry.hpp:27
pFlow::objectFile::WRITE_NEVER
@ WRITE_NEVER
Definition: objectFile.hpp:44
pFlow::readFromTimeFolder::pointFieldGetCheckType
bool pointFieldGetCheckType(word const &fieldName, word &typeName) const
Definition: readFromTimeFolder.hpp:84
repository.hpp
pFlow::readFromTimeFolder::repository_
repository & repository_
Definition: readFromTimeFolder.hpp:35
pFlow::repository::name
word name() const
Definition: repository.cpp:60
pFlow::pointField
Definition: pointField.hpp:33
pFlow::pointStructure
Definition: pointStructure.hpp:34
pFlow::pointStructureFile__
const char *const pointStructureFile__
Definition: vocabs.hpp:42
fatalErrorInFunction
#define fatalErrorInFunction
Report a fatal error and function name and exit the application.
Definition: error.hpp:77
pFlow::readFromTimeFolder::checkForPointStructure
bool checkForPointStructure() const
Definition: readFromTimeFolder.hpp:37
pFlow::objectFile
Definition: objectFile.hpp:30
pFlow::repository::path
virtual fileSystem path() const
Definition: repository.cpp:70
pStruct
auto & pStruct
Definition: setPointStructure.hpp:24
pFlow::readFromTimeFolder::readFromTimeFolder
readFromTimeFolder(repository &rep)
Definition: readFromTimeFolder.cpp:23
utilityFunctions.hpp
pFlow::objectFile::READ_NEVER
@ READ_NEVER
Definition: objectFile.hpp:37
pFlow::utilities::pointFieldGetType
bool pointFieldGetType(std::string TYPENAME, std::string &fieldType, std::string &fieldSpace)
Definition: utilityFunctions.hpp:30
pFlow::uniquePtr
Definition: uniquePtr.hpp:42
pFlow::repository
Definition: repository.hpp:34
pFlow::objectFile::READ_IF_PRESENT
@ READ_IF_PRESENT
Definition: objectFile.hpp:38
vocabs.hpp
pFlow::readFromTimeFolder::readPointField_D
uniquePtr< pointField_D< T > > readPointField_D(word const &name)
Definition: readFromTimeFolder.hpp:195
pFlow::readFromTimeFolder::createUniformPointField_H
uniquePtr< pointField_H< T > > createUniformPointField_H(word const &name, T value, bool regRep=true)
Definition: readFromTimeFolder.hpp:116