zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

scheduled or non-blocking polyMesh initialisation

Browse Source
This commit is contained in:
mattijs
2009-11-23 12:44:46 +00:00
parent de97ff23b9
commit 5bb620de10
25 changed files with 479 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.C
View File

@ -28,6 +28,9 @@ License
#include "polyBoundaryMesh.H"
#include "facePointPatch.H"
#include "globalPointPatch.H"
#include "PstreamBuffers.H"
#include "lduSchedule.H"
#include "globalMeshData.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -57,15 +60,47 @@ Foam::pointBoundaryMesh::pointBoundaryMesh
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::pointBoundaryMesh::calcGeometry()
{
PstreamBuffers pBufs(Pstream::defaultCommsType);
if
(
Pstream::defaultCommsType == Pstream::blocking
|| Pstream::defaultCommsType == Pstream::nonBlocking
)
{
forAll(*this, patchi)
{
operator[](patchi).initGeometry();
operator[](patchi).initGeometry(pBufs);
}
pBufs.finishedSends();
forAll(*this, patchi)
{
operator[](patchi).calcGeometry();
operator[](patchi).calcGeometry(pBufs);
}
}
else if (Pstream::defaultCommsType == Pstream::scheduled)
{
const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
// Dummy.
pBufs.finishedSends();
forAll(patchSchedule, patchEvali)
{
label patchi = patchSchedule[patchEvali].patch;
if (patchSchedule[patchEvali].init)
{
operator[](patchi).initGeometry(pBufs);
}
else
{
operator[](patchi).calcGeometry(pBufs);
}
}
}
}
@ -97,32 +132,92 @@ Foam::pointBoundaryMesh::globalPatch() const
void Foam::pointBoundaryMesh::movePoints(const pointField& p)
{
pointPatchList& patches = *this;
PstreamBuffers pBufs(Pstream::defaultCommsType);
forAll(patches, patchi)
if
(
Pstream::defaultCommsType == Pstream::blocking
|| Pstream::defaultCommsType == Pstream::nonBlocking
)
{
patches[patchi].initMovePoints(p);
forAll(*this, patchi)
{
operator[](patchi).initMovePoints(pBufs, p);
}
forAll(patches, patchi)
pBufs.finishedSends();
forAll(*this, patchi)
{
patches[patchi].movePoints(p);
operator[](patchi).movePoints(pBufs, p);
}
}
else if (Pstream::defaultCommsType == Pstream::scheduled)
{
const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
// Dummy.
pBufs.finishedSends();
forAll(patchSchedule, patchEvali)
{
label patchi = patchSchedule[patchEvali].patch;
if (patchSchedule[patchEvali].init)
{
operator[](patchi).initMovePoints(pBufs, p);
}
else
{
operator[](patchi).movePoints(pBufs, p);
}
}
}
}
void Foam::pointBoundaryMesh::updateMesh()
{
pointPatchList& patches = *this;
PstreamBuffers pBufs(Pstream::defaultCommsType);
forAll(patches, patchi)
if
(
Pstream::defaultCommsType == Pstream::blocking
|| Pstream::defaultCommsType == Pstream::nonBlocking
)
{
patches[patchi].initUpdateMesh();
forAll(*this, patchi)
{
operator[](patchi).initUpdateMesh(pBufs);
}
forAll(patches, patchi)
pBufs.finishedSends();
forAll(*this, patchi)
{
patches[patchi].updateMesh();
operator[](patchi).updateMesh(pBufs);
}
}
else if (Pstream::defaultCommsType == Pstream::scheduled)
{
const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
// Dummy.
pBufs.finishedSends();
forAll(patchSchedule, patchEvali)
{
label patchi = patchSchedule[patchEvali].patch;
if (patchSchedule[patchEvali].init)
{
operator[](patchi).initUpdateMesh(pBufs);
}
else
{
operator[](patchi).updateMesh(pBufs);
}
}
}
}

12
src/OpenFOAM/meshes/pointMesh/pointPatches/basic/coupled/coupledPointPatch.H
View File

@ -66,22 +66,22 @@ protected:
// Protected Member Functions
//- Initialise the calculation of the patch geometry
virtual void initGeometry() = 0;
virtual void initGeometry(PstreamBuffers&) = 0;
//- Calculate the patch geometry
virtual void calcGeometry() = 0;
virtual void calcGeometry(PstreamBuffers&) = 0;
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&) = 0;
virtual void initMovePoints(PstreamBuffers&, const pointField&) = 0;
//- Correct patches after moving points
virtual void movePoints(const pointField&) = 0;
virtual void movePoints(PstreamBuffers&, const pointField&) = 0;
//- Initialise the update of the patch topology
virtual void initUpdateMesh() = 0;
virtual void initUpdateMesh(PstreamBuffers&) = 0;
//- Update of the patch topology
virtual void updateMesh() = 0;
virtual void updateMesh(PstreamBuffers&) = 0;
public:

32
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.C
View File

@ -50,13 +50,13 @@ addToRunTimeSelectionTable
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
void Foam::cyclicPointPatch::initGeometry()
void Foam::cyclicPointPatch::initGeometry(PstreamBuffers&)
{
transformPairs_.setSize(0);
}
void Foam::cyclicPointPatch::calcGeometry()
void Foam::cyclicPointPatch::calcGeometry(PstreamBuffers&)
{
const edgeList& cp = cyclicPolyPatch_.coupledPoints();
const labelList& mp = cyclicPolyPatch_.meshPoints();
@ -128,16 +128,20 @@ void Foam::cyclicPointPatch::calcGeometry()
}
else if (pointMap[cp[i][0]] == -1 && pointMap[cp[i][1]] != -1)
{
FatalErrorIn("cyclicPointPatch::calcGeometry() const")
<< "Point " << cp[i][0] << "of point-pair " << i
FatalErrorIn
(
"cyclicPointPatch::calcGeometry(PstreamBuffers&) const"
) << "Point " << cp[i][0] << "of point-pair " << i
<< " is a global point but the other point "
<< cp[i][1] << " is not"
<< exit(FatalError);
}
else if (pointMap[cp[i][0]] != -1 && pointMap[cp[i][1]] == -1)
{
FatalErrorIn("cyclicPointPatch::calcGeometry() const")
<< "Point " << cp[i][1] << "of point-pair " << i
FatalErrorIn
(
"cyclicPointPatch::calcGeometry(PstreamBuffers&) const"
) << "Point " << cp[i][1] << "of point-pair " << i
<< " is a global point but the other point "
<< cp[i][0] << " is not"
<< exit(FatalError);
@ -149,25 +153,25 @@ void Foam::cyclicPointPatch::calcGeometry()
}
void cyclicPointPatch::initMovePoints(const pointField&)
void cyclicPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
{}
void cyclicPointPatch::movePoints(const pointField&)
void cyclicPointPatch::movePoints(PstreamBuffers&, const pointField&)
{}
void cyclicPointPatch::initUpdateMesh()
void cyclicPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
facePointPatch::initUpdateMesh();
cyclicPointPatch::initGeometry();
facePointPatch::initUpdateMesh(pBufs);
cyclicPointPatch::initGeometry(pBufs);
}
void cyclicPointPatch::updateMesh()
void cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
{
facePointPatch::updateMesh();
cyclicPointPatch::calcGeometry();
facePointPatch::updateMesh(pBufs);
cyclicPointPatch::calcGeometry(pBufs);
}

12
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.H
View File

@ -74,22 +74,22 @@ class cyclicPointPatch
edgeList transformPairs_;
//- Initialise the calculation of the patch geometry
virtual void initGeometry();
virtual void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
virtual void calcGeometry();
virtual void calcGeometry(PstreamBuffers&);
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&);
virtual void initMovePoints(PstreamBuffers&, const pointField&);
//- Correct patches after moving points
virtual void movePoints(const pointField&);
virtual void movePoints(PstreamBuffers&, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh();
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
public:

38
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.C
View File

@ -52,7 +52,7 @@ addToRunTimeSelectionTable
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
void Foam::processorPointPatch::initGeometry()
void Foam::processorPointPatch::initGeometry(PstreamBuffers& pBufs)
{
// Algorithm:
// Depending on whether the patch is a master or a slave, get the primitive
@ -84,16 +84,16 @@ void Foam::processorPointPatch::initGeometry()
if (Pstream::parRun())
{
initPatchPatchPoints();
initPatchPatchPoints(pBufs);
}
}
void Foam::processorPointPatch::calcGeometry()
void Foam::processorPointPatch::calcGeometry(PstreamBuffers& pBufs)
{
if (Pstream::parRun())
{
calcPatchPatchPoints();
calcPatchPatchPoints(pBufs);
}
// If it is not runing parallel or there are no global points
@ -149,11 +149,11 @@ void Foam::processorPointPatch::calcGeometry()
}
void processorPointPatch::initPatchPatchPoints()
void processorPointPatch::initPatchPatchPoints(PstreamBuffers& pBufs)
{
if (debug)
{
Info<< "processorPointPatch::calcPatchPatchPoints() : "
Info<< "processorPointPatch::initPatchPatchPoints(PstreamBuffers&) : "
<< "constructing patch-patch points"
<< endl;
}
@ -229,7 +229,7 @@ void processorPointPatch::initPatchPatchPoints()
// Send the patchPatchPoints to the neighbouring processor
OPstream toNeighbProc(Pstream::blocking, neighbProcNo());
UOPstream toNeighbProc(neighbProcNo(), pBufs);
toNeighbProc
<< ppmp.size() // number of points for checking
@ -238,17 +238,17 @@ void processorPointPatch::initPatchPatchPoints()
if (debug)
{
Info<< "processorPointPatch::calcPatchPatchPoints() : "
Info<< "processorPointPatch::initPatchPatchPoints() : "
<< "constructed patch-patch points"
<< endl;
}
}
void Foam::processorPointPatch::calcPatchPatchPoints()
void Foam::processorPointPatch::calcPatchPatchPoints(PstreamBuffers& pBufs)
{
// Get the patchPatchPoints from the neighbouring processor
IPstream fromNeighbProc(Pstream::blocking, neighbProcNo());
UIPstream fromNeighbProc(neighbProcNo(), pBufs);
label nbrNPoints(readLabel(fromNeighbProc));
labelListList patchPatchPoints(fromNeighbProc);
@ -265,7 +265,7 @@ void Foam::processorPointPatch::calcPatchPatchPoints()
// separate.
if (nbrNPoints != ppmp.size())
{
WarningIn("processorPointPatch::calcPatchPatchPoints()")
WarningIn("processorPointPatch::calcPatchPatchPoints(PstreamBuffers&)")
<< "Processor patch " << name()
<< " has " << ppmp.size() << " points; coupled patch has "
<< nbrNPoints << " points." << endl
@ -352,25 +352,25 @@ void Foam::processorPointPatch::calcPatchPatchPoints()
}
void processorPointPatch::initMovePoints(const pointField&)
void processorPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
{}
void processorPointPatch::movePoints(const pointField&)
void processorPointPatch::movePoints(PstreamBuffers&, const pointField&)
{}
void processorPointPatch::initUpdateMesh()
void processorPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
facePointPatch::initUpdateMesh();
processorPointPatch::initGeometry();
facePointPatch::initUpdateMesh(pBufs);
processorPointPatch::initGeometry(pBufs);
}
void processorPointPatch::updateMesh()
void processorPointPatch::updateMesh(PstreamBuffers& pBufs)
{
facePointPatch::updateMesh();
processorPointPatch::calcGeometry();
facePointPatch::updateMesh(pBufs);
processorPointPatch::calcGeometry(pBufs);
}

16
src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H
View File

@ -68,30 +68,30 @@ class processorPointPatch
// Private Member Functions
//- Initialise the calculation of the patch geometry
virtual void initGeometry();
virtual void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
virtual void calcGeometry();
virtual void calcGeometry(PstreamBuffers&);
//- Initialise the points on this patch which are should also be
// on a neighbouring patch but are not part of faces of that patch
void initPatchPatchPoints();
void initPatchPatchPoints(PstreamBuffers&);
//- Calculate the points on this patch which are should also be
// on a neighbouring patch but are not part of faces of that patch
void calcPatchPatchPoints();
void calcPatchPatchPoints(PstreamBuffers&);
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&);
virtual void initMovePoints(PstreamBuffers&, const pointField&);
//- Correct patches after moving points
virtual void movePoints(const pointField&);
virtual void movePoints(PstreamBuffers&, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh();
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
//- Disallow default construct as copy

2
src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.H
View File

@ -86,7 +86,7 @@ protected:
// Construction of demand-driven data
//- Calculate mesh points
virtual void calcGeometry() = 0;
virtual void calcGeometry(PstreamBuffers&) = 0;
public:

12
src/OpenFOAM/meshes/pointMesh/pointPatches/derived/global/globalPointPatch.H
View File

@ -67,27 +67,27 @@ class globalPointPatch
// Protected Member Functions
//- Initialise the calculation of the patch geometry
virtual void initGeometry()
virtual void initGeometry(PstreamBuffers&)
{}
//- Calculate the patch geometry
virtual void calcGeometry()
virtual void calcGeometry(PstreamBuffers&)
{}
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&)
virtual void initMovePoints(PstreamBuffers&, const pointField&)
{}
//- Correct patches after moving points
virtual void movePoints(const pointField&)
virtual void movePoints(PstreamBuffers&, const pointField&)
{}
//- Initialise the update of the patch topology
virtual void initUpdateMesh()
virtual void initUpdateMesh(PstreamBuffers&)
{}
//- Update of the patch topology
virtual void updateMesh()
virtual void updateMesh(PstreamBuffers&)
{}

14
src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.C
View File

@ -51,7 +51,7 @@ addToRunTimeSelectionTable
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
void facePointPatch::initGeometry()
void facePointPatch::initGeometry(PstreamBuffers&)
{
meshPoints_.setSize(0);
localPoints_.setSize(0);
@ -59,25 +59,25 @@ void facePointPatch::initGeometry()
}
void facePointPatch::calcGeometry()
void facePointPatch::calcGeometry(PstreamBuffers&)
{}
void facePointPatch::initMovePoints(const pointField&)
void facePointPatch::initMovePoints(PstreamBuffers&, const pointField&)
{}
void facePointPatch::movePoints(const pointField&)
void facePointPatch::movePoints(PstreamBuffers&, const pointField&)
{}
void facePointPatch::initUpdateMesh()
void facePointPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
facePointPatch::initGeometry();
facePointPatch::initGeometry(pBufs);
}
void facePointPatch::updateMesh()
void facePointPatch::updateMesh(PstreamBuffers&)
{}

12
src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.H
View File

@ -76,22 +76,22 @@ protected:
// Protected Member Functions
//- Initialise the calculation of the patch geometry
virtual void initGeometry();
virtual void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
virtual void calcGeometry();
virtual void calcGeometry(PstreamBuffers&);
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&);
virtual void initMovePoints(PstreamBuffers&, const pointField&);
//- Correct patches after moving points
virtual void movePoints(const pointField&);
virtual void movePoints(PstreamBuffers&, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh();
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
private:

13
src/OpenFOAM/meshes/pointMesh/pointPatches/pointPatch/pointPatch.H
View File

@ -49,6 +49,7 @@ namespace Foam
class pointBoundaryMesh;
class pointConstraint;
class PstreamBuffers;
/*---------------------------------------------------------------------------*\
Class pointPatch Declaration
@ -79,27 +80,27 @@ protected:
friend class pointBoundaryMesh;
//- Initialise the calculation of the patch geometry
virtual void initGeometry()
virtual void initGeometry(PstreamBuffers&)
{}
//- Calculate the patch geometry
virtual void calcGeometry()
virtual void calcGeometry(PstreamBuffers&)
{}
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&)
virtual void initMovePoints(PstreamBuffers&, const pointField&)
{}
//- Correct patches after moving points
virtual void movePoints(const pointField&)
virtual void movePoints(PstreamBuffers&, const pointField&)
{}
//- Initialise the update of the patch topology
virtual void initUpdateMesh()
virtual void initUpdateMesh(PstreamBuffers&)
{}
//- Update of the patch topology
virtual void updateMesh()
virtual void updateMesh(PstreamBuffers&)
{}

119
src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C
View File

@ -29,6 +29,9 @@ License
#include "primitiveMesh.H"
#include "processorPolyPatch.H"
#include "stringListOps.H"
#include "PstreamBuffers.H"
#include "lduSchedule.H"
#include "globalMeshData.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -143,15 +146,47 @@ void Foam::polyBoundaryMesh::clearAddressing()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::polyBoundaryMesh::calcGeometry()
{
PstreamBuffers pBufs(Pstream::defaultCommsType);
if
(
Pstream::defaultCommsType == Pstream::blocking
|| Pstream::defaultCommsType == Pstream::nonBlocking
)
{
forAll(*this, patchi)
{
operator[](patchi).initGeometry();
operator[](patchi).initGeometry(pBufs);
}
pBufs.finishedSends();
forAll(*this, patchi)
{
operator[](patchi).calcGeometry();
operator[](patchi).calcGeometry(pBufs);
}
}
else if (Pstream::defaultCommsType == Pstream::scheduled)
{
const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
// Dummy.
pBufs.finishedSends();
forAll(patchSchedule, patchEvali)
{
label patchi = patchSchedule[patchEvali].patch;
if (patchSchedule[patchEvali].init)
{
operator[](patchi).initGeometry(pBufs);
}
else
{
operator[](patchi).calcGeometry(pBufs);
}
}
}
}
@ -573,16 +608,46 @@ bool Foam::polyBoundaryMesh::checkDefinition(const bool report) const
void Foam::polyBoundaryMesh::movePoints(const pointField& p)
{
polyPatchList& patches = *this;
PstreamBuffers pBufs(Pstream::defaultCommsType);
forAll(patches, patchi)
if
(
Pstream::defaultCommsType == Pstream::blocking
|| Pstream::defaultCommsType == Pstream::nonBlocking
)
{
patches[patchi].initMovePoints(p);
forAll(*this, patchi)
{
operator[](patchi).initMovePoints(pBufs, p);
}
forAll(patches, patchi)
pBufs.finishedSends();
forAll(*this, patchi)
{
patches[patchi].movePoints(p);
operator[](patchi).movePoints(pBufs, p);
}
}
else if (Pstream::defaultCommsType == Pstream::scheduled)
{
const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
// Dummy.
pBufs.finishedSends();
forAll(patchSchedule, patchEvali)
{
label patchi = patchSchedule[patchEvali].patch;
if (patchSchedule[patchEvali].init)
{
operator[](patchi).initMovePoints(pBufs, p);
}
else
{
operator[](patchi).movePoints(pBufs, p);
}
}
}
}
@ -591,16 +656,46 @@ void Foam::polyBoundaryMesh::updateMesh()
{
deleteDemandDrivenData(neighbourEdgesPtr_);
polyPatchList& patches = *this;
PstreamBuffers pBufs(Pstream::defaultCommsType);
forAll(patches, patchi)
if
(
Pstream::defaultCommsType == Pstream::blocking
|| Pstream::defaultCommsType == Pstream::nonBlocking
)
{
patches[patchi].initUpdateMesh();
forAll(*this, patchi)
{
operator[](patchi).initUpdateMesh(pBufs);
}
forAll(patches, patchi)
pBufs.finishedSends();
forAll(*this, patchi)
{
patches[patchi].updateMesh();
operator[](patchi).updateMesh(pBufs);
}
}
else if (Pstream::defaultCommsType == Pstream::scheduled)
{
const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
// Dummy.
pBufs.finishedSends();
forAll(patchSchedule, patchEvali)
{
label patchi = patchSchedule[patchEvali].patch;
if (patchSchedule[patchEvali].init)
{
operator[](patchi).initUpdateMesh(pBufs);
}
else
{
operator[](patchi).updateMesh(pBufs);
}
}
}
}

2
src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.H
View File

@ -50,8 +50,6 @@ class polyMesh;
// Forward declaration of friend functions and operators
class polyBoundaryMesh;
Ostream& operator<<(Ostream&, const polyBoundaryMesh&);

19
src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
View File

@ -90,22 +90,22 @@ protected:
) const;
//- Initialise the calculation of the patch geometry
virtual void initGeometry() = 0;
virtual void initGeometry(PstreamBuffers&) = 0;
//- Calculate the patch geometry
virtual void calcGeometry() = 0;
virtual void calcGeometry(PstreamBuffers&) = 0;
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&) = 0;
virtual void initMovePoints(PstreamBuffers&, const pointField&) = 0;
//- Correct patches after moving points
virtual void movePoints(const pointField&) = 0;
virtual void movePoints(PstreamBuffers&, const pointField&) = 0;
//- Initialise the update of the patch topology
virtual void initUpdateMesh() = 0;
virtual void initUpdateMesh(PstreamBuffers&) = 0;
//- Update of the patch topology
virtual void updateMesh() = 0;
virtual void updateMesh(PstreamBuffers&) = 0;
//- Write point in OBJ format
@ -283,7 +283,11 @@ public:
//- Initialize ordering for primitivePatch. Does not
// refer to *this (except for name() and type() etc.)
virtual void initOrder(const primitivePatch&) const = 0;
virtual void initOrder
(
PstreamBuffers&,
const primitivePatch&
) const = 0;
//- Return new ordering for primitivePatch.
// Ordering is -faceMap: for every face
@ -292,6 +296,7 @@ public:
// (faceMap is identity, rotation is 0), true otherwise.
virtual bool order
(
PstreamBuffers&,
const primitivePatch&,
labelList& faceMap,
labelList& rotation

51
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
View File

@ -516,7 +516,8 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
// if (debug)
// {
// Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
// << "Specified translation : " << separationVector_ << endl;
// << "Specified translation : " << separationVector_
// << endl;
// }
//
// half0Ctrs += separationVector_;
@ -858,36 +859,44 @@ Foam::cyclicPolyPatch::~cyclicPolyPatch()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::cyclicPolyPatch::initGeometry()
void Foam::cyclicPolyPatch::initGeometry(PstreamBuffers& pBufs)
{
polyPatch::initGeometry();
polyPatch::initGeometry(pBufs);
}
void Foam::cyclicPolyPatch::calcGeometry()
void Foam::cyclicPolyPatch::calcGeometry(PstreamBuffers& pBufs)
{
polyPatch::calcGeometry();
polyPatch::calcGeometry(pBufs);
calcTransforms();
}
void Foam::cyclicPolyPatch::initMovePoints(const pointField& p)
void Foam::cyclicPolyPatch::initMovePoints
(
PstreamBuffers& pBufs,
const pointField& p
)
{
polyPatch::initMovePoints(p);
polyPatch::initMovePoints(pBufs, p);
}
void Foam::cyclicPolyPatch::movePoints(const pointField& p)
void Foam::cyclicPolyPatch::movePoints
(
PstreamBuffers& pBufs,
const pointField& p
)
{
polyPatch::movePoints(p);
polyPatch::movePoints(pBufs, p);
calcTransforms();
}
void Foam::cyclicPolyPatch::initUpdateMesh()
void Foam::cyclicPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
polyPatch::initUpdateMesh();
polyPatch::initUpdateMesh(pBufs);
}
void Foam::cyclicPolyPatch::updateMesh()
void Foam::cyclicPolyPatch::updateMesh(PstreamBuffers& pBufs)
{
polyPatch::updateMesh();
polyPatch::updateMesh(pBufs);
deleteDemandDrivenData(coupledPointsPtr_);
deleteDemandDrivenData(coupledEdgesPtr_);
}
@ -1105,7 +1114,11 @@ const Foam::edgeList& Foam::cyclicPolyPatch::coupledEdges() const
}
void Foam::cyclicPolyPatch::initOrder(const primitivePatch& pp) const
void Foam::cyclicPolyPatch::initOrder
(
PstreamBuffers&,
const primitivePatch& pp
) const
{}
@ -1115,6 +1128,7 @@ void Foam::cyclicPolyPatch::initOrder(const primitivePatch& pp) const
// is identity, rotation is 0)
bool Foam::cyclicPolyPatch::order
(
PstreamBuffers& pBufs,
const primitivePatch& pp,
labelList& faceMap,
labelList& rotation
@ -1300,7 +1314,8 @@ bool Foam::cyclicPolyPatch::order
<< endl;
// Recalculate untransformed face centres
//pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
//pointField rawHalf0Ctrs =
// calcFaceCentres(half0Faces, pp.points());
label vertI = 0;
forAll(half1Ctrs, i)
@ -1413,7 +1428,8 @@ bool Foam::cyclicPolyPatch::order
<< endl;
// Recalculate untransformed face centres
//pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
//pointField rawHalf0Ctrs =
// calcFaceCentres(half0Faces, pp.points());
label vertI = 0;
forAll(half1Ctrs, i)
@ -1499,7 +1515,8 @@ bool Foam::cyclicPolyPatch::order
<< endl;
// Recalculate untransformed face centres
//pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
//pointField rawHalf0Ctrs =
// calcFaceCentres(half0Faces, pp.points());
label vertI = 0;
forAll(half1Ctrs, i)

15
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H
View File

@ -176,22 +176,22 @@ protected:
// Protected Member functions
//- Initialise the calculation of the patch geometry
virtual void initGeometry();
virtual void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
virtual void calcGeometry();
virtual void calcGeometry(PstreamBuffers&);
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&);
virtual void initMovePoints(PstreamBuffers&, const pointField&);
//- Correct patches after moving points
virtual void movePoints(const pointField&);
virtual void movePoints(PstreamBuffers&, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh();
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
public:
@ -391,7 +391,7 @@ public:
//- Initialize ordering for primitivePatch. Does not
// refer to *this (except for name() and type() etc.)
virtual void initOrder(const primitivePatch&) const;
virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
//- Return new ordering for primitivePatch.
// Ordering is -faceMap: for every face
@ -400,6 +400,7 @@ public:
// (faceMap is identity, rotation is 0), true otherwise.
virtual bool order
(
PstreamBuffers&,
const primitivePatch&,
labelList& faceMap,
labelList& rotation

68
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
View File

@ -34,6 +34,7 @@ License
#include "polyMesh.H"
#include "Time.H"
#include "transformList.H"
#include "PstreamBuffers.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -155,16 +156,11 @@ Foam::processorPolyPatch::~processorPolyPatch()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::processorPolyPatch::initGeometry()
void Foam::processorPolyPatch::initGeometry(PstreamBuffers& pBufs)
{
if (Pstream::parRun())
{
OPstream toNeighbProc
(
Pstream::blocking,
neighbProcNo(),
3*(sizeof(label) + size()*sizeof(vector) + sizeof(scalar))
);
UOPstream toNeighbProc(neighbProcNo(), pBufs);
toNeighbProc
<< faceCentres()
@ -174,17 +170,13 @@ void Foam::processorPolyPatch::initGeometry()
}
void Foam::processorPolyPatch::calcGeometry()
void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
{
if (Pstream::parRun())
{
{
IPstream fromNeighbProc
(
Pstream::blocking,
neighbProcNo(),
3*(sizeof(label) + size()*sizeof(vector) + sizeof(scalar))
);
UIPstream fromNeighbProc(neighbProcNo(), pBufs);
fromNeighbProc
>> neighbFaceCentres_
>> neighbFaceAreas_
@ -251,22 +243,30 @@ void Foam::processorPolyPatch::calcGeometry()
}
void Foam::processorPolyPatch::initMovePoints(const pointField& p)
void Foam::processorPolyPatch::initMovePoints
(
PstreamBuffers& pBufs,
const pointField& p
)
{
polyPatch::movePoints(p);
processorPolyPatch::initGeometry();
polyPatch::movePoints(pBufs, p);
processorPolyPatch::initGeometry(pBufs);
}
void Foam::processorPolyPatch::movePoints(const pointField&)
void Foam::processorPolyPatch::movePoints
(
PstreamBuffers& pBufs,
const pointField&
)
{
processorPolyPatch::calcGeometry();
processorPolyPatch::calcGeometry(pBufs);
}
void Foam::processorPolyPatch::initUpdateMesh()
void Foam::processorPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
polyPatch::initUpdateMesh();
polyPatch::initUpdateMesh(pBufs);
deleteDemandDrivenData(neighbPointsPtr_);
deleteDemandDrivenData(neighbEdgesPtr_);
@ -303,14 +303,7 @@ void Foam::processorPolyPatch::initUpdateMesh()
edgeIndex[patchEdgeI] = findIndex(fEdges, patchEdgeI);
}
OPstream toNeighbProc
(
Pstream::blocking,
neighbProcNo(),
8*sizeof(label) // four headers of labelList
+ 2*nPoints()*sizeof(label) // two point-based labellists
+ 2*nEdges()*sizeof(label) // two edge-based labelLists
);
UOPstream toNeighbProc(neighbProcNo(), pBufs);
toNeighbProc
<< pointFace
@ -321,10 +314,10 @@ void Foam::processorPolyPatch::initUpdateMesh()
}
void Foam::processorPolyPatch::updateMesh()
void Foam::processorPolyPatch::updateMesh(PstreamBuffers& pBufs)
{
// For completeness
polyPatch::updateMesh();
polyPatch::updateMesh(pBufs);
if (Pstream::parRun())
{
@ -336,7 +329,7 @@ void Foam::processorPolyPatch::updateMesh()
{
// Note cannot predict exact size since opposite nPoints might
// be different from one over here.
IPstream fromNeighbProc(Pstream::blocking, neighbProcNo());
UIPstream fromNeighbProc(neighbProcNo(), pBufs);
fromNeighbProc
>> nbrPointFace
@ -446,7 +439,11 @@ const Foam::labelList& Foam::processorPolyPatch::neighbEdges() const
}
void Foam::processorPolyPatch::initOrder(const primitivePatch& pp) const
void Foam::processorPolyPatch::initOrder
(
PstreamBuffers& pBufs,
const primitivePatch& pp
) const
{
if (!Pstream::parRun())
{
@ -491,7 +488,7 @@ void Foam::processorPolyPatch::initOrder(const primitivePatch& pp) const
pointField anchors(getAnchorPoints(pp, pp.points()));
// Now send all info over to the neighbour
OPstream toNeighbour(Pstream::blocking, neighbProcNo());
UOPstream toNeighbour(neighbProcNo(), pBufs);
toNeighbour << ctrs << anchors;
}
}
@ -503,6 +500,7 @@ void Foam::processorPolyPatch::initOrder(const primitivePatch& pp) const
// is identity, rotation is 0)
bool Foam::processorPolyPatch::order
(
PstreamBuffers& pBufs,
const primitivePatch& pp,
labelList& faceMap,
labelList& rotation
@ -539,7 +537,7 @@ bool Foam::processorPolyPatch::order
// Receive data from neighbour
{
IPstream fromNeighbour(Pstream::blocking, neighbProcNo());
UIPstream fromNeighbour(neighbProcNo(), pBufs);
fromNeighbour >> masterCtrs >> masterAnchors;
}

23
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H
View File

@ -28,11 +28,9 @@ Class
Description
Neighbour processor patch.
Note: morph patch face ordering comes geometric or topological.
Geometric: no cyclics allowed (assumes faces coincident)
Topological: needs unmodified faces on both sides to correspond. Also
needs at least one per connected patch area (so all patch faces can be
visited from an unmodified face)
Note: morph patch face ordering tries to do a geometric ordering.
(assumes faces coincident) Hence will have problems when cyclics
are present.
SourceFiles
processorPolyPatch.C
@ -97,22 +95,22 @@ protected:
// Protected Member functions
//- Initialise the calculation of the patch geometry
void initGeometry();
void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
void calcGeometry();
void calcGeometry(PstreamBuffers&);
//- Initialise the patches for moving points
void initMovePoints(const pointField&);
void initMovePoints(PstreamBuffers&, const pointField&);
//- Correct patches after moving points
void movePoints(const pointField&);
void movePoints(PstreamBuffers&, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh();
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
public:
@ -283,7 +281,7 @@ public:
//- Initialize ordering for primitivePatch. Does not
// refer to *this (except for name() and type() etc.)
virtual void initOrder(const primitivePatch&) const;
virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
//- Return new ordering for primitivePatch.
// Ordering is -faceMap: for every face
@ -292,6 +290,7 @@ public:
// (faceMap is identity, rotation is 0), true otherwise.
virtual bool order
(
PstreamBuffers&,
const primitivePatch&,
labelList& faceMap,
labelList& rotation

7
src/OpenFOAM/meshes/polyMesh/polyPatches/polyPatch/polyPatch.C
View File

@ -55,12 +55,12 @@ namespace Foam
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
void Foam::polyPatch::movePoints(const pointField& p)
void Foam::polyPatch::movePoints(PstreamBuffers&, const pointField& p)
{
primitivePatch::movePoints(p);
}
void Foam::polyPatch::updateMesh()
void Foam::polyPatch::updateMesh(PstreamBuffers&)
{
clearAddressing();
}
@ -334,12 +334,13 @@ void Foam::polyPatch::write(Ostream& os) const
}
void Foam::polyPatch::initOrder(const primitivePatch&) const
void Foam::polyPatch::initOrder(PstreamBuffers&, const primitivePatch&) const
{}
bool Foam::polyPatch::order
(
PstreamBuffers&,
const primitivePatch&,
labelList& faceMap,
labelList& rotation

16
src/OpenFOAM/meshes/polyMesh/polyPatches/polyPatch/polyPatch.H
View File

@ -56,6 +56,7 @@ namespace Foam
class polyBoundaryMesh;
class polyPatch;
class PstreamBuffers;
Ostream& operator<<(Ostream&, const polyPatch&);
@ -101,26 +102,26 @@ protected:
friend class polyBoundaryMesh;
//- Initialise the calculation of the patch geometry
virtual void initGeometry()
virtual void initGeometry(PstreamBuffers&)
{}
//- Calculate the patch geometry
virtual void calcGeometry()
virtual void calcGeometry(PstreamBuffers&)
{}
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&)
virtual void initMovePoints(PstreamBuffers&, const pointField&)
{}
//- Correct patches after moving points
virtual void movePoints(const pointField& p);
virtual void movePoints(PstreamBuffers&, const pointField& p);
//- Initialise the update of the patch topology
virtual void initUpdateMesh()
virtual void initUpdateMesh(PstreamBuffers&)
{}
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
public:
@ -358,7 +359,7 @@ public:
//- Initialize ordering for primitivePatch. Does not
// refer to *this (except for name() and type() etc.)
virtual void initOrder(const primitivePatch&) const;
virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
//- Return new ordering for primitivePatch.
// Ordering is -faceMap: for every face
@ -367,6 +368,7 @@ public:
// (faceMap is identity, rotation is 0), true otherwise.
virtual bool order
(
PstreamBuffers&,
const primitivePatch&,
labelList& faceMap,
labelList& rotation

6
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C
View File

@ -1844,6 +1844,8 @@ void Foam::polyTopoChange::reorderCoupledFaces
// Rotation on new faces.
labelList rotation(faces_.size(), 0);
PstreamBuffers pBufs(Pstream::nonBlocking);
// Send ordering
forAll(boundary, patchI)
{
@ -1851,6 +1853,7 @@ void Foam::polyTopoChange::reorderCoupledFaces
{
boundary[patchI].initOrder
(
pBufs,
primitivePatch
(
SubList<face>
@ -1865,6 +1868,8 @@ void Foam::polyTopoChange::reorderCoupledFaces
}
}
pBufs.finishedSends();
// Receive and calculate ordering
bool anyChanged = false;
@ -1878,6 +1883,7 @@ void Foam::polyTopoChange::reorderCoupledFaces
bool changed = boundary[patchI].order
(
pBufs,
primitivePatch
(
SubList<face>

35
src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.C
View File

@ -145,44 +145,49 @@ Foam::directMappedPolyPatch::~directMappedPolyPatch()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
//- Initialise the calculation of the patch geometry
void Foam::directMappedPolyPatch::initGeometry()
void Foam::directMappedPolyPatch::initGeometry(PstreamBuffers& pBufs)
{
polyPatch::initGeometry();
directMappedPatchBase::clearOut();
polyPatch::initGeometry(pBufs);
}
//- Calculate the patch geometry
void Foam::directMappedPolyPatch::calcGeometry()
void Foam::directMappedPolyPatch::calcGeometry(PstreamBuffers& pBufs)
{
polyPatch::calcGeometry();
polyPatch::calcGeometry(pBufs);
directMappedPatchBase::clearOut();
}
//- Initialise the patches for moving points
void Foam::directMappedPolyPatch::initMovePoints(const pointField& p)
void Foam::directMappedPolyPatch::initMovePoints
(
PstreamBuffers& pBufs,
const pointField& p
)
{
polyPatch::initMovePoints(p);
directMappedPatchBase::clearOut();
polyPatch::initMovePoints(pBufs, p);
}
//- Correct patches after moving points
void Foam::directMappedPolyPatch::movePoints(const pointField& p)
void Foam::directMappedPolyPatch::movePoints
(
PstreamBuffers& pBufs,
const pointField& p
)
{
polyPatch::movePoints(p);
polyPatch::movePoints(pBufs, p);
directMappedPatchBase::clearOut();
}
//- Initialise the update of the patch topology
void Foam::directMappedPolyPatch::initUpdateMesh()
void Foam::directMappedPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
polyPatch::initUpdateMesh();
directMappedPatchBase::clearOut();
polyPatch::initUpdateMesh(pBufs);
}
//- Update of the patch topology
void Foam::directMappedPolyPatch::updateMesh()
void Foam::directMappedPolyPatch::updateMesh(PstreamBuffers& pBufs)
{
polyPatch::updateMesh();
polyPatch::updateMesh(pBufs);
directMappedPatchBase::clearOut();
}

12
src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.H
View File

@ -65,22 +65,22 @@ class directMappedPolyPatch
protected:
//- Initialise the calculation of the patch geometry
virtual void initGeometry();
virtual void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
virtual void calcGeometry();
virtual void calcGeometry(PstreamBuffers&);
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&);
virtual void initMovePoints(PstreamBuffers&, const pointField&);
//- Correct patches after moving points
virtual void movePoints(const pointField&);
virtual void movePoints(PstreamBuffers&, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh();
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
public:

35
src/meshTools/directMapped/directMappedPolyPatch/directMappedWallPolyPatch.C
View File

@ -150,44 +150,49 @@ Foam::directMappedWallPolyPatch::~directMappedWallPolyPatch()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
//- Initialise the calculation of the patch geometry
void Foam::directMappedWallPolyPatch::initGeometry()
void Foam::directMappedWallPolyPatch::initGeometry(PstreamBuffers& pBufs)
{
wallPolyPatch::initGeometry();
directMappedPatchBase::clearOut();
wallPolyPatch::initGeometry(pBufs);
}
//- Calculate the patch geometry
void Foam::directMappedWallPolyPatch::calcGeometry()
void Foam::directMappedWallPolyPatch::calcGeometry(PstreamBuffers& pBufs)
{
wallPolyPatch::calcGeometry();
wallPolyPatch::calcGeometry(pBufs);
directMappedPatchBase::clearOut();
}
//- Initialise the patches for moving points
void Foam::directMappedWallPolyPatch::initMovePoints(const pointField& p)
void Foam::directMappedWallPolyPatch::initMovePoints
(
PstreamBuffers& pBufs,
const pointField& p
)
{
wallPolyPatch::initMovePoints(p);
directMappedPatchBase::clearOut();
wallPolyPatch::initMovePoints(pBufs, p);
}
//- Correct patches after moving points
void Foam::directMappedWallPolyPatch::movePoints(const pointField& p)
void Foam::directMappedWallPolyPatch::movePoints
(
PstreamBuffers& pBufs,
const pointField& p
)
{
wallPolyPatch::movePoints(p);
wallPolyPatch::movePoints(pBufs, p);
directMappedPatchBase::clearOut();
}
//- Initialise the update of the patch topology
void Foam::directMappedWallPolyPatch::initUpdateMesh()
void Foam::directMappedWallPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
{
wallPolyPatch::initUpdateMesh();
directMappedPatchBase::clearOut();
wallPolyPatch::initUpdateMesh(pBufs);
}
//- Update of the patch topology
void Foam::directMappedWallPolyPatch::updateMesh()
void Foam::directMappedWallPolyPatch::updateMesh(PstreamBuffers& pBufs)
{
wallPolyPatch::updateMesh();
wallPolyPatch::updateMesh(pBufs);
directMappedPatchBase::clearOut();
}

12
src/meshTools/directMapped/directMappedPolyPatch/directMappedWallPolyPatch.H
View File

@ -65,22 +65,22 @@ class directMappedWallPolyPatch
protected:
//- Initialise the calculation of the patch geometry
virtual void initGeometry();
virtual void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
virtual void calcGeometry();
virtual void calcGeometry(PstreamBuffers&);
//- Initialise the patches for moving points
virtual void initMovePoints(const pointField&);
virtual void initMovePoints(PstreamBuffers&, const pointField&);
//- Correct patches after moving points
virtual void movePoints(const pointField&);
virtual void movePoints(PstreamBuffers&, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh();
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh();
virtual void updateMesh(PstreamBuffers&);
public: