xfygogo
/
phasicFlow
mirror of https://github.com/PhasicFlow/phasicFlow.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

pointFieild

This commit is contained in:
Hamidreza Norouzi 2024-01-20 06:05:05 -08:00
parent 0096856c98
commit 6bc180275e
13 changed files with 117 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/phasicFlow/CMakeLists.txt
View File

@ -38,7 +38,7 @@ containers/Vector/Vectors.cpp
containers/VectorHD/VectorSingles.cpp containers/VectorHD/VectorSingles.cpp
containers/Field/Fields.cpp containers/Field/Fields.cpp
containers/List/anyList/anyList.cpp containers/List/anyList/anyList.cpp
#containers/pointField/pointFields.cpp containers/pointField/pointFields.cpp
#setFieldList/setFieldList.cpp #setFieldList/setFieldList.cpp
#setFieldList/setFieldEntry.cpp #setFieldList/setFieldEntry.cpp
@ -112,6 +112,7 @@ if(pFlow_Build_MPI)
MPIParallelization/procCommunication.cpp MPIParallelization/procCommunication.cpp
MPIParallelization/boundaryProcessor.cpp MPIParallelization/boundaryProcessor.cpp
MPIParallelization/scatteredMasterDistributeChar.cpp MPIParallelization/scatteredMasterDistributeChar.cpp
MPIParallelization/processorBoundaryFields.cpp
) )
list(APPEND link_libs MPI::MPI_CXX ${ZOLTAN_LIBRARY} -lm ) list(APPEND link_libs MPI::MPI_CXX ${ZOLTAN_LIBRARY} -lm )

10
src/phasicFlow/containers/pointField/boundaryField.cpp
View File

@ -18,8 +18,8 @@ Licence:
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::boundaryField<VectorField, T, MemorySpace>::boundaryField pFlow::boundaryField<T, MemorySpace>::boundaryField
( (
const boundaryBase& boundary, const boundaryBase& boundary,
InternalFieldType& internal InternalFieldType& internal
@ -31,9 +31,9 @@ pFlow::boundaryField<VectorField, T, MemorySpace>::boundaryField
{} {}
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::uniquePtr<pFlow::boundaryField<VectorField, T, MemorySpace>> pFlow::uniquePtr<pFlow::boundaryField<T, MemorySpace>>
pFlow::boundaryField<VectorField, T, MemorySpace>::create pFlow::boundaryField<T, MemorySpace>::create
( (
const boundaryBase& boundary, const boundaryBase& boundary,
InternalFieldType& internal InternalFieldType& internal

6
src/phasicFlow/containers/pointField/boundaryField.hpp
View File

@ -27,16 +27,16 @@ Licence:
namespace pFlow namespace pFlow
{ {
template< template<class, class> class VectorField, class T, class MemorySpace = void> template< class T, class MemorySpace = void>
class boundaryField class boundaryField
: :
public observer public observer
{ {
public: 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; using memory_space = typename InternalFieldType::memory_space;

6
src/phasicFlow/containers/pointField/boundaryFieldList.hpp
View File

@ -27,14 +27,14 @@ Licence:
namespace pFlow namespace pFlow
{ {
template< template<class, class> class VectorField, class T, class MemorySpace = void > template< class T, class MemorySpace = void >
class boundaryFieldList class boundaryFieldList
: :
ListPtr<boundaryField<VectorField, T, MemorySpace>> public ListPtr< boundaryField<T, MemorySpace> >
{ {
public: public:
using BoundaryFieldType = boundaryField<VectorField, T, MemorySpace>; using BoundaryFieldType = boundaryField<T, MemorySpace>;
using InternalFieldType = typename BoundaryFieldType::InternalFieldType; using InternalFieldType = typename BoundaryFieldType::InternalFieldType;

8
src/phasicFlow/containers/pointField/createBoundaryFields.hpp
View File

@ -24,12 +24,12 @@ Licence:
#include "boundaryField.hpp" #include "boundaryField.hpp"
#include "exitBoundaryField.hpp" #include "exitBoundaryField.hpp"
#define createBaseBoundary(VectorFieldType, DataType, MemorySpaceType) \ #define createBaseBoundary(DataType, MemorySpaceType) \
template class pFlow::boundaryField<VectorFieldType, DataType, MemorySpaceType>; template class pFlow::boundaryField<DataType, MemorySpaceType>;
#define createBoundary(VectorFieldType, DataType, MemorySpaceType, BoundaryType) \ #define createBoundary(DataType, MemorySpaceType, BoundaryType) \
template class pFlow::BoundaryType##BoundaryField<VectorFieldType, DataType, MemorySpaceType>; template class pFlow::BoundaryType##BoundaryField<DataType, MemorySpaceType>;
#endif //__createBoundaryFields_hpp__ #endif //__createBoundaryFields_hpp__

4
src/phasicFlow/containers/pointField/exitBoundaryField.cpp
View File

@ -18,8 +18,8 @@ Licence:
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::exitBoundaryField<VectorField, T, MemorySpace>::exitBoundaryField pFlow::exitBoundaryField<T, MemorySpace>::exitBoundaryField
( (
const boundaryBase& boundary, const boundaryBase& boundary,
InternalFieldType& internal InternalFieldType& internal

11
src/phasicFlow/containers/pointField/exitBoundaryField.hpp
View File

@ -25,16 +25,16 @@ Licence:
namespace pFlow namespace pFlow
{ {
template< template<class, class> class VectorField, class T, class MemorySpace = void> template< class T, class MemorySpace = void>
class exitBoundaryField class exitBoundaryField
: :
public boundaryField<VectorField, T, MemorySpace> public boundaryField<T, MemorySpace>
{ {
public: 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; using InternalFieldType = typename BoundaryFieldType::InternalFieldType;
@ -51,8 +51,7 @@ public:
exitBoundaryField( exitBoundaryField(
const boundaryBase& boundary, const boundaryBase& boundary,
InternalFieldType& internal); InternalFieldType& internal);
add_vCtor add_vCtor
( (

37
src/phasicFlow/containers/pointField/internalField.cpp
View File

@ -18,8 +18,8 @@ Licence:
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::internalField<VectorField, T, MemorySpace>::internalField pFlow::internalField<T, MemorySpace>::internalField
( (
const word& name, const word& name,
const internalPoints& internal const internalPoints& internal
@ -41,8 +41,8 @@ pFlow::internalField<VectorField, T, MemorySpace>::internalField
internalPoints_(internal) internalPoints_(internal)
{} {}
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::internalField<VectorField, T, MemorySpace>::internalField pFlow::internalField<T, MemorySpace>::internalField
( (
const word &name, const word &name,
const internalPoints &internal, const internalPoints &internal,
@ -68,14 +68,22 @@ pFlow::internalField<VectorField, T, MemorySpace>::internalField
} }
template <template <class, class> class VectorField, class T, class MemorySpace> template <class T, class MemorySpace>
pFlow::hostViewType1D<T> typename pFlow::internalField<T, MemorySpace>::FieldTypeHost
pFlow::internalField<VectorField, T, MemorySpace>::activeValuesHost() const pFlow::internalField<T, MemorySpace>::activeValuesHost() const
{ {
auto maskH = internalPoints_.activePointsMaskHost(); auto maskH = internalPoints_.activePointsMaskHost();
auto fieldH = field_.hostVector(); 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(); auto aRange = maskH.activeRange();
uint32 n = 0; uint32 n = 0;
@ -87,12 +95,11 @@ pFlow::internalField<VectorField, T, MemorySpace>::activeValuesHost() const
n++; n++;
} }
} }
return aField; return aField;
} }
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
bool pFlow::internalField<VectorField, T, MemorySpace>::write bool pFlow::internalField<T, MemorySpace>::write
( (
iOstream& os, iOstream& os,
const IOPattern& iop const IOPattern& iop
@ -104,9 +111,7 @@ bool pFlow::internalField<VectorField, T, MemorySpace>::write
} }
else else
{ {
auto aValues = activeValuesHost(); auto aField = activeValuesHost();
auto spanValues = makeSpan(aValues); return aField.write(os, iop);
return writeSpan(os, spanValues, iop);
} }
} }

15
src/phasicFlow/containers/pointField/internalField.hpp
View File

@ -23,20 +23,25 @@ Licence:
#include "internalPoints.hpp" #include "internalPoints.hpp"
#include "Field.hpp" #include "Field.hpp"
#include "observer.hpp" #include "observer.hpp"
#include "dataIO.hpp"
namespace pFlow namespace pFlow
{ {
template<template<class, class> class VectorField, class T, class MemorySpace=void> template<class T, class MemorySpace=void>
class internalField class internalField
: :
public observer public observer
{ {
public: 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; using VectorType = typename FieldType::VectorType;
@ -81,7 +86,7 @@ public:
return field_.hostVector(); return field_.hostVector();
} }
hostViewType1D<T> activeValuesHost()const; FieldTypeHost activeValuesHost()const;
inline inline
auto size()const auto size()const
@ -131,12 +136,12 @@ public:
}; };
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
inline inline
iOstream& operator<< iOstream& operator<<
( (
iOstream& os, iOstream& os,
const internalField<VectorField, T, MemorySpace>& ifeild const internalField<T, MemorySpace>& ifeild
) )
{ {
if( !ifeild.write(os, IOPattern::AllProcessorsDifferent) ) if( !ifeild.write(os, IOPattern::AllProcessorsDifferent) )

87
src/phasicFlow/containers/pointField/pointField.cpp
View File

@ -1,3 +1,4 @@
#include "pointField.hpp"
/*------------------------------- phasicFlow --------------------------------- /*------------------------------- phasicFlow ---------------------------------
O C enter of O C enter of
O O E ngineering and O O E ngineering and
@ -18,8 +19,8 @@ Licence:
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::pointField<VectorField, T, MemorySpace>::pointField pFlow::pointField<T, MemorySpace>::pointField
( (
const objectFile& objf, const objectFile& objf,
pointStructure& pStruct, pointStructure& pStruct,
@ -44,8 +45,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
} }
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::pointField<VectorField, T, MemorySpace>::pointField pFlow::pointField<T, MemorySpace>::pointField
( (
const objectFile &objf, const objectFile &objf,
pointStructure &pStruct, pointStructure &pStruct,
@ -81,8 +82,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::pointField<VectorField, T, MemorySpace>::pointField pFlow::pointField<T, MemorySpace>::pointField
( (
const pointStructure& pStruct, const pointStructure& pStruct,
const T& defVal, const T& defVal,
@ -98,8 +99,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
this->fill(defVal); this->fill(defVal);
} }
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::pointField<VectorField, T, MemorySpace>::pointField pFlow::pointField<T, MemorySpace>::pointField
( (
const pointStructure& pStruct, const pointStructure& pStruct,
const T& val, const T& val,
@ -115,8 +116,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
this->fill(val); this->fill(val);
} }
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::pointField<VectorField, T, MemorySpace>::pointField pFlow::pointField<T, MemorySpace>::pointField
( (
const pointField& src, const pointField& src,
bool subscribe bool subscribe
@ -128,15 +129,15 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
defaultValue_(src.defaultValue_) defaultValue_(src.defaultValue_)
{} {}
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
pFlow::pointField<VectorField, T, MemorySpace>::pointField(const pointField& src) 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> template<class T, class MemorySpace>
pFlow::pointField<VectorField, T, MemorySpace>& pFlow::pointField<VectorField, T, MemorySpace>::operator = pFlow::pointField<T, MemorySpace>& pFlow::pointField<T, MemorySpace>::operator =
( (
const pointField& rhs const pointField& rhs
) )
@ -148,8 +149,8 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
} }
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
bool pFlow::pointField<VectorField, T, MemorySpace>::update(const eventMessage& msg) bool pFlow::pointField<T, MemorySpace>::update(const eventMessage& msg)
{ {
if( msg.isDeleted() ) if( msg.isDeleted() )
@ -173,14 +174,19 @@ pFlow::pointField<VectorField, T, MemorySpace>::pointField
return true; return true;
}*/ }*/
template <template <class, class> class VectorField, class T, class MemorySpace> template <class T, class MemorySpace>
bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField( bool pFlow::pointField<T, MemorySpace>::readPointField
(
iIstream &is, iIstream &is,
const IOPattern &iop) const IOPattern &iop
)
{ {
Field<Vector, T , vecAllocator<T>> typename InternalFieldType::FieldTypeHost fRead
fRead("file_read"+InternalFieldType::name(), InternalFieldType::fieldKey()); (
InternalFieldType::name(),
InternalFieldType::fieldKey()
);
if( !fRead.read(is, iop)) if( !fRead.read(is, iop))
{ {
fatalErrorInFunction<< fatalErrorInFunction<<
@ -190,10 +196,10 @@ bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField(
auto thisN = pStruct_.simDomain().initialNumberInThis(); auto thisN = pStruct_.simDomain().initialNumberInThis();
Field<Vector, T , vecAllocator<T>> internal typename InternalFieldType::FieldTypeHost internal
( (
"internalField"+InternalFieldType::name(), InternalFieldType::name(),
InternalFieldType::fieldKey(), InternalFieldType::fieldKey(),
thisN, thisN,
thisN, thisN,
RESERVE() RESERVE()
@ -215,35 +221,12 @@ bool pFlow::pointField<VectorField, T, MemorySpace>::readPointField(
return true; return true;
} }
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
bool pFlow::pointField<VectorField, T, MemorySpace>::writePointField bool pFlow::pointField<T, MemorySpace>::writePointField
( (
iOstream& os, iOstream& os,
const IOPattern& iop const IOPattern& iop
)const )const
{ {
return InternalFieldType::write(os, iop);
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;
} }

17
src/phasicFlow/containers/pointField/pointField.hpp
View File

@ -26,25 +26,26 @@ Licence:
#include "internalField.hpp" #include "internalField.hpp"
#include "boundaryFieldList.hpp" #include "boundaryFieldList.hpp"
namespace pFlow namespace pFlow
{ {
template<template<class, class> class VectorField, class T, class MemorySpace=void> template<class T, class MemorySpace=void>
class pointField class pointField
: :
public IOobject, public IOobject,
public internalField<VectorField, T, MemorySpace> public internalField<T, MemorySpace>
{ {
public: 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 FieldType = typename InternalFieldType::FieldType;
using boundaryFieldListType = boundaryFieldList<VectorField, T, MemorySpace>;
using VectorType = typename InternalFieldType::VectorType; using VectorType = typename InternalFieldType::VectorType;
using memory_space = typename InternalFieldType::memory_space; using memory_space = typename InternalFieldType::memory_space;
@ -187,8 +188,8 @@ iIstream& operator >> (iIstream & is, pointField<VectorField, T, MemorySpace> &
return is; return is;
}*/ }*/
template<template<class, class> class VectorField, class T, class MemorySpace> template<class T, class MemorySpace>
iOstream& operator << (iOstream& os, const pointField<VectorField, T, MemorySpace>& pF ) iOstream& operator << (iOstream& os, const pointField<T, MemorySpace>& pF )
{ {
if(! pF.write(os, IOPattern::AllProcessorsDifferent) ) if(! pF.write(os, IOPattern::AllProcessorsDifferent) )
{ {

24
src/phasicFlow/containers/pointField/pointFields.cpp
View File

@ -23,22 +23,22 @@ Licence:
#include "createBoundaryFields.hpp" #include "createBoundaryFields.hpp"
template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>; template class pFlow::pointField<pFlow::int8, pFlow::HostSpace>;
createBaseBoundary(pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace); createBaseBoundary(pFlow::int8, pFlow::HostSpace);
createBoundary(pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace, exit); createBoundary(pFlow::int8, pFlow::HostSpace, exit);
template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8>; template class pFlow::pointField<pFlow::int8>;
createBaseBoundary(pFlow::VectorSingle, pFlow::int8, void); createBaseBoundary(pFlow::int8, void);
createBoundary(pFlow::VectorSingle, pFlow::int8, void, exit); createBoundary(pFlow::int8, void, exit);
template class pFlow::pointField<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>; template class pFlow::pointField<pFlow::real, pFlow::HostSpace>;
createBaseBoundary(pFlow::VectorSingle, pFlow::real, pFlow::HostSpace); createBaseBoundary(pFlow::real, pFlow::HostSpace);
createBoundary(pFlow::VectorSingle, pFlow::real, pFlow::HostSpace, exit); createBoundary(pFlow::real, pFlow::HostSpace, exit);
template class pFlow::pointField<pFlow::VectorSingle, pFlow::real>; template class pFlow::pointField<pFlow::real>;
createBaseBoundary(pFlow::VectorSingle, pFlow::real, void); createBaseBoundary(pFlow::real, void);
createBoundary(pFlow::VectorSingle, pFlow::real, void, exit); createBoundary(pFlow::real, void, exit);
/*template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>; /*template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>;

12
src/phasicFlow/containers/pointField/pointFields.hpp
View File

@ -30,19 +30,19 @@ namespace pFlow
{ {
template<typename T> template<typename T>
using pointField_H = pointField<VectorSingle, T, HostSpace>; using pointField_H = pointField<T, HostSpace>;
template<typename T> 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>; //using int32PointField_D = pointField<VectorSingle, int32>;