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/Field/Fields.cpp
containers/List/anyList/anyList.cpp
#containers/pointField/pointFields.cpp
containers/pointField/pointFields.cpp
#setFieldList/setFieldList.cpp
#setFieldList/setFieldEntry.cpp
@ -112,6 +112,7 @@ if(pFlow_Build_MPI)
MPIParallelization/procCommunication.cpp
MPIParallelization/boundaryProcessor.cpp
MPIParallelization/scatteredMasterDistributeChar.cpp
MPIParallelization/processorBoundaryFields.cpp
)
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>
pFlow::boundaryField<VectorField, T, MemorySpace>::boundaryField
template<class T, class MemorySpace>
pFlow::boundaryField<T, MemorySpace>::boundaryField
(
const boundaryBase& boundary,
InternalFieldType& internal
@ -31,9 +31,9 @@ pFlow::boundaryField<VectorField, T, MemorySpace>::boundaryField
{}
template<template<class, class> class VectorField, class T, class MemorySpace>
pFlow::uniquePtr<pFlow::boundaryField<VectorField, T, MemorySpace>>
pFlow::boundaryField<VectorField, T, MemorySpace>::create
template<class T, class MemorySpace>
pFlow::uniquePtr<pFlow::boundaryField<T, MemorySpace>>
pFlow::boundaryField<T, MemorySpace>::create
(
const boundaryBase& boundary,
InternalFieldType& internal

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

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

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

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

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

@ -24,12 +24,12 @@ Licence:
#include "boundaryField.hpp"
#include "exitBoundaryField.hpp"
#define createBaseBoundary(VectorFieldType, DataType, MemorySpaceType) \
template class pFlow::boundaryField<VectorFieldType, DataType, MemorySpaceType>;
#define createBaseBoundary(DataType, MemorySpaceType) \
template class pFlow::boundaryField<DataType, MemorySpaceType>;
#define createBoundary(VectorFieldType, DataType, MemorySpaceType, BoundaryType) \
template class pFlow::BoundaryType##BoundaryField<VectorFieldType, DataType, MemorySpaceType>;
#define createBoundary(DataType, MemorySpaceType, BoundaryType) \
template class pFlow::BoundaryType##BoundaryField<DataType, MemorySpaceType>;
#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>
pFlow::exitBoundaryField<VectorField, T, MemorySpace>::exitBoundaryField
template<class T, class MemorySpace>
pFlow::exitBoundaryField<T, MemorySpace>::exitBoundaryField
(
const boundaryBase& boundary,
InternalFieldType& internal

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

@ -25,16 +25,16 @@ Licence:
namespace pFlow
{
template< template<class, class> class VectorField, class T, class MemorySpace = void>
template< class T, class MemorySpace = void>
class exitBoundaryField
:
public boundaryField<VectorField, T, MemorySpace>
public boundaryField<T, MemorySpace>
{
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;
@ -51,8 +51,7 @@ public:
exitBoundaryField(
const boundaryBase& boundary,
InternalFieldType& internal);
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>
pFlow::internalField<VectorField, T, MemorySpace>::internalField
template<class T, class MemorySpace>
pFlow::internalField<T, MemorySpace>::internalField
(
const word& name,
const internalPoints& internal
@ -41,8 +41,8 @@ pFlow::internalField<VectorField, T, MemorySpace>::internalField
internalPoints_(internal)
{}
template<template<class, class> class VectorField, class T, class MemorySpace>
pFlow::internalField<VectorField, T, MemorySpace>::internalField
template<class T, class MemorySpace>
pFlow::internalField<T, MemorySpace>::internalField
(
const word &name,
const internalPoints &internal,
@ -68,14 +68,22 @@ pFlow::internalField<VectorField, T, MemorySpace>::internalField
}
template <template <class, class> class VectorField, class T, class MemorySpace>
pFlow::hostViewType1D<T>
pFlow::internalField<VectorField, T, MemorySpace>::activeValuesHost() const
template <class T, class MemorySpace>
typename pFlow::internalField<T, MemorySpace>::FieldTypeHost
pFlow::internalField<T, MemorySpace>::activeValuesHost() const
{
auto maskH = internalPoints_.activePointsMaskHost();
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();
uint32 n = 0;
@ -87,12 +95,11 @@ pFlow::internalField<VectorField, T, MemorySpace>::activeValuesHost() const
n++;
}
}
return aField;
}
template<template<class, class> class VectorField, class T, class MemorySpace>
bool pFlow::internalField<VectorField, T, MemorySpace>::write
template<class T, class MemorySpace>
bool pFlow::internalField<T, MemorySpace>::write
(
iOstream& os,
const IOPattern& iop
@ -104,9 +111,7 @@ bool pFlow::internalField<VectorField, T, MemorySpace>::write
}
else
{
auto aValues = activeValuesHost();
auto spanValues = makeSpan(aValues);
return writeSpan(os, spanValues, iop);
auto aField = activeValuesHost();
return aField.write(os, iop);
}
}
}

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

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

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

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

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

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

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

@ -23,22 +23,22 @@ Licence:
#include "createBoundaryFields.hpp"
template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace>;
createBaseBoundary(pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace);
createBoundary(pFlow::VectorSingle, pFlow::int8, pFlow::HostSpace, exit);
template class pFlow::pointField<pFlow::int8, pFlow::HostSpace>;
createBaseBoundary(pFlow::int8, pFlow::HostSpace);
createBoundary(pFlow::int8, pFlow::HostSpace, exit);
template class pFlow::pointField<pFlow::VectorSingle, pFlow::int8>;
createBaseBoundary(pFlow::VectorSingle, pFlow::int8, void);
createBoundary(pFlow::VectorSingle, pFlow::int8, void, exit);
template class pFlow::pointField<pFlow::int8>;
createBaseBoundary(pFlow::int8, void);
createBoundary(pFlow::int8, void, exit);
template class pFlow::pointField<pFlow::VectorSingle, pFlow::real, pFlow::HostSpace>;
createBaseBoundary(pFlow::VectorSingle, pFlow::real, pFlow::HostSpace);
createBoundary(pFlow::VectorSingle, pFlow::real, pFlow::HostSpace, exit);
template class pFlow::pointField<pFlow::real, pFlow::HostSpace>;
createBaseBoundary(pFlow::real, pFlow::HostSpace);
createBoundary(pFlow::real, pFlow::HostSpace, exit);
template class pFlow::pointField<pFlow::VectorSingle, pFlow::real>;
createBaseBoundary(pFlow::VectorSingle, pFlow::real, void);
createBoundary(pFlow::VectorSingle, pFlow::real, void, exit);
template class pFlow::pointField<pFlow::real>;
createBaseBoundary(pFlow::real, void);
createBoundary(pFlow::real, void, exit);
/*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>
using pointField_H = pointField<VectorSingle, T, HostSpace>;
using pointField_H = pointField<T, HostSpace>;
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>;