zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MeshZones: Renamed ZoneMesh to MeshZones

Browse Source
This commit is contained in:
Will Bainbridge
2021-07-14 12:24:30 +01:00
parent bf6734ff4e
commit 25d274736f
73 changed files with 453 additions and 450 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
applications/utilities/mesh/advanced/PDRMesh/PDRMesh.C
View File

@ -319,7 +319,7 @@ void createCoupledBaffles
PackedBoolList& modifiedFace
)
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
forAll(coupledWantedPatch, facei)
{
@ -387,7 +387,7 @@ void createCyclicCoupledBaffles
PackedBoolList& modifiedFace
)
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
forAll(cyclicMasterPatch, facei)
{
@ -460,7 +460,7 @@ void createBaffles
polyTopoChange& meshMod
)
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
Info << "faceZone:createBaffle " << faceZones << endl;
forAll(wantedPatch, facei)
{

2
applications/utilities/mesh/conversion/fluentMeshToFoam/README.txt
View File

@ -19,7 +19,7 @@ Notes for fluentMeshToFoam with zone preservation
- Zones are simple lists of label lists that can be accessed from polyMesh
with the cellZones(), faceZones() and pointZones() member functions
- Example (Members from polyMesh.H and ZoneMesh.H):
- Example (Members from polyMesh.H and MeshZones.H):
const labelList& thisCellZone = mesh.cellZones()["thisZoneName"];
- Zone integrity is preserved during mesh modification and decompomposition.

2
applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C
View File

@ -1543,7 +1543,7 @@ int main(int argc, char *argv[])
if (hasZones)
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
meshZoneID.setSize(zoneNames.size());
forAll(zoneNames, i)

2
applications/utilities/mesh/manipulation/mergeBaffles/mergeBaffles.C
View File

@ -90,7 +90,7 @@ void mergeDuplicateBoundaryFaces
const faceList& faces = mesh.faces();
const labelList& faceOwner = mesh.faceOwner();
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
forAll(duplicates, bFacei)
{

8
applications/utilities/mesh/manipulation/mergeMeshes/mergePolyMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -199,7 +199,7 @@ void Foam::mergePolyMesh::addMesh(const polyMesh& m)
const pointField& p = m.points();
labelList renumberPoints(p.size());
const pointZoneMesh& pz = m.pointZones();
const meshPointZones& pz = m.pointZones();
labelList pointZoneIndices(pz.size());
forAll(pz, zoneI)
@ -236,7 +236,7 @@ void Foam::mergePolyMesh::addMesh(const polyMesh& m)
const cellList& c = m.cells();
labelList renumberCells(c.size());
const cellZoneMesh& cz = m.cellZones();
const meshCellZones& cz = m.cellZones();
labelList cellZoneIndices(cz.size());
forAll(cz, zoneI)
@ -286,7 +286,7 @@ void Foam::mergePolyMesh::addMesh(const polyMesh& m)
const faceZoneMesh& fz = m.faceZones();
const meshFaceZones& fz = m.faceZones();
labelList faceZoneIndices(fz.size());
forAll(fz, zoneI)

4
applications/utilities/mesh/manipulation/polyDualMesh/polyDualMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -242,7 +242,7 @@ void simpleMarkFeatures
}
// B. face zones.
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
if (doNotPreserveFaceZones)
{

4
applications/utilities/mesh/manipulation/renumberMesh/renumberMesh.C
View File

@ -461,7 +461,7 @@ autoPtr<mapPolyMesh> reorderMesh
// Re-do the faceZones
{
faceZoneMesh& faceZones = mesh.faceZones();
meshFaceZones& faceZones = mesh.faceZones();
faceZones.clearAddressing();
forAll(faceZones, zoneI)
{
@ -492,7 +492,7 @@ autoPtr<mapPolyMesh> reorderMesh
}
// Re-do the cellZones
{
cellZoneMesh& cellZones = mesh.cellZones();
meshCellZones& cellZones = mesh.cellZones();
cellZones.clearAddressing();
forAll(cellZones, zoneI)
{

14
applications/utilities/mesh/manipulation/setSet/setSet.C
View File

@ -296,7 +296,7 @@ void printAllSets(const polyMesh& mesh, Ostream& os)
}
}
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
if (cellZones.size())
{
os << "cellZones:" << endl;
@ -306,7 +306,7 @@ void printAllSets(const polyMesh& mesh, Ostream& os)
os << '\t' << zone.name() << "\tsize:" << zone.size() << endl;
}
}
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
if (faceZones.size())
{
os << "faceZones:" << endl;
@ -316,7 +316,7 @@ void printAllSets(const polyMesh& mesh, Ostream& os)
os << '\t' << zone.name() << "\tsize:" << zone.size() << endl;
}
}
const pointZoneMesh& pointZones = mesh.pointZones();
const meshPointZones& pointZones = mesh.pointZones();
if (pointZones.size())
{
os << "pointZones:" << endl;
@ -334,7 +334,7 @@ void printAllSets(const polyMesh& mesh, Ostream& os)
template<class ZoneType>
void removeZone
(
ZoneMesh<ZoneType, polyMesh>& zones,
MeshZones<ZoneType, polyMesh>& zones,
const word& setName
)
{
@ -400,7 +400,7 @@ void removeSet
{
removeZone
(
const_cast<cellZoneMesh&>(mesh.cellZones()),
const_cast<meshCellZones&>(mesh.cellZones()),
setName
);
}
@ -408,7 +408,7 @@ void removeSet
{
removeZone
(
const_cast<faceZoneMesh&>(mesh.faceZones()),
const_cast<meshFaceZones&>(mesh.faceZones()),
setName
);
}
@ -416,7 +416,7 @@ void removeSet
{
removeZone
(
const_cast<pointZoneMesh&>(mesh.pointZones()),
const_cast<meshPointZones&>(mesh.pointZones()),
setName
);
}

8
applications/utilities/mesh/manipulation/setsToZones/setsToZones.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -127,7 +127,7 @@ int main(int argc, char *argv[])
set.name(), // name
pointLabels, // addressing
sz, // index
mesh.pointZones() // pointZoneMesh
mesh.pointZones() // meshPointZones
)
);
mesh.pointZones().writeOpt() = IOobject::AUTO_WRITE;
@ -259,7 +259,7 @@ int main(int argc, char *argv[])
addressing.shrink(), // addressing
flipMap.shrink(), // flipmap
sz, // index
mesh.faceZones() // pointZoneMesh
mesh.faceZones() // meshFaceZones
)
);
mesh.faceZones().writeOpt() = IOobject::AUTO_WRITE;
@ -307,7 +307,7 @@ int main(int argc, char *argv[])
set.name(), // name
cellLabels, // addressing
sz, // index
mesh.cellZones() // pointZoneMesh
mesh.cellZones() // meshCellZones
)
);
mesh.cellZones().writeOpt() = IOobject::AUTO_WRITE;

12
applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -1192,7 +1192,7 @@ label findCorrespondingRegion
void getZoneID
(
const polyMesh& mesh,
const cellZoneMesh& cellZones,
const meshCellZones& cellZones,
labelList& zoneID,
labelList& neiZoneID
)
@ -1251,7 +1251,7 @@ void matchRegions
labelList& zoneToRegion
)
{
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
regionToZone.setSize(nCellRegions, -1);
regionNames.setSize(nCellRegions);
@ -1586,7 +1586,7 @@ int main(int argc, char *argv[])
args.optionLookupOrDefault("defaultRegionName", standardRegionName)
);
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
// Existing zoneID
labelList zoneID(mesh.nCells(), -1);
@ -1645,7 +1645,7 @@ int main(int argc, char *argv[])
<< "This requires all"
<< " cells to be in one and only one cellZone." << nl << endl;
cellZoneMesh newCellZones
meshCellZones newCellZones
(
IOobject
(
@ -1939,7 +1939,7 @@ int main(int argc, char *argv[])
zoneName, // name
regionCells, // addressing
zoneI, // index
cellZones // cellZoneMesh
cellZones // meshCellZones
)
);
}

8
applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -86,7 +86,7 @@ label addPointZone(const polyMesh& mesh, const word& name)
}
else
{
pointZoneMesh& pointZones = const_cast<polyMesh&>(mesh).pointZones();
meshPointZones& pointZones = const_cast<polyMesh&>(mesh).pointZones();
zoneID = pointZones.size();
Info<< "Adding pointZone " << name << " at index " << zoneID << endl;
@ -118,7 +118,7 @@ label addFaceZone(const polyMesh& mesh, const word& name)
}
else
{
faceZoneMesh& faceZones = const_cast<polyMesh&>(mesh).faceZones();
meshFaceZones& faceZones = const_cast<polyMesh&>(mesh).faceZones();
zoneID = faceZones.size();
Info<< "Adding faceZone " << name << " at index " << zoneID << endl;
@ -151,7 +151,7 @@ label addCellZone(const polyMesh& mesh, const word& name)
}
else
{
cellZoneMesh& cellZones = const_cast<polyMesh&>(mesh).cellZones();
meshCellZones& cellZones = const_cast<polyMesh&>(mesh).cellZones();
zoneID = cellZones.size();
Info<< "Adding cellZone " << name << " at index " << zoneID << endl;

8
applications/utilities/mesh/manipulation/topoSet/topoSet.C
View File

@ -59,7 +59,7 @@ void printMesh(const Time& runTime, const polyMesh& mesh)
template<class ZoneType>
void removeZone
(
ZoneMesh<ZoneType, polyMesh>& zones,
MeshZones<ZoneType, polyMesh>& zones,
const word& setName
)
{
@ -124,7 +124,7 @@ void removeSet
{
removeZone
(
const_cast<cellZoneMesh&>(mesh.cellZones()),
const_cast<meshCellZones&>(mesh.cellZones()),
setName
);
}
@ -132,7 +132,7 @@ void removeSet
{
removeZone
(
const_cast<faceZoneMesh&>(mesh.faceZones()),
const_cast<meshFaceZones&>(mesh.faceZones()),
setName
);
}
@ -140,7 +140,7 @@ void removeSet
{
removeZone
(
const_cast<pointZoneMesh&>(mesh.pointZones()),
const_cast<meshPointZones&>(mesh.pointZones()),
setName
);
}

4
applications/utilities/miscellaneous/foamFormatConvert/foamFormatConvert.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -89,7 +89,7 @@ bool writeZones(const word& name, const fileName& meshDir, Time& runTime)
bool writeOk = false;
if (io.typeHeaderOk<cellZoneMesh>(false))
if (io.typeHeaderOk<meshCellZones>(false))
{
Info<< " Reading " << io.headerClassName()
<< " : " << name << endl;

8
applications/utilities/parallelProcessing/decomposePar/domainDecomposition.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -512,7 +512,7 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
// Point zones
{
const pointZoneMesh& pz = pointZones();
const meshPointZones& pz = pointZones();
// Go through all the zoned points and find out if they
// belong to a zone. If so, add it to the zone as
@ -578,7 +578,7 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
// Face zones
{
const faceZoneMesh& fz = faceZones();
const meshFaceZones& fz = faceZones();
// Go through all the zoned face and find out if they
// belong to a zone. If so, add it to the zone as
@ -672,7 +672,7 @@ bool Foam::domainDecomposition::writeDecomposition(const bool decomposeSets)
// Cell zones
{
const cellZoneMesh& cz = cellZones();
const meshCellZones& cz = cellZones();
// Go through all the zoned cells and find out if they
// belong to a zone. If so, add it to the zone as

10
applications/utilities/postProcessing/dataConversion/foamToTecplot360/foamToTecplot360.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -1061,18 +1061,18 @@ int main(int argc, char *argv[])
//
//---------------------------------------------------------------------
const faceZoneMesh& zones = mesh.faceZones();
const meshFaceZones& zones = mesh.faceZones();
if (doFaceZones && zones.size() > 0)
{
mkDir(fvPath/"faceZoneMesh");
mkDir(fvPath/"meshFaceZones");
fileName patchFileName;
if (vMesh.useSubMesh())
{
patchFileName =
fvPath/"faceZoneMesh"/cellSetName
fvPath/"meshFaceZones"/cellSetName
+ "_"
+ timeDesc
+ ".plt";
@ -1080,7 +1080,7 @@ int main(int argc, char *argv[])
else
{
patchFileName =
fvPath/"faceZoneMesh"/"faceZoneMesh"
fvPath/"meshFaceZones"/"meshFaceZones"
+ "_"
+ timeDesc
+ ".plt";

4
applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C
View File

@ -143,7 +143,7 @@ Note
#include "sphericalTensorIOField.H"
#include "symmTensorIOField.H"
#include "tensorIOField.H"
#include "faceZoneMesh.H"
#include "meshFaceZones.H"
#include "Cloud.H"
#include "passiveParticle.H"
#include "stringListOps.H"
@ -1067,7 +1067,7 @@ int main(int argc, char *argv[])
);
print(" surfVectorFields :", Info, svf);
const faceZoneMesh& zones = mesh.faceZones();
const meshFaceZones& zones = mesh.faceZones();
forAll(zones, zoneI)
{

24
applications/utilities/postProcessing/graphics/PVReaders/vtkPVFoam/vtkPVFoam.H
View File

@ -295,10 +295,10 @@ class vtkPVFoam
// TODO: regions
List<polyDecomp> regionPolyDecomp_;
//- Decomposed cells information (cellZone meshes)
//- Decomposed cells information (cellZonas)
List<polyDecomp> zonePolyDecomp_;
//- Decomposed cells information (cellSet meshes)
//- Decomposed cells information (cellSets)
List<polyDecomp> csetPolyDecomp_;
//- List of patch names for rendering to window
@ -369,7 +369,7 @@ class vtkPVFoam
template<class ZoneType>
wordList getZoneNames
(
const ZoneMesh<ZoneType, polyMesh>&
const MeshZones<ZoneType, polyMesh>&
) const;
//- Add objects of Type to paraview array selection
@ -432,31 +432,31 @@ class vtkPVFoam
//- Lagrangian mesh
void convertMeshLagrangian(vtkMultiBlockDataSet*, int& blockNo);
//- Patch meshes
//- Patches
void convertMeshPatches(vtkMultiBlockDataSet*, int& blockNo);
//- Cell zone meshes
//- Cell zones
void convertMeshCellZones(vtkMultiBlockDataSet*, int& blockNo);
//- Face zone meshes
//- Face zones
void convertMeshFaceZones(vtkMultiBlockDataSet*, int& blockNo);
//- Point zone meshes
//- Point zones
void convertMeshPointZones(vtkMultiBlockDataSet*, int& blockNo);
//- Cell set meshes
//- Cell sets
void convertMeshCellSets(vtkMultiBlockDataSet*, int& blockNo);
//- Face set meshes
//- Face sets
void convertMeshFaceSets(vtkMultiBlockDataSet*, int& blockNo);
//- Point set meshes
//- Point sets
void convertMeshPointSets(vtkMultiBlockDataSet*, int& blockNo);
// Add mesh functions
//- Add internal mesh/cell set meshes
//- Add internal mesh/cell set
vtkUnstructuredGrid* volumeVTKMesh(const fvMesh&, polyDecomp&);
//- Add Lagrangian mesh
@ -477,7 +477,7 @@ class vtkPVFoam
const labelList& pointLabels
);
//- Add face set mesh
//- Add face set
vtkPolyData* faceSetVTKMesh
(
const fvMesh&,

8
applications/utilities/postProcessing/graphics/PVReaders/vtkPVFoam/vtkPVFoamMesh.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -264,7 +264,7 @@ void Foam::vtkPVFoam::convertMeshCellZones
printMemory();
}
const cellZoneMesh& zMesh = mesh.cellZones();
const meshCellZones& zMesh = mesh.cellZones();
for (int partId = range.start(); partId < range.end(); ++partId)
{
const word zoneName = getPartName(partId);
@ -432,7 +432,7 @@ void Foam::vtkPVFoam::convertMeshFaceZones
printMemory();
}
const faceZoneMesh& zMesh = mesh.faceZones();
const meshFaceZones& zMesh = mesh.faceZones();
for (int partId = range.start(); partId < range.end(); ++partId)
{
const word zoneName = getPartName(partId);
@ -550,7 +550,7 @@ void Foam::vtkPVFoam::convertMeshPointZones
if (range.size())
{
const pointZoneMesh& zMesh = mesh.pointZones();
const meshPointZones& zMesh = mesh.pointZones();
for (int partId = range.start(); partId < range.end(); ++partId)
{
word zoneName = getPartName(partId);

4
applications/utilities/postProcessing/graphics/PVReaders/vtkPVFoam/vtkPVFoamSurfaceField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -260,7 +260,7 @@ void Foam::vtkPVFoam::convertSurfaceFields
continue;
}
const faceZoneMesh& zMesh = mesh.faceZones();
const meshFaceZones& zMesh = mesh.faceZones();
const label zoneId = zMesh.findZoneID(zoneName);
if (zoneId < 0)

6
applications/utilities/postProcessing/graphics/PVReaders/vtkPVFoam/vtkPVFoamUpdateInfo.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -84,7 +84,7 @@ public:
template<class ZoneType>
Foam::wordList Foam::vtkPVFoam::getZoneNames
(
const ZoneMesh<ZoneType, polyMesh>& zmesh
const MeshZones<ZoneType, polyMesh>& zmesh
) const
{
wordList names(zmesh.size());
@ -124,7 +124,7 @@ Foam::wordList Foam::vtkPVFoam::getZoneNames(const word& zoneType) const
false
);
if (ioObj.typeHeaderOk<cellZoneMesh>(false))
if (ioObj.typeHeaderOk<meshCellZones>(false))
{
zonesEntries zones(ioObj);

4
applications/utilities/postProcessing/graphics/PVReaders/vtkPVFoam/vtkPVFoamVolFields.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -217,7 +217,7 @@ void Foam::vtkPVFoam::convertVolFields
continue;
}
const faceZoneMesh& zMesh = mesh.faceZones();
const meshFaceZones& zMesh = mesh.faceZones();
const label zoneId = zMesh.findZoneID(zoneName);
if (zoneId < 0)

12
applications/utilities/surface/surfaceMeshTriangulate/surfaceMeshTriangulate.C
View File

@ -142,13 +142,13 @@ int main(int argc, char *argv[])
const faceZoneMesh& fzm = mesh.faceZones();
labelHashSet includeFaceZones(fzm.size());
const meshFaceZones& mfz = mesh.faceZones();
labelHashSet includeFaceZones(mfz.size());
if (args.optionFound("faceZones"))
{
wordReList zoneNames(args.optionLookup("faceZones")());
const wordList allZoneNames(fzm.names());
const wordList allZoneNames(mfz.names());
forAll(zoneNames, i)
{
const wordRe& zoneName = zoneNames[i];
@ -196,7 +196,7 @@ int main(int argc, char *argv[])
HashTable<label> zoneSize(1000);
forAllConstIter(labelHashSet, includeFaceZones, iter)
{
const faceZone& pp = fzm[iter.key()];
const faceZone& pp = mfz[iter.key()];
zoneSize.insert(pp.name(), pp.size());
nFaces += pp.size();
}
@ -237,7 +237,7 @@ int main(int argc, char *argv[])
}
else
{
label zoneI = fzm.findZoneID(iter.key());
label zoneI = mfz.findZoneID(iter.key());
faceZoneToCompactZone[zoneI] = iter();
}
}
@ -259,7 +259,7 @@ int main(int argc, char *argv[])
// Collect faces on faceZones
forAllConstIter(labelHashSet, includeFaceZones, iter)
{
const faceZone& pp = fzm[iter.key()];
const faceZone& pp = mfz[iter.key()];
forAll(pp, i)
{
faceLabels.append(pp[i]);

14
src/OpenFOAM/meshes/Identifiers/zones/ZoneIDs.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,9 +28,9 @@ License
#include "DynamicID.H"
#include "cellZoneMeshFwd.H"
#include "faceZoneMeshFwd.H"
#include "pointZoneMeshFwd.H"
#include "meshCellZonesFwd.H"
#include "meshFaceZonesFwd.H"
#include "meshPointZonesFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -38,13 +38,13 @@ namespace Foam
{
//- Foam::cellZoneID
typedef DynamicID<cellZoneMesh> cellZoneID;
typedef DynamicID<meshCellZones> cellZoneID;
//- Foam::faceZoneID
typedef DynamicID<faceZoneMesh> faceZoneID;
typedef DynamicID<meshFaceZones> faceZoneID;
//- Foam::pointZoneID
typedef DynamicID<pointZoneMesh> pointZoneID;
typedef DynamicID<meshPointZones> pointZoneID;
}

32
src/OpenFOAM/meshes/polyMesh/polyMesh.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -52,9 +52,9 @@ SourceFiles
#include "labelIOList.H"
#include "polyBoundaryMesh.H"
#include "boundBox.H"
#include "pointZoneMesh.H"
#include "faceZoneMesh.H"
#include "cellZoneMesh.H"
#include "meshPointZones.H"
#include "meshFaceZones.H"
#include "meshCellZones.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -159,13 +159,13 @@ private:
// Zoning information
//- Point zones
pointZoneMesh pointZones_;
meshPointZones pointZones_;
//- Face zones
faceZoneMesh faceZones_;
meshFaceZones faceZones_;
//- Cell zones
cellZoneMesh cellZones_;
meshCellZones cellZones_;
//- Parallel info
@ -467,20 +467,20 @@ public:
//- Return the cell search tree
const indexedOctree<treeDataCell>& cellTree() const;
//- Return point zone mesh
const pointZoneMesh& pointZones() const
//- Return point zones
const meshPointZones& pointZones() const
{
return pointZones_;
}
//- Return face zone mesh
const faceZoneMesh& faceZones() const
//- Return face zones
const meshFaceZones& faceZones() const
{
return faceZones_;
}
//- Return cell zone mesh
const cellZoneMesh& cellZones() const
//- Return cell zones
const meshCellZones& cellZones() const
{
return cellZones_;
}
@ -553,19 +553,19 @@ public:
// Topological change
//- Return non-const access to the pointZones
pointZoneMesh& pointZones()
meshPointZones& pointZones()
{
return pointZones_;
}
//- Return non-const access to the faceZones
faceZoneMesh& faceZones()
meshFaceZones& faceZones()
{
return faceZones_;
}
//- Return non-const access to the cellZones
cellZoneMesh& cellZones()
meshCellZones& cellZones()
{
return cellZones_;
}

6
src/OpenFOAM/meshes/polyMesh/polyMeshIO.C
View File

@ -278,7 +278,7 @@ Foam::polyMesh::readUpdateState Foam::polyMesh::readUpdate()
solutionD_ = Zero;
// Zones
pointZoneMesh newPointZones
meshPointZones newPointZones
(
IOobject
(
@ -315,7 +315,7 @@ Foam::polyMesh::readUpdateState Foam::polyMesh::readUpdate()
}
faceZoneMesh newFaceZones
meshFaceZones newFaceZones
(
IOobject
(
@ -356,7 +356,7 @@ Foam::polyMesh::readUpdateState Foam::polyMesh::readUpdate()
}
cellZoneMesh newCellZones
meshCellZones newCellZones
(
IOobject
(

58
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.C → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/MeshZones.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,7 +23,7 @@ License
\*---------------------------------------------------------------------------*/
#include "ZoneMesh.H"
#include "MeshZones.H"
#include "entry.H"
#include "demandDrivenData.H"
#include "stringListOps.H"
@ -32,7 +32,7 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class ZoneType, class MeshType>
void Foam::ZoneMesh<ZoneType, MeshType>::calcZoneMap() const
void Foam::MeshZones<ZoneType, MeshType>::calcZoneMap() const
{
// It is an error to attempt to recalculate cellEdges
// if the pointer is already set
@ -71,7 +71,7 @@ void Foam::ZoneMesh<ZoneType, MeshType>::calcZoneMap() const
template<class ZoneType, class MeshType>
bool Foam::ZoneMesh<ZoneType, MeshType>::read()
bool Foam::MeshZones<ZoneType, MeshType>::read()
{
if
(
@ -114,7 +114,7 @@ bool Foam::ZoneMesh<ZoneType, MeshType>::read()
// Check state of IOstream
is.check
(
"ZoneMesh::ZoneMesh"
"MeshZones::MeshZones"
"(const IOobject&, const MeshType&)"
);
@ -133,7 +133,7 @@ bool Foam::ZoneMesh<ZoneType, MeshType>::read()
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class ZoneType, class MeshType>
Foam::ZoneMesh<ZoneType, MeshType>::ZoneMesh
Foam::MeshZones<ZoneType, MeshType>::MeshZones
(
const IOobject& io,
const MeshType& mesh
@ -149,7 +149,7 @@ Foam::ZoneMesh<ZoneType, MeshType>::ZoneMesh
template<class ZoneType, class MeshType>
Foam::ZoneMesh<ZoneType, MeshType>::ZoneMesh
Foam::MeshZones<ZoneType, MeshType>::MeshZones
(
const IOobject& io,
const MeshType& mesh,
@ -167,11 +167,11 @@ Foam::ZoneMesh<ZoneType, MeshType>::ZoneMesh
template<class ZoneType, class MeshType>
Foam::ZoneMesh<ZoneType, MeshType>::ZoneMesh
Foam::MeshZones<ZoneType, MeshType>::MeshZones
(
const IOobject& io,
const MeshType& mesh,
const PtrList<ZoneType>& pzm
const PtrList<ZoneType>& mpz
)
:
PtrList<ZoneType>(),
@ -183,10 +183,10 @@ Foam::ZoneMesh<ZoneType, MeshType>::ZoneMesh
{
// Nothing read. Use supplied zones
PtrList<ZoneType>& zones = *this;
zones.setSize(pzm.size());
zones.setSize(mpz.size());
forAll(zones, zoneI)
{
zones.set(zoneI, pzm[zoneI].clone(*this).ptr());
zones.set(zoneI, mpz[zoneI].clone(*this).ptr());
}
}
}
@ -195,7 +195,7 @@ Foam::ZoneMesh<ZoneType, MeshType>::ZoneMesh
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class ZoneType, class MeshType>
Foam::ZoneMesh<ZoneType, MeshType>::~ZoneMesh()
Foam::MeshZones<ZoneType, MeshType>::~MeshZones()
{
clearAddressing();
}
@ -205,7 +205,7 @@ Foam::ZoneMesh<ZoneType, MeshType>::~ZoneMesh()
template<class ZoneType, class MeshType>
const Foam::Map<Foam::label>&
Foam::ZoneMesh<ZoneType, MeshType>::zoneMap() const
Foam::MeshZones<ZoneType, MeshType>::zoneMap() const
{
if (!zoneMapPtr_)
{
@ -217,7 +217,7 @@ Foam::ZoneMesh<ZoneType, MeshType>::zoneMap() const
template<class ZoneType, class MeshType>
Foam::label Foam::ZoneMesh<ZoneType, MeshType>::whichZone
Foam::label Foam::MeshZones<ZoneType, MeshType>::whichZone
(
const label objectIndex
) const
@ -237,7 +237,7 @@ Foam::label Foam::ZoneMesh<ZoneType, MeshType>::whichZone
template<class ZoneType, class MeshType>
Foam::wordList Foam::ZoneMesh<ZoneType, MeshType>::types() const
Foam::wordList Foam::MeshZones<ZoneType, MeshType>::types() const
{
const PtrList<ZoneType>& zones = *this;
@ -253,7 +253,7 @@ Foam::wordList Foam::ZoneMesh<ZoneType, MeshType>::types() const
template<class ZoneType, class MeshType>
Foam::wordList Foam::ZoneMesh<ZoneType, MeshType>::names() const
Foam::wordList Foam::MeshZones<ZoneType, MeshType>::names() const
{
const PtrList<ZoneType>& zones = *this;
@ -269,7 +269,7 @@ Foam::wordList Foam::ZoneMesh<ZoneType, MeshType>::names() const
template<class ZoneType, class MeshType>
Foam::labelList Foam::ZoneMesh<ZoneType, MeshType>::findIndices
Foam::labelList Foam::MeshZones<ZoneType, MeshType>::findIndices
(
const wordRe& key
) const
@ -302,7 +302,7 @@ Foam::labelList Foam::ZoneMesh<ZoneType, MeshType>::findIndices
template<class ZoneType, class MeshType>
Foam::label Foam::ZoneMesh<ZoneType, MeshType>::findIndex
Foam::label Foam::MeshZones<ZoneType, MeshType>::findIndex
(
const wordRe& key
) const
@ -337,7 +337,7 @@ Foam::label Foam::ZoneMesh<ZoneType, MeshType>::findIndex
template<class ZoneType, class MeshType>
Foam::label Foam::ZoneMesh<ZoneType, MeshType>::findZoneID
Foam::label Foam::MeshZones<ZoneType, MeshType>::findZoneID
(
const word& zoneName
) const
@ -366,7 +366,7 @@ Foam::label Foam::ZoneMesh<ZoneType, MeshType>::findZoneID
template<class ZoneType, class MeshType>
Foam::PackedBoolList Foam::ZoneMesh<ZoneType, MeshType>::findMatching
Foam::PackedBoolList Foam::MeshZones<ZoneType, MeshType>::findMatching
(
const wordRe& key
) const
@ -384,7 +384,7 @@ Foam::PackedBoolList Foam::ZoneMesh<ZoneType, MeshType>::findMatching
template<class ZoneType, class MeshType>
void Foam::ZoneMesh<ZoneType, MeshType>::clearAddressing()
void Foam::MeshZones<ZoneType, MeshType>::clearAddressing()
{
deleteDemandDrivenData(zoneMapPtr_);
@ -398,7 +398,7 @@ void Foam::ZoneMesh<ZoneType, MeshType>::clearAddressing()
template<class ZoneType, class MeshType>
void Foam::ZoneMesh<ZoneType, MeshType>::clear()
void Foam::MeshZones<ZoneType, MeshType>::clear()
{
clearAddressing();
PtrList<ZoneType>::clear();
@ -406,7 +406,7 @@ void Foam::ZoneMesh<ZoneType, MeshType>::clear()
template<class ZoneType, class MeshType>
bool Foam::ZoneMesh<ZoneType, MeshType>::checkDefinition
bool Foam::MeshZones<ZoneType, MeshType>::checkDefinition
(
const bool report
) const
@ -424,7 +424,7 @@ bool Foam::ZoneMesh<ZoneType, MeshType>::checkDefinition
template<class ZoneType, class MeshType>
bool Foam::ZoneMesh<ZoneType, MeshType>::checkParallelSync
bool Foam::MeshZones<ZoneType, MeshType>::checkParallelSync
(
const bool report
) const
@ -502,7 +502,7 @@ bool Foam::ZoneMesh<ZoneType, MeshType>::checkParallelSync
template<class ZoneType, class MeshType>
void Foam::ZoneMesh<ZoneType, MeshType>::movePoints(const pointField& p)
void Foam::MeshZones<ZoneType, MeshType>::movePoints(const pointField& p)
{
PtrList<ZoneType>& zones = *this;
@ -514,7 +514,7 @@ void Foam::ZoneMesh<ZoneType, MeshType>::movePoints(const pointField& p)
template<class ZoneType, class MeshType>
bool Foam::ZoneMesh<ZoneType, MeshType>::writeData(Ostream& os) const
bool Foam::MeshZones<ZoneType, MeshType>::writeData(Ostream& os) const
{
os << *this;
return os.good();
@ -524,7 +524,7 @@ bool Foam::ZoneMesh<ZoneType, MeshType>::writeData(Ostream& os) const
// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
template<class ZoneType, class MeshType>
const ZoneType& Foam::ZoneMesh<ZoneType, MeshType>::operator[]
const ZoneType& Foam::MeshZones<ZoneType, MeshType>::operator[]
(
const word& zoneName
) const
@ -544,7 +544,7 @@ const ZoneType& Foam::ZoneMesh<ZoneType, MeshType>::operator[]
template<class ZoneType, class MeshType>
ZoneType& Foam::ZoneMesh<ZoneType, MeshType>::operator[]
ZoneType& Foam::MeshZones<ZoneType, MeshType>::operator[]
(
const word& zoneName
)
@ -569,7 +569,7 @@ template<class ZoneType, class MeshType>
Foam::Ostream& Foam::operator<<
(
Ostream& os,
const ZoneMesh<ZoneType, MeshType>& zones
const MeshZones<ZoneType, MeshType>& zones
)
{
os << zones.size() << nl << token::BEGIN_LIST;

37
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/ZoneMesh.H → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/MeshZones.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,18 +22,18 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::ZoneMesh
Foam::MeshZones
Description
A list of mesh zones.
SourceFiles
ZoneMesh.C
MeshZones.C
\*---------------------------------------------------------------------------*/
#ifndef ZoneMesh_H
#define ZoneMesh_H
#ifndef MeshZones_H
#define MeshZones_H
#include "List.H"
#include "regIOobject.H"
@ -50,17 +50,17 @@ namespace Foam
// Forward declaration of friend functions and operators
template<class ZoneType, class MeshType> class ZoneMesh;
template<class ZoneType, class MeshType> class MeshZones;
template<class ZoneType, class MeshType>
Ostream& operator<<(Ostream&, const ZoneMesh<ZoneType, MeshType>&);
Ostream& operator<<(Ostream&, const MeshZones<ZoneType, MeshType>&);
/*---------------------------------------------------------------------------*\
Class ZoneMesh Declaration
Class MeshZones Declaration
\*---------------------------------------------------------------------------*/
template<class ZoneType, class MeshType>
class ZoneMesh
class MeshZones
:
public PtrList<ZoneType>,
public regIOobject
@ -80,10 +80,10 @@ class ZoneMesh
bool read();
//- Disallow default bitwise copy construction
ZoneMesh(const ZoneMesh&);
MeshZones(const MeshZones&);
//- Disallow default bitwise assignment
void operator=(const ZoneMesh<ZoneType, MeshType>&);
void operator=(const MeshZones<ZoneType, MeshType>&);
//- Create zone map
@ -95,14 +95,14 @@ public:
// Constructors
//- Read constructor given IOobject and a MeshType reference
ZoneMesh
MeshZones
(
const IOobject&,
const MeshType&
);
//- Construct given size
ZoneMesh
MeshZones
(
const IOobject&,
const MeshType&,
@ -110,7 +110,7 @@ public:
);
//- Construct given a PtrList
ZoneMesh
MeshZones
(
const IOobject&,
const MeshType&,
@ -119,7 +119,7 @@ public:
//- Destructor
~ZoneMesh();
~MeshZones();
// Member Functions
@ -169,12 +169,13 @@ public:
// true if in error.
bool checkParallelSync(const bool report = false) const;
//- Correct zone mesh after moving points
//- Correct zones after moving points
void movePoints(const pointField&);
//- writeData member function required by regIOobject
bool writeData(Ostream&) const;
// Member Operators
//- Return const and non-const reference to ZoneType by index.
@ -192,7 +193,7 @@ public:
friend Ostream& operator<< <ZoneType, MeshType>
(
Ostream&,
const ZoneMesh<ZoneType, MeshType>&
const MeshZones<ZoneType, MeshType>&
);
};
@ -204,7 +205,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "ZoneMesh.C"
#include "MeshZones.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

12
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/cellZoneMesh.H → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/meshCellZones.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,16 +22,16 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
Foam::cellZoneMesh
Foam::meshCellZones
\*---------------------------------------------------------------------------*/
#ifndef cellZoneMesh_H
#define cellZoneMesh_H
#ifndef meshCellZones_H
#define meshCellZones_H
#include "ZoneMesh.H"
#include "MeshZones.H"
#include "cellZone.H"
#include "cellZoneMeshFwd.H"
#include "meshCellZonesFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

14
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/cellZoneMeshFwd.H → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/meshCellZonesFwd.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,25 +22,25 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Typedef
Foam::cellZoneMesh
Foam::meshCellZones
Description
A ZoneMesh with the type cellZone
A MeshZones with the type cellZone
\*---------------------------------------------------------------------------*/
#ifndef cellZoneMeshFwd_H
#define cellZoneMeshFwd_H
#ifndef meshCellZonesFwd_H
#define meshCellZonesFwd_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
template<class Zone, class MeshType> class ZoneMesh;
template<class Zone, class MeshType> class MeshZones;
class cellZone;
class polyMesh;
typedef ZoneMesh<cellZone, polyMesh> cellZoneMesh;
typedef MeshZones<cellZone, polyMesh> meshCellZones;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

12
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/faceZoneMesh.H → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/meshFaceZones.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,16 +22,16 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
Foam::faceZoneMesh
Foam::meshFaceZones
\*---------------------------------------------------------------------------*/
#ifndef faceZoneMesh_H
#define faceZoneMesh_H
#ifndef meshFaceZones_H
#define meshFaceZones_H
#include "ZoneMesh.H"
#include "MeshZones.H"
#include "faceZone.H"
#include "faceZoneMeshFwd.H"
#include "meshFaceZonesFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

14
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/faceZoneMeshFwd.H → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/meshFaceZonesFwd.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,25 +22,25 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Typedef
Foam::faceZoneMesh
Foam::meshFaceZones
Description
A ZoneMesh with the type faceZone
A MeshZones with the type faceZone
\*---------------------------------------------------------------------------*/
#ifndef faceZoneMeshFwd_H
#define faceZoneMeshFwd_H
#ifndef meshFaceZonesFwd_H
#define meshFaceZonesFwd_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
template<class Zone, class MeshType> class ZoneMesh;
template<class Zone, class MeshType> class MeshZones;
class faceZone;
class polyMesh;
typedef ZoneMesh<faceZone, polyMesh> faceZoneMesh;
typedef MeshZones<faceZone, polyMesh> meshFaceZones;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

12
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/pointZoneMesh.H → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/meshPointZones.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,16 +22,16 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
Foam::pointZoneMesh
Foam::meshPointZones
\*---------------------------------------------------------------------------*/
#ifndef pointZoneMesh_H
#define pointZoneMesh_H
#ifndef meshPointZones_H
#define meshPointZones_H
#include "ZoneMesh.H"
#include "MeshZones.H"
#include "pointZone.H"
#include "pointZoneMeshFwd.H"
#include "meshPointZonesFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

14
src/OpenFOAM/meshes/polyMesh/zones/ZoneMesh/pointZoneMeshFwd.H → src/OpenFOAM/meshes/polyMesh/zones/MeshZones/meshPointZonesFwd.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,25 +22,25 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Typedef
Foam::pointZoneMesh
Foam::meshPointZones
Description
A ZoneMesh with the type pointZone
A MeshZones with the type pointZone
\*---------------------------------------------------------------------------*/
#ifndef pointZoneMeshFwd_H
#define pointZoneMeshFwd_H
#ifndef meshPointZonesFwd_H
#define meshPointZonesFwd_H
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
template<class Zone, class MeshType> class ZoneMesh;
template<class Zone, class MeshType> class MeshZones;
class pointZone;
class polyMesh;
typedef ZoneMesh<pointZone, polyMesh> pointZoneMesh;
typedef MeshZones<pointZone, polyMesh> meshPointZones;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

30
src/OpenFOAM/meshes/polyMesh/zones/cellZone/cellZone.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,7 +25,7 @@ License
#include "cellZone.H"
#include "addToRunTimeSelectionTable.H"
#include "cellZoneMesh.H"
#include "meshCellZones.H"
#include "polyMesh.H"
#include "primitiveMesh.H"
#include "IOstream.H"
@ -49,11 +49,11 @@ Foam::cellZone::cellZone
const word& name,
const labelUList& addr,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
)
:
zone(name, addr, index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -62,11 +62,11 @@ Foam::cellZone::cellZone
const word& name,
labelList&& addr,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
)
:
zone(name, move(addr), index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -75,11 +75,11 @@ Foam::cellZone::cellZone
const word& name,
const dictionary& dict,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
)
:
zone(name, dict, this->labelsName, index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -88,11 +88,11 @@ Foam::cellZone::cellZone
const cellZone& cz,
const labelUList& addr,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
)
:
zone(cz, addr, index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -101,11 +101,11 @@ Foam::cellZone::cellZone
const cellZone& cz,
labelList&& addr,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
)
:
zone(cz, move(addr), index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -123,15 +123,15 @@ Foam::label Foam::cellZone::whichCell(const label globalCellID) const
}
const Foam::cellZoneMesh& Foam::cellZone::zoneMesh() const
const Foam::meshCellZones& Foam::cellZone::meshZones() const
{
return zoneMesh_;
return meshZones_;
}
bool Foam::cellZone::checkDefinition(const bool report) const
{
return zone::checkDefinition(zoneMesh_.mesh().nCells(), report);
return zone::checkDefinition(meshZones_.mesh().nCells(), report);
}

44
src/OpenFOAM/meshes/polyMesh/zones/cellZone/cellZone.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -29,7 +29,7 @@ Description
Currently set up as an indirect list but will be extended to use a
primitive mesh. For quick check whether a cell belongs to the zone use
the lookup mechanism in cellZoneMesh, where all the zoned cells are
the lookup mechanism in meshCellZones, where all the zoned cells are
registered with their zone number.
SourceFiles
@ -42,7 +42,7 @@ SourceFiles
#define cellZone_H
#include "zone.H"
#include "cellZoneMeshFwd.H"
#include "meshCellZonesFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -69,7 +69,7 @@ protected:
// Protected data
//- Reference to zone list
const cellZoneMesh& zoneMesh_;
const meshCellZones& meshZones_;
public:
@ -95,9 +95,9 @@ public:
const word& name,
const dictionary& dict,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
),
(name, dict, index, zm)
(name, dict, index, mz)
);
@ -109,7 +109,7 @@ public:
const word& name,
const labelUList& addr,
const label index,
const cellZoneMesh&
const meshCellZones&
);
//- Construct from components, transferring contents
@ -118,7 +118,7 @@ public:
const word& name,
labelList&& addr,
const label index,
const cellZoneMesh&
const meshCellZones&
);
//- Construct from dictionary
@ -127,54 +127,54 @@ public:
const word& name,
const dictionary&,
const label index,
const cellZoneMesh&
const meshCellZones&
);
//- Construct given the original zone and resetting the
// cell list and zone mesh information
// cell list and mesh zones information
cellZone
(
const cellZone&,
const labelUList& addr,
const label index,
const cellZoneMesh&
const meshCellZones&
);
//- Construct given the original zone, resetting the
// cell list and zone mesh information
// cell list and mesh zones information
cellZone
(
const cellZone&,
labelList&& addr,
const label index,
const cellZoneMesh&
const meshCellZones&
);
//- Disallow default bitwise copy construction
cellZone(const cellZone&) = delete;
//- Construct and return a clone, resetting the zone mesh
virtual autoPtr<cellZone> clone(const cellZoneMesh& zm) const
//- Construct and return a clone, resetting the mesh zones
virtual autoPtr<cellZone> clone(const meshCellZones& mz) const
{
return autoPtr<cellZone>
(
new cellZone(*this, *this, index(), zm)
new cellZone(*this, *this, index(), mz)
);
}
//- Construct and return a clone, resetting the cell list
// and zone mesh
// and mesh zones
virtual autoPtr<cellZone> clone
(
const labelUList& addr,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
) const
{
return autoPtr<cellZone>
(
new cellZone(*this, addr, index, zm)
new cellZone(*this, addr, index, mz)
);
}
@ -188,7 +188,7 @@ public:
const word& name,
const dictionary&,
const label index,
const cellZoneMesh&
const meshCellZones&
);
@ -201,8 +201,8 @@ public:
//- Helper function to re-direct to zone::localID(...)
label whichCell(const label globalCellID) const;
//- Return zoneMesh reference
const cellZoneMesh& zoneMesh() const;
//- Return meshZones reference
const meshCellZones& meshZones() const;
//- Check zone definition. Return true if in error.
virtual bool checkDefinition(const bool report = false) const;

6
src/OpenFOAM/meshes/polyMesh/zones/cellZone/cellZoneNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -33,7 +33,7 @@ Foam::autoPtr<Foam::cellZone> Foam::cellZone::New
const word& name,
const dictionary& dict,
const label index,
const cellZoneMesh& zm
const meshCellZones& mz
)
{
if (debug)
@ -58,7 +58,7 @@ Foam::autoPtr<Foam::cellZone> Foam::cellZone::New
<< exit(FatalIOError);
}
return autoPtr<cellZone>(cstrIter()(name, dict, index, zm));
return autoPtr<cellZone>(cstrIter()(name, dict, index, mz));
}

48
src/OpenFOAM/meshes/polyMesh/zones/faceZone/faceZone.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,7 +25,7 @@ License
#include "faceZone.H"
#include "addToRunTimeSelectionTable.H"
#include "faceZoneMesh.H"
#include "meshFaceZones.H"
#include "polyMesh.H"
#include "primitiveMesh.H"
#include "demandDrivenData.H"
@ -64,12 +64,12 @@ void Foam::faceZone::calcFaceZonePatch() const
new primitiveFacePatch
(
faceList(size()),
zoneMesh().mesh().points()
meshZones().mesh().points()
);
primitiveFacePatch& patch = *patchPtr_;
const faceList& f = zoneMesh().mesh().faces();
const faceList& f = meshZones().mesh().faces();
const labelList& addr = *this;
const boolList& flip = flipMap();
@ -113,8 +113,8 @@ void Foam::faceZone::calcCellLayers() const
// Go through all the faces in the master zone. Choose the
// master or slave cell based on the face flip
const labelList& own = zoneMesh().mesh().faceOwner();
const labelList& nei = zoneMesh().mesh().faceNeighbour();
const labelList& own = meshZones().mesh().faceOwner();
const labelList& nei = meshZones().mesh().faceNeighbour();
const labelList& mf = *this;
@ -131,7 +131,7 @@ void Foam::faceZone::calcCellLayers() const
label ownCelli = own[mf[facei]];
label neiCelli =
(
zoneMesh().mesh().isInternalFace(mf[facei])
meshZones().mesh().isInternalFace(mf[facei])
? nei[mf[facei]]
: -1
);
@ -165,7 +165,7 @@ void Foam::faceZone::checkAddressing() const
const labelList& mf = *this;
// Note: nFaces, nCells might not be set yet on mesh so use owner size
const label nFaces = zoneMesh().mesh().faceOwner().size();
const label nFaces = meshZones().mesh().faceOwner().size();
bool hasWarned = false;
forAll(mf, i)
@ -189,12 +189,12 @@ Foam::faceZone::faceZone
const labelUList& addr,
const boolList& fm,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
)
:
zone(name, addr, index),
flipMap_(fm),
zoneMesh_(zm),
meshZones_(mz),
patchPtr_(nullptr),
masterCellsPtr_(nullptr),
slaveCellsPtr_(nullptr),
@ -210,12 +210,12 @@ Foam::faceZone::faceZone
labelList&& addr,
boolList&& fm,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
)
:
zone(name, move(addr), index),
flipMap_(move(fm)),
zoneMesh_(zm),
meshZones_(mz),
patchPtr_(nullptr),
masterCellsPtr_(nullptr),
slaveCellsPtr_(nullptr),
@ -230,12 +230,12 @@ Foam::faceZone::faceZone
const word& name,
const dictionary& dict,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
)
:
zone(name, dict, this->labelsName, index),
flipMap_(dict.lookup("flipMap")),
zoneMesh_(zm),
meshZones_(mz),
patchPtr_(nullptr),
masterCellsPtr_(nullptr),
slaveCellsPtr_(nullptr),
@ -251,12 +251,12 @@ Foam::faceZone::faceZone
const labelUList& addr,
const boolList& fm,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
)
:
zone(fz, addr, index),
flipMap_(fm),
zoneMesh_(zm),
meshZones_(mz),
patchPtr_(nullptr),
masterCellsPtr_(nullptr),
slaveCellsPtr_(nullptr),
@ -272,12 +272,12 @@ Foam::faceZone::faceZone
labelList&& addr,
boolList&& fm,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
)
:
zone(fz, move(addr), index),
flipMap_(move(fm)),
zoneMesh_(zm),
meshZones_(mz),
patchPtr_(nullptr),
masterCellsPtr_(nullptr),
slaveCellsPtr_(nullptr),
@ -297,9 +297,9 @@ Foam::faceZone::~faceZone()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::faceZoneMesh& Foam::faceZone::zoneMesh() const
const Foam::meshFaceZones& Foam::faceZone::meshZones() const
{
return zoneMesh_;
return meshZones_;
}
@ -351,8 +351,8 @@ const Foam::labelList& Foam::faceZone::meshEdges() const
(
operator()().meshEdges
(
zoneMesh().mesh().edges(),
zoneMesh().mesh().pointEdges()
meshZones().mesh().edges(),
meshZones().mesh().pointEdges()
)
);
}
@ -418,13 +418,13 @@ void Foam::faceZone::updateMesh(const mapPolyMesh& mpm)
bool Foam::faceZone::checkDefinition(const bool report) const
{
return zone::checkDefinition(zoneMesh().mesh().faces().size(), report);
return zone::checkDefinition(meshZones().mesh().faces().size(), report);
}
bool Foam::faceZone::checkParallelSync(const bool report) const
{
const polyMesh& mesh = zoneMesh().mesh();
const polyMesh& mesh = meshZones().mesh();
const polyBoundaryMesh& bm = mesh.boundaryMesh();
bool hasError = false;

44
src/OpenFOAM/meshes/polyMesh/zones/faceZone/faceZone.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,7 +28,7 @@ Description
A subset of mesh faces organised as a primitive patch.
For quick check whether a face belongs to the zone use the lookup
mechanism in faceZoneMesh, where all the zoned faces are registered
mechanism in meshFaceZones, where all the zoned faces are registered
with their zone number.
SourceFiles
@ -41,7 +41,7 @@ SourceFiles
#define faceZone_H
#include "zone.H"
#include "faceZoneMeshFwd.H"
#include "meshFaceZonesFwd.H"
#include "boolList.H"
#include "primitiveFacePatch.H"
@ -81,7 +81,7 @@ protected:
boolList flipMap_;
//- Reference to zone list
const faceZoneMesh& zoneMesh_;
const meshFaceZones& meshZones_;
// Demand-driven private data
@ -137,9 +137,9 @@ public:
const word& name,
const dictionary& dict,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
),
(name, dict, index, zm)
(name, dict, index, mz)
);
@ -152,7 +152,7 @@ public:
const labelUList& addr,
const boolList& fm,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
);
//- Construct from components, moving contents
@ -162,7 +162,7 @@ public:
labelList&& addr,
boolList&& fm,
const label index,
const faceZoneMesh&
const meshFaceZones&
);
//- Construct from dictionary
@ -171,57 +171,57 @@ public:
const word& name,
const dictionary&,
const label index,
const faceZoneMesh&
const meshFaceZones&
);
//- Construct given the original zone and resetting the
// face list and zone mesh information
// face list and mesh zones information
faceZone
(
const faceZone&,
const labelUList& addr,
const boolList& fm,
const label index,
const faceZoneMesh&
const meshFaceZones&
);
//- Construct given the original zone, resetting the
// face list and zone mesh information
// face list and mesh zones information
faceZone
(
const faceZone&,
labelList&& addr,
boolList&& fm,
const label index,
const faceZoneMesh&
const meshFaceZones&
);
//- Disallow default bitwise copy construction
faceZone(const faceZone&) = delete;
//- Construct and return a clone, resetting the zone mesh
virtual autoPtr<faceZone> clone(const faceZoneMesh& zm) const
//- Construct and return a clone, resetting the mesh zones
virtual autoPtr<faceZone> clone(const meshFaceZones& mz) const
{
return autoPtr<faceZone>
(
new faceZone(*this, *this, flipMap(), index(), zm)
new faceZone(*this, *this, flipMap(), index(), mz)
);
}
//- Construct and return a clone, resetting the face list
// and zone mesh
// and mesh zones
virtual autoPtr<faceZone> clone
(
const labelUList& addr,
const boolList& fm,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
) const
{
return autoPtr<faceZone>
(
new faceZone(*this, addr, fm, index, zm)
new faceZone(*this, addr, fm, index, mz)
);
}
@ -235,7 +235,7 @@ public:
const word& name,
const dictionary&,
const label index,
const faceZoneMesh&
const meshFaceZones&
);
@ -257,8 +257,8 @@ public:
//- Return reference to primitive patch
const primitiveFacePatch& operator()() const;
//- Return zoneMesh reference
const faceZoneMesh& zoneMesh() const;
//- Return meshZones reference
const meshFaceZones& meshZones() const;
// Addressing into mesh

6
src/OpenFOAM/meshes/polyMesh/zones/faceZone/faceZoneNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -33,7 +33,7 @@ Foam::autoPtr<Foam::faceZone> Foam::faceZone::New
const word& name,
const dictionary& dict,
const label index,
const faceZoneMesh& zm
const meshFaceZones& mz
)
{
if (debug)
@ -58,7 +58,7 @@ Foam::autoPtr<Foam::faceZone> Foam::faceZone::New
<< exit(FatalIOError);
}
return autoPtr<faceZone>(cstrIter()(name, dict, index, zm));
return autoPtr<faceZone>(cstrIter()(name, dict, index, mz));
}

32
src/OpenFOAM/meshes/polyMesh/zones/pointZone/pointZone.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,7 +25,7 @@ License
#include "pointZone.H"
#include "addToRunTimeSelectionTable.H"
#include "pointZoneMesh.H"
#include "meshPointZones.H"
#include "polyMesh.H"
#include "primitiveMesh.H"
#include "demandDrivenData.H"
@ -49,11 +49,11 @@ Foam::pointZone::pointZone
const word& name,
const labelUList& addr,
const label index,
const pointZoneMesh& zm
const meshPointZones& mz
)
:
zone(name, addr, index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -62,11 +62,11 @@ Foam::pointZone::pointZone
const word& name,
labelList&& addr,
const label index,
const pointZoneMesh& zm
const meshPointZones& mz
)
:
zone(name, move(addr), index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -75,11 +75,11 @@ Foam::pointZone::pointZone
const word& name,
const dictionary& dict,
const label index,
const pointZoneMesh& zm
const meshPointZones& mz
)
:
zone(name, dict, this->labelsName, index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -88,11 +88,11 @@ Foam::pointZone::pointZone
const pointZone& pz,
const labelUList& addr,
const label index,
const pointZoneMesh& zm
const meshPointZones& mz
)
:
zone(pz, addr, index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -101,11 +101,11 @@ Foam::pointZone::pointZone
const pointZone& pz,
labelList&& addr,
const label index,
const pointZoneMesh& zm
const meshPointZones& mz
)
:
zone(pz, move(addr), index),
zoneMesh_(zm)
meshZones_(mz)
{}
@ -117,9 +117,9 @@ Foam::pointZone::~pointZone()
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::pointZoneMesh& Foam::pointZone::zoneMesh() const
const Foam::meshPointZones& Foam::pointZone::meshZones() const
{
return zoneMesh_;
return meshZones_;
}
@ -131,13 +131,13 @@ Foam::label Foam::pointZone::whichPoint(const label globalPointID) const
bool Foam::pointZone::checkDefinition(const bool report) const
{
return zone::checkDefinition(zoneMesh_.mesh().points().size(), report);
return zone::checkDefinition(meshZones_.mesh().points().size(), report);
}
bool Foam::pointZone::checkParallelSync(const bool report) const
{
const polyMesh& mesh = zoneMesh().mesh();
const polyMesh& mesh = meshZones().mesh();
labelList maxZone(mesh.nPoints(), -1);
labelList minZone(mesh.nPoints(), labelMax);

44
src/OpenFOAM/meshes/polyMesh/zones/pointZone/pointZone.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -30,7 +30,7 @@ Description
list.
For quick check whether a point belongs to the zone use the lookup
mechanism in pointZoneMesh, where all the zoned points are registered
mechanism in meshPointZones, where all the zoned points are registered
with their zone number.
SourceFiles
@ -43,7 +43,7 @@ SourceFiles
#define pointZone_H
#include "zone.H"
#include "pointZoneMeshFwd.H"
#include "meshPointZonesFwd.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -70,7 +70,7 @@ protected:
// Protected data
//- Reference to zone list
const pointZoneMesh& zoneMesh_;
const meshPointZones& meshZones_;
public:
@ -96,9 +96,9 @@ public:
const word& name,
const dictionary& dict,
const label index,
const pointZoneMesh& zm
const meshPointZones& mz
),
(name, dict, index, zm)
(name, dict, index, mz)
);
@ -110,7 +110,7 @@ public:
const word& name,
const labelUList& addr,
const label index,
const pointZoneMesh&
const meshPointZones&
);
//- Construct from components, transferring contents
@ -119,7 +119,7 @@ public:
const word& name,
labelList&& addr,
const label index,
const pointZoneMesh&
const meshPointZones&
);
//- Construct from dictionary
@ -128,54 +128,54 @@ public:
const word& name,
const dictionary&,
const label index,
const pointZoneMesh&
const meshPointZones&
);
//- Construct given the original zone and resetting the
// point list and zone mesh information
// point list and mesh zones information
pointZone
(
const pointZone&,
const labelUList& addr,
const label index,
const pointZoneMesh&
const meshPointZones&
);
//- Construct given the original zone, resetting the
// face list and zone mesh information
// face list and mesh zones information
pointZone
(
const pointZone&,
labelList&& addr,
const label index,
const pointZoneMesh&
const meshPointZones&
);
//- Disallow default bitwise copy construction
pointZone(const pointZone&) = delete;
//- Construct and return a clone, resetting the zone mesh
virtual autoPtr<pointZone> clone(const pointZoneMesh& zm) const
//- Construct and return a clone, resetting the mesh zones
virtual autoPtr<pointZone> clone(const meshPointZones& mz) const
{
return autoPtr<pointZone>
(
new pointZone(*this, *this, index(), zm)
new pointZone(*this, *this, index(), mz)
);
}
//- Construct and return a clone, resetting the point list
// and zone mesh
// and mesh zones
virtual autoPtr<pointZone> clone
(
const pointZoneMesh& zm,
const meshPointZones& mz,
const label index,
const labelUList& addr
) const
{
return autoPtr<pointZone>
(
new pointZone(*this, addr, index, zm)
new pointZone(*this, addr, index, mz)
);
}
@ -189,7 +189,7 @@ public:
const word& name,
const dictionary&,
const label index,
const pointZoneMesh&
const meshPointZones&
);
@ -199,8 +199,8 @@ public:
// Member Functions
//- Return zoneMesh reference
const pointZoneMesh& zoneMesh() const;
//- Return meshZones reference
const meshPointZones& meshZones() const;
//- Helper function to re-direct to zone::localID(...)
label whichPoint(const label globalPointID) const;

6
src/OpenFOAM/meshes/polyMesh/zones/pointZone/pointZoneNew.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -33,7 +33,7 @@ Foam::autoPtr<Foam::pointZone> Foam::pointZone::New
const word& name,
const dictionary& dict,
const label index,
const pointZoneMesh& zm
const meshPointZones& mz
)
{
if (debug)
@ -58,7 +58,7 @@ Foam::autoPtr<Foam::pointZone> Foam::pointZone::New
<< exit(FatalIOError);
}
return autoPtr<pointZone>(cstrIter()(name, dict, index, zm));
return autoPtr<pointZone>(cstrIter()(name, dict, index, mz));
}

6
src/OpenFOAM/meshes/polyMesh/zones/zone/zone.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -117,7 +117,7 @@ public:
);
//- Construct given the original zone and resetting the
// cell list and zone mesh information
// cell list and mesh zones information
zone
(
const zone&,
@ -126,7 +126,7 @@ public:
);
//- Construct given the original zone, resetting the
// cell list and zone mesh information
// cell list and mesh zones information
zone
(
const zone&,

2
src/atmosphericModels/porosityModels/powerLawLopesdaCosta/powerLawLopesdaCosta.C
View File

@ -256,7 +256,7 @@ Foam::porosityModels::powerLawLopesdaCostaZone::powerLawLopesdaCostaZone
// Create the porous region cellZone and add to the mesh cellZones
cellZoneMesh& cellZones = const_cast<cellZoneMesh&>(mesh.cellZones());
meshCellZones& cellZones = const_cast<meshCellZones&>(mesh.cellZones());
label zoneID = cellZones.findZoneID(zoneName_);

4
src/conversion/meshTables/cellTable.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -470,7 +470,7 @@ void Foam::cellTable::addCellZones
}
zoneUsed.setSize(nZone);
cellZoneMesh& czMesh = mesh.cellZones();
meshCellZones& czMesh = mesh.cellZones();
czMesh.clear();
if (nZone <= 1)

19
src/dynamicMesh/attachDetach/detachInterface.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -70,14 +70,14 @@ void Foam::attachDetach::detachInterface
}
const polyMesh& mesh = topoChanger().mesh();
const faceZoneMesh& zoneMesh = mesh.faceZones();
const meshFaceZones& meshZones = mesh.faceZones();
// Check that zone is in increasing order (needed since adding faces
// in same order - otherwise polyTopoChange face ordering will mess up
// correspondence)
if (debug)
{
const labelList& faceLabels = zoneMesh[faceZoneID_.index()];
const labelList& faceLabels = meshZones[faceZoneID_.index()];
if (faceLabels.size() > 0)
{
for (label i = 1; i < faceLabels.size(); i++)
@ -85,7 +85,7 @@ void Foam::attachDetach::detachInterface
if (faceLabels[i] <= faceLabels[i-1])
{
FatalErrorInFunction
<< "faceZone " << zoneMesh[faceZoneID_.index()].name()
<< "faceZone " << meshZones[faceZoneID_.index()].name()
<< " does not have mesh face labels in"
<< " increasing order." << endl
<< "Face label " << faceLabels[i]
@ -100,14 +100,15 @@ void Foam::attachDetach::detachInterface
const primitiveFacePatch& masterFaceLayer = zoneMesh[faceZoneID_.index()]();
const primitiveFacePatch& masterFaceLayer =
meshZones[faceZoneID_.index()]();
const pointField& points = mesh.points();
const labelListList& meshEdgeFaces = mesh.edgeFaces();
const labelList& mp = masterFaceLayer.meshPoints();
const edgeList& zoneLocalEdges = masterFaceLayer.edges();
const labelList& meshEdges = zoneMesh[faceZoneID_.index()].meshEdges();
const labelList& meshEdges = meshZones[faceZoneID_.index()].meshEdges();
// Create the points
@ -170,8 +171,8 @@ void Foam::attachDetach::detachInterface
// Modify faces in the master zone and duplicate for the slave zone
const labelList& mf = zoneMesh[faceZoneID_.index()];
const boolList& mfFlip = zoneMesh[faceZoneID_.index()].flipMap();
const labelList& mf = meshZones[faceZoneID_.index()];
const boolList& mfFlip = meshZones[faceZoneID_.index()].flipMap();
const faceList& zoneFaces = masterFaceLayer.localFaces();
const faceList& faces = mesh.faces();
@ -317,7 +318,7 @@ void Foam::attachDetach::detachInterface
forAll(curFaces, facei)
{
// Check if the face belongs to the master patch; if not add it
if (zoneMesh.whichZone(curFaces[facei]) != faceZoneID_.index())
if (meshZones.whichZone(curFaces[facei]) != faceZoneID_.index())
{
masterCellFaceMap.insert(curFaces[facei]);
}

8
src/dynamicMesh/fvMeshDistribute/fvMeshDistribute.C
View File

@ -1478,7 +1478,7 @@ void Foam::fvMeshDistribute::sendMesh
// in merged-zone indices.
CompactListList<label> zonePoints;
{
const pointZoneMesh& pointZones = mesh.pointZones();
const meshPointZones& pointZones = mesh.pointZones();
labelList rowSizes(pointZoneNames.size(), 0);
@ -1508,7 +1508,7 @@ void Foam::fvMeshDistribute::sendMesh
CompactListList<label> zoneFaces;
CompactListList<bool> zoneFaceFlip;
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
labelList rowSizes(faceZoneNames.size(), 0);
@ -1540,7 +1540,7 @@ void Foam::fvMeshDistribute::sendMesh
// Assume sparse, possibly overlapping cell zones
CompactListList<label> zoneCells;
{
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
labelList rowSizes(cellZoneNames.size(), 0);
@ -1573,7 +1573,7 @@ void Foam::fvMeshDistribute::sendMesh
// cellZoneID.setSize(mesh.nCells());
// cellZoneID = -1;
//
// const cellZoneMesh& cellZones = mesh.cellZones();
// const meshCellZones& cellZones = mesh.cellZones();
//
// forAll(cellZones, zoneI)
// {

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

@ -316,7 +316,7 @@ void Foam::fvMeshSubset::subsetZones()
{
// Keep all zones, even if zero size.
const pointZoneMesh& pointZones = baseMesh().pointZones();
const meshPointZones& pointZones = baseMesh().pointZones();
// PointZones
List<pointZone*> pZonePtrs(pointZones.size());
@ -336,7 +336,7 @@ void Foam::fvMeshSubset::subsetZones()
// FaceZones
const faceZoneMesh& faceZones = baseMesh().faceZones();
const meshFaceZones& faceZones = baseMesh().faceZones();
// Do we need to remove zones where the side we're interested in
// no longer exists? Guess not.
@ -403,7 +403,7 @@ void Foam::fvMeshSubset::subsetZones()
}
// CellZones
const cellZoneMesh& cellZones = baseMesh().cellZones();
const meshCellZones& cellZones = baseMesh().cellZones();
List<cellZone*> cZonePtrs(cellZones.size());

8
src/dynamicMesh/layerAdditionRemoval/addCellLayer.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -399,7 +399,7 @@ void Foam::layerAdditionRemoval::addCellLayer
const labelListList& meshEdgeFaces = mesh.edgeFaces();
const faceZoneMesh& zoneMesh = mesh.faceZones();
const meshFaceZones& meshZones = mesh.faceZones();
// Do all boundary edges
@ -429,7 +429,7 @@ void Foam::layerAdditionRemoval::addCellLayer
if (!mesh.isInternalFace(cf))
{
// Face not internal. Check if it is in the zone
if (zoneMesh.whichZone(cf) != faceZoneID_.index())
if (meshZones.whichZone(cf) != faceZoneID_.index())
{
// Found the face in a boundary patch which is not in zone
patchID = mesh.boundaryMesh().whichPatch(cf);
@ -499,7 +499,7 @@ void Foam::layerAdditionRemoval::addCellLayer
forAll(curFaces, facei)
{
// Check if the face belongs to the master zone; if not add it
if (zoneMesh.whichZone(curFaces[facei]) != faceZoneID_.index())
if (meshZones.whichZone(curFaces[facei]) != faceZoneID_.index())
{
masterCellFaceMap.insert(curFaces[facei]);
}

10
src/dynamicMesh/layerAdditionRemoval/layerAdditionRemoval.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -247,7 +247,7 @@ bool Foam::layerAdditionRemoval::changeTopology() const
else
{
// Thickness calculated from edges on layer
const Map<label>& zoneMeshPointMap = fz().meshPointMap();
const Map<label>& meshZonePointMap = fz().meshPointMap();
// Edges with only one point on zone
forAll(mc, facei)
@ -259,9 +259,9 @@ bool Foam::layerAdditionRemoval::changeTopology() const
{
const edge& e = cellEdges[i];
if (zoneMeshPointMap.found(e[0]))
if (meshZonePointMap.found(e[0]))
{
if (!zoneMeshPointMap.found(e[1]))
if (!meshZonePointMap.found(e[1]))
{
scalar curDelta = e.mag(mesh.points());
avgDelta += curDelta;
@ -272,7 +272,7 @@ bool Foam::layerAdditionRemoval::changeTopology() const
}
else
{
if (zoneMeshPointMap.found(e[1]))
if (meshZonePointMap.found(e[1]))
{
scalar curDelta = e.mag(mesh.points());
avgDelta += curDelta;

4
src/dynamicMesh/motionSolvers/displacement/solidBody/multiSolidBodyMotionSolver/multiSolidBodyMotionSolver.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,7 +26,7 @@ License
#include "multiSolidBodyMotionSolver.H"
#include "addToRunTimeSelectionTable.H"
#include "transformField.H"
#include "cellZoneMesh.H"
#include "meshCellZones.H"
#include "boolList.H"
#include "syncTools.H"

4
src/dynamicMesh/motionSolvers/displacement/solidBody/solidBodyMotionSolver/solidBodyMotionSolver.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2016-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,7 +26,7 @@ License
#include "solidBodyMotionSolver.H"
#include "addToRunTimeSelectionTable.H"
#include "transformField.H"
#include "cellZoneMesh.H"
#include "meshCellZones.H"
#include "cellSet.H"
#include "boolList.H"
#include "syncTools.H"

12
src/dynamicMesh/polyMeshAdder/polyMeshAdder.C
View File

@ -689,8 +689,8 @@ void Foam::polyMeshAdder::mergePrimitives
void Foam::polyMeshAdder::mergePointZones
(
const label nAllPoints,
const pointZoneMesh& pz0,
const pointZoneMesh& pz1,
const meshPointZones& pz0,
const meshPointZones& pz1,
const labelList& from0ToAllPoints,
const labelList& from1ToAllPoints,
@ -839,9 +839,9 @@ void Foam::polyMeshAdder::mergeFaceZones
List<DynamicList<bool>>& fzFlips
)
{
const faceZoneMesh& fz0 = mesh0.faceZones();
const meshFaceZones& fz0 = mesh0.faceZones();
const labelList& owner0 = mesh0.faceOwner();
const faceZoneMesh& fz1 = mesh1.faceZones();
const meshFaceZones& fz1 = mesh1.faceZones();
const labelList& owner1 = mesh1.faceOwner();
@ -1017,8 +1017,8 @@ void Foam::polyMeshAdder::mergeCellZones
(
const label nAllCells,
const cellZoneMesh& cz0,
const cellZoneMesh& cz1,
const meshCellZones& cz0,
const meshCellZones& cz1,
const labelList& from1ToAllCells,
DynamicList<word>& zoneNames,

8
src/dynamicMesh/polyMeshAdder/polyMeshAdder.H
View File

@ -149,8 +149,8 @@ private:
(
const label nAllPoints,
const pointZoneMesh& pz0,
const pointZoneMesh& pz1,
const meshPointZones& pz0,
const meshPointZones& pz1,
const labelList& from0ToAllPoints,
const labelList& from1ToAllPoints,
@ -181,8 +181,8 @@ private:
(
const label nAllCells,
const cellZoneMesh& cz0,
const cellZoneMesh& cz1,
const meshCellZones& cz0,
const meshCellZones& cz1,
const labelList& from1ToAllCells,
DynamicList<word>& zoneNames,

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

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -1258,7 +1258,7 @@ bool Foam::edgeCollapser::setRefinement
const labelList& faceOwner = mesh_.faceOwner();
const labelList& faceNeighbour = mesh_.faceNeighbour();
const labelListList& pointFaces = mesh_.pointFaces();
const pointZoneMesh& pointZones = mesh_.pointZones();
const meshPointZones& pointZones = mesh_.pointZones();
@ -1555,7 +1555,7 @@ bool Foam::edgeCollapser::setRefinement
const polyBoundaryMesh& boundaryMesh = mesh_.boundaryMesh();
const faceZoneMesh& faceZones = mesh_.faceZones();
const meshFaceZones& faceZones = mesh_.faceZones();
// Renumber faces that use points
forAll(allPointInfo, pointi)

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

@ -1580,7 +1580,7 @@ void Foam::polyTopoChange::resetZones
pointZoneMap.setSize(mesh.pointZones().size());
{
const pointZoneMesh& pointZones = mesh.pointZones();
const meshPointZones& pointZones = mesh.pointZones();
// Count points per zone
@ -1666,7 +1666,7 @@ void Foam::polyTopoChange::resetZones
faceZoneFaceMap.setSize(mesh.faceZones().size());
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
labelList nFaces(faceZones.size(), 0);
@ -1779,7 +1779,7 @@ void Foam::polyTopoChange::resetZones
cellZoneMap.setSize(mesh.cellZones().size());
{
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
labelList nCells(cellZones.size(), 0);
@ -1868,11 +1868,11 @@ void Foam::polyTopoChange::resetZones
void Foam::polyTopoChange::calcFaceZonePointMap
(
const polyMesh& mesh,
const List<Map<label>>& oldFaceZoneMeshPointMaps,
const List<Map<label>>& oldMeshFaceZonesPointMaps,
labelListList& faceZonePointMap
) const
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
faceZonePointMap.setSize(faceZones.size());
@ -1880,25 +1880,26 @@ void Foam::polyTopoChange::calcFaceZonePointMap
{
const faceZone& newZone = faceZones[zoneI];
const labelList& newZoneMeshPoints = newZone().meshPoints();
const labelList& newMeshZonePoints = newZone().meshPoints();
const Map<label>& oldZoneMeshPointMap = oldFaceZoneMeshPointMaps[zoneI];
const Map<label>& oldMeshZonePointMap =
oldMeshFaceZonesPointMaps[zoneI];
labelList& curFzPointRnb = faceZonePointMap[zoneI];
curFzPointRnb.setSize(newZoneMeshPoints.size());
curFzPointRnb.setSize(newMeshZonePoints.size());
forAll(newZoneMeshPoints, pointi)
forAll(newMeshZonePoints, pointi)
{
if (newZoneMeshPoints[pointi] < pointMap_.size())
if (newMeshZonePoints[pointi] < pointMap_.size())
{
Map<label>::const_iterator ozmpmIter =
oldZoneMeshPointMap.find
oldMeshZonePointMap.find
(
pointMap_[newZoneMeshPoints[pointi]]
pointMap_[newMeshZonePoints[pointi]]
);
if (ozmpmIter != oldZoneMeshPointMap.end())
if (ozmpmIter != oldMeshZonePointMap.end())
{
curFzPointRnb[pointi] = ozmpmIter();
}
@ -2055,7 +2056,7 @@ void Foam::polyTopoChange::compactAndReorder
List<Map<label>>& oldPatchMeshPointMaps,
labelList& oldPatchNMeshPoints,
labelList& oldPatchStarts,
List<Map<label>>& oldFaceZoneMeshPointMaps
List<Map<label>>& oldMeshFaceZonesPointMaps
)
{
if (mesh.boundaryMesh().size() != nPatches_)
@ -2144,22 +2145,22 @@ void Foam::polyTopoChange::compactAndReorder
forAll(boundary, patchi)
{
// Copy old face zone mesh point maps
// Copy old face zone point maps
oldPatchMeshPointMaps[patchi] = boundary[patchi].meshPointMap();
oldPatchNMeshPoints[patchi] = boundary[patchi].meshPoints().size();
oldPatchStarts[patchi] = boundary[patchi].start();
}
// Grab old face zone mesh point maps.
// Grab old face zone point maps.
// These need to be saved before resetting the mesh and are used
// later on to calculate the faceZone pointMaps.
oldFaceZoneMeshPointMaps.setSize(mesh.faceZones().size());
oldMeshFaceZonesPointMaps.setSize(mesh.faceZones().size());
forAll(mesh.faceZones(), zoneI)
{
const faceZone& oldZone = mesh.faceZones()[zoneI];
oldFaceZoneMeshPointMaps[zoneI] = oldZone().meshPointMap();
oldMeshFaceZonesPointMaps[zoneI] = oldZone().meshPointMap();
}
}
@ -2296,7 +2297,7 @@ void Foam::polyTopoChange::addMesh
// Add points
{
const pointField& points = mesh.points();
const pointZoneMesh& pointZones = mesh.pointZones();
const meshPointZones& pointZones = mesh.pointZones();
// Extend
points_.setCapacity(points_.size() + points.size());
@ -2333,7 +2334,7 @@ void Foam::polyTopoChange::addMesh
// Add cells
{
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
// Resize
@ -2392,7 +2393,7 @@ void Foam::polyTopoChange::addMesh
const faceList& faces = mesh.faces();
const labelList& faceOwner = mesh.faceOwner();
const labelList& faceNeighbour = mesh.faceNeighbour();
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
// Resize
label nAllFaces = mesh.faces().size();
@ -3144,7 +3145,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::changeMesh
List<Map<label>> oldPatchMeshPointMaps;
labelList oldPatchNMeshPoints;
labelList oldPatchStarts;
List<Map<label>> oldFaceZoneMeshPointMaps;
List<Map<label>> oldMeshFaceZonesPointMaps;
// Compact, reorder patch faces and calculate mesh/patch maps.
compactAndReorder
@ -3169,7 +3170,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::changeMesh
oldPatchMeshPointMaps,
oldPatchNMeshPoints,
oldPatchStarts,
oldFaceZoneMeshPointMaps
oldMeshFaceZonesPointMaps
);
const label nOldPoints(mesh.nPoints());
@ -3320,9 +3321,9 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::changeMesh
patchPointMap
);
// Create the face zone mesh point renumbering
// Create the face zone point renumbering
labelListList faceZonePointMap(mesh.faceZones().size());
calcFaceZonePointMap(mesh, oldFaceZoneMeshPointMaps, faceZonePointMap);
calcFaceZonePointMap(mesh, oldMeshFaceZonesPointMaps, faceZonePointMap);
labelHashSet flipFaceFluxSet(getSetIndices(flipFaceFlux_));
@ -3423,7 +3424,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::makeMesh
List<Map<label>> oldPatchMeshPointMaps;
labelList oldPatchNMeshPoints;
labelList oldPatchStarts;
List<Map<label>> oldFaceZoneMeshPointMaps;
List<Map<label>> oldMeshFaceZonesPointMaps;
// Compact, reorder patch faces and calculate mesh/patch maps.
compactAndReorder
@ -3448,7 +3449,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::makeMesh
oldPatchMeshPointMaps,
oldPatchNMeshPoints,
oldPatchStarts,
oldFaceZoneMeshPointMaps
oldMeshFaceZonesPointMaps
);
const label nOldPoints(mesh.nPoints());
@ -3537,7 +3538,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::makeMesh
// ~~~~~
// Start off from empty zones.
const pointZoneMesh& oldPointZones = mesh.pointZones();
const meshPointZones& oldPointZones = mesh.pointZones();
List<pointZone*> pZonePtrs(oldPointZones.size());
{
forAll(oldPointZones, i)
@ -3552,7 +3553,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::makeMesh
}
}
const faceZoneMesh& oldFaceZones = mesh.faceZones();
const meshFaceZones& oldFaceZones = mesh.faceZones();
List<faceZone*> fZonePtrs(oldFaceZones.size());
{
forAll(oldFaceZones, i)
@ -3568,7 +3569,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::makeMesh
}
}
const cellZoneMesh& oldCellZones = mesh.cellZones();
const meshCellZones& oldCellZones = mesh.cellZones();
List<cellZone*> cZonePtrs(oldCellZones.size());
{
forAll(oldCellZones, i)
@ -3613,9 +3614,9 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::polyTopoChange::makeMesh
patchPointMap
);
// Create the face zone mesh point renumbering
// Create the face zone point renumbering
labelListList faceZonePointMap(newMesh.faceZones().size());
calcFaceZonePointMap(newMesh, oldFaceZoneMeshPointMaps, faceZonePointMap);
calcFaceZonePointMap(newMesh, oldMeshFaceZonesPointMaps, faceZonePointMap);
if (debug)
{

4
src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -398,7 +398,7 @@ class polyTopoChange
List<Map<label>>& oldPatchMeshPointMaps,
labelList& oldPatchNMeshPoints,
labelList& oldPatchStarts,
List<Map<label>>& oldFaceZoneMeshPointMaps
List<Map<label>>& oldMeshFaceZonesPointMaps
);
public:

4
src/dynamicMesh/polyTopoChange/polyTopoChange/removeCells.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -248,7 +248,7 @@ void Foam::removeCells::setRefinement
const faceList& faces = mesh_.faces();
const labelList& faceOwner = mesh_.faceOwner();
const labelList& faceNeighbour = mesh_.faceNeighbour();
const faceZoneMesh& faceZones = mesh_.faceZones();
const meshFaceZones& faceZones = mesh_.faceZones();
// Count starting number of faces using each point. Keep up to date whenever
// removing a face.

4
src/dynamicMesh/slidingInterface/coupleSlidingInterface.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -81,7 +81,7 @@ void Foam::slidingInterface::coupleInterface(polyTopoChange& ref) const
const labelList& own = mesh.faceOwner();
const labelList& nei = mesh.faceNeighbour();
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
const primitiveFacePatch& masterPatch =
faceZones[masterFaceZoneID_.index()]();

4
src/dynamicMesh/slidingInterface/slidingInterfaceAttachedAddressing.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -48,7 +48,7 @@ void Foam::slidingInterface::calcAttachedAddressing() const
const polyMesh& mesh = topoChanger().mesh();
const labelList& own = mesh.faceOwner();
const labelList& nei = mesh.faceNeighbour();
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
// Master side

4
src/fvModels/interRegion/interRegionExplicitPorositySource/interRegionExplicitPorositySource.C
View File

@ -90,12 +90,12 @@ Foam::fv::interRegionExplicitPorositySource::interRegionExplicitPorositySource
const word zoneName(name + ":porous");
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
label zoneID = cellZones.findZoneID(zoneName);
if (zoneID == -1)
{
cellZoneMesh& cz = const_cast<cellZoneMesh&>(cellZones);
meshCellZones& cz = const_cast<meshCellZones&>(cellZones);
zoneID = cz.size();

2
src/fvMotionSolver/pointPatchFields/derived/surfaceDisplacement/surfaceDisplacementPointPatchVectorField.C
View File

@ -85,7 +85,7 @@ void surfaceDisplacementPointPatchVectorField::calcProjection
if (frozenPointsZone_.size() > 0)
{
const pointZoneMesh& pZones = mesh.pointZones();
const meshPointZones& pZones = mesh.pointZones();
zonePtr = &pZones[frozenPointsZone_];

2
src/fvMotionSolver/pointPatchFields/derived/surfaceSlipDisplacement/surfaceSlipDisplacementPointPatchVectorField.C
View File

@ -84,7 +84,7 @@ void surfaceSlipDisplacementPointPatchVectorField::calcProjection
if (frozenPointsZone_.size() > 0)
{
const pointZoneMesh& pZones = mesh.pointZones();
const meshPointZones& pZones = mesh.pointZones();
zonePtr = &pZones[frozenPointsZone_];

4
src/lagrangian/molecularDynamics/molecule/moleculeCloud/moleculeCloud.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -481,7 +481,7 @@ void Foam::moleculeCloud::initialiseMolecules
<< "Initialising molecules in each zone specified in mdInitialiseDict."
<< endl;
const cellZoneMesh& cellZones = mesh_.cellZones();
const meshCellZones& cellZones = mesh_.cellZones();
if (!cellZones.size())
{

18
src/lagrangian/parcel/submodels/CloudFunctionObjects/FacePostProcessing/FacePostProcessing.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -81,7 +81,7 @@ void Foam::FacePostProcessing<CloudType>::write()
{
const fvMesh& mesh = this->owner().mesh();
const Time& time = mesh.time();
const faceZoneMesh& fzm = mesh.faceZones();
const meshFaceZones& mfz = mesh.faceZones();
scalar timeNew = time.value();
scalar timeElapsed = timeNew - timeOld_;
@ -105,7 +105,7 @@ void Foam::FacePostProcessing<CloudType>::write()
List<scalarField> zoneMassFlowRate(massFlowRate_.size());
forAll(faceZoneIDs_, zoneI)
{
const word& zoneName = fzm[faceZoneIDs_[zoneI]].name();
const word& zoneName = mfz[faceZoneIDs_[zoneI]].name();
scalarListList allProcMass(Pstream::nProcs());
allProcMass[proci] = massTotal_[zoneI];
@ -147,7 +147,7 @@ void Foam::FacePostProcessing<CloudType>::write()
{
forAll(faceZoneIDs_, zoneI)
{
const faceZone& fZone = fzm[faceZoneIDs_[zoneI]];
const faceZone& fZone = mfz[faceZoneIDs_[zoneI]];
labelList pointToGlobal;
labelList uniqueMeshPointLabels;
@ -272,17 +272,17 @@ Foam::FacePostProcessing<CloudType>::FacePostProcessing
outputFilePtr_.setSize(faceZoneNames.size());
DynamicList<label> zoneIDs;
const faceZoneMesh& fzm = owner.mesh().faceZones();
const meshFaceZones& mfz = owner.mesh().faceZones();
const surfaceScalarField& magSf = owner.mesh().magSf();
const polyBoundaryMesh& pbm = owner.mesh().boundaryMesh();
forAll(faceZoneNames, i)
{
const word& zoneName = faceZoneNames[i];
label zoneI = fzm.findZoneID(zoneName);
label zoneI = mfz.findZoneID(zoneName);
if (zoneI != -1)
{
zoneIDs.append(zoneI);
const faceZone& fz = fzm[zoneI];
const faceZone& fz = mfz[zoneI];
mass_[i].setSize(fz.size(), 0.0);
massTotal_[i].setSize(fz.size(), 0.0);
massFlowRate_[i].setSize(fz.size(), 0.0);
@ -365,11 +365,11 @@ void Foam::FacePostProcessing<CloudType>::postFace(const parcelType& p, bool&)
|| this->owner().solution().transient()
)
{
const faceZoneMesh& fzm = this->owner().mesh().faceZones();
const meshFaceZones& mfz = this->owner().mesh().faceZones();
forAll(faceZoneIDs_, i)
{
const faceZone& fz = fzm[faceZoneIDs_[i]];
const faceZone& fz = mfz[faceZoneIDs_[i]];
label faceId = -1;
forAll(fz, j)

4
src/mesh/snappyHexMesh/meshRefinement/meshRefinement.C
View File

@ -1419,7 +1419,7 @@ Foam::autoPtr<Foam::mapDistributePolyMesh> Foam::meshRefinement::balance
const PtrList<surfaceZonesInfo>& surfZones =
surfaces().surfZones();
const faceZoneMesh& fZones = mesh_.faceZones();
const meshFaceZones& fZones = mesh_.faceZones();
const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
// Get faces whose owner and neighbour should stay together,
@ -1832,7 +1832,7 @@ Foam::tmp<Foam::pointVectorField> Foam::meshRefinement::makeDisplacementField
void Foam::meshRefinement::checkCoupledFaceZones(const polyMesh& mesh)
{
const faceZoneMesh& fZones = mesh.faceZones();
const meshFaceZones& fZones = mesh.faceZones();
// Check any zones are present anywhere and in same order

6
src/mesh/snappyHexMesh/meshRefinement/meshRefinementBaffles.C
View File

@ -281,7 +281,7 @@ Foam::Map<Foam::labelPair> Foam::meshRefinement::getZoneBafflePatches
Map<labelPair> bafflePatch(mesh_.nFaces()/1000);
const PtrList<surfaceZonesInfo>& surfZones = surfaces_.surfZones();
const faceZoneMesh& fZones = mesh_.faceZones();
const meshFaceZones& fZones = mesh_.faceZones();
forAll(surfZones, surfI)
{
@ -476,7 +476,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createBaffles
void Foam::meshRefinement::checkZoneFaces() const
{
const faceZoneMesh& fZones = mesh_.faceZones();
const meshFaceZones& fZones = mesh_.faceZones();
const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
@ -878,7 +878,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergeBaffles
const faceList& faces = mesh_.faces();
const labelList& faceOwner = mesh_.faceOwner();
const faceZoneMesh& faceZones = mesh_.faceZones();
const meshFaceZones& faceZones = mesh_.faceZones();
forAll(couples, i)
{

8
src/mesh/snappyHexMesh/refinementSurfaces/surfaceZonesInfo.C
View File

@ -340,7 +340,7 @@ Foam::labelList Foam::surfaceZonesInfo::addCellZonesToMesh
{
labelList surfaceToCellZone(surfList.size(), -1);
cellZoneMesh& cellZones = mesh.cellZones();
meshCellZones& cellZones = mesh.cellZones();
forAll(namedSurfaces, i)
{
@ -364,7 +364,7 @@ Foam::labelList Foam::surfaceZonesInfo::addCellZonesToMesh
cellZoneName, // name
labelList(0), // addressing
zoneI, // index
cellZones // cellZoneMesh
cellZones // meshCellZones
)
);
}
@ -405,7 +405,7 @@ Foam::labelList Foam::surfaceZonesInfo::addFaceZonesToMesh
{
labelList surfaceToFaceZone(surfList.size(), -1);
faceZoneMesh& faceZones = mesh.faceZones();
meshFaceZones& faceZones = mesh.faceZones();
forAll(namedSurfaces, i)
{
@ -428,7 +428,7 @@ Foam::labelList Foam::surfaceZonesInfo::addFaceZonesToMesh
labelList(0), // addressing
boolList(0), // flipmap
zoneI, // index
faceZones // faceZoneMesh
faceZones // meshFaceZones
)
);
}

6
src/mesh/snappyHexMesh/snappyHexMeshDriver/snappySnapDriver.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -1874,7 +1874,7 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::snappySnapDriver::repatchToSurface
// 2. All faces on zoned surfaces
const PtrList<surfaceZonesInfo>& surfZones = surfaces.surfZones();
const faceZoneMesh& fZones = mesh.faceZones();
const meshFaceZones& fZones = mesh.faceZones();
forAll(zonedSurfaces, i)
{
@ -2173,7 +2173,7 @@ void Foam::snappySnapDriver::doSnap
// Selectively 'forget' about the baffles, i.e. not check across them
// or merge across them.
{
const faceZoneMesh& fZones = mesh.faceZones();
const meshFaceZones& fZones = mesh.faceZones();
const refinementSurfaces& surfaces = meshRefiner_.surfaces();
const PtrList<surfaceZonesInfo>& surfZones = surfaces.surfZones();

6
src/meshTools/sets/topoSets/cellZoneSet.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -74,7 +74,7 @@ cellZoneSet::cellZoneSet
mesh_(mesh),
addressing_(0)
{
const cellZoneMesh& cellZones = mesh.cellZones();
const meshCellZones& cellZones = mesh.cellZones();
label zoneID = cellZones.findZoneID(name);
if
@ -259,7 +259,7 @@ bool cellZoneSet::writeObject
const_cast<word&>(type()) = oldTypeName;
// Modify cellZone
cellZoneMesh& cellZones = const_cast<polyMesh&>(mesh_).cellZones();
meshCellZones& cellZones = const_cast<polyMesh&>(mesh_).cellZones();
label zoneID = cellZones.findZoneID(name());
if (zoneID == -1)

6
src/meshTools/sets/topoSets/faceZoneSet.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -79,7 +79,7 @@ faceZoneSet::faceZoneSet
addressing_(0),
flipMap_(0)
{
const faceZoneMesh& faceZones = mesh.faceZones();
const meshFaceZones& faceZones = mesh.faceZones();
label zoneID = faceZones.findZoneID(name);
if
@ -474,7 +474,7 @@ bool faceZoneSet::writeObject
const_cast<word&>(type()) = oldTypeName;
// Modify faceZone
faceZoneMesh& faceZones = const_cast<polyMesh&>(mesh_).faceZones();
meshFaceZones& faceZones = const_cast<polyMesh&>(mesh_).faceZones();
label zoneID = faceZones.findZoneID(name());
if (zoneID == -1)

6
src/meshTools/sets/topoSets/pointZoneSet.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -76,7 +76,7 @@ pointZoneSet::pointZoneSet
mesh_(mesh),
addressing_(0)
{
const pointZoneMesh& pointZones = mesh.pointZones();
const meshPointZones& pointZones = mesh.pointZones();
label zoneID = pointZones.findZoneID(name);
if
@ -260,7 +260,7 @@ bool pointZoneSet::writeObject
const_cast<word&>(type()) = oldTypeName;
// Modify pointZone
pointZoneMesh& pointZones = const_cast<polyMesh&>(mesh_).pointZones();
meshPointZones& pointZones = const_cast<polyMesh&>(mesh_).pointZones();
label zoneID = pointZones.findZoneID(name());
if (zoneID == -1)

6
src/parallel/decompose/decompositionMethods/decompositionConstraints/preserveFaceZones/preserveFaceZonesConstraint.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2018 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2021 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -97,7 +97,7 @@ void Foam::decompositionConstraints::preserveFaceZonesConstraint::add
{
blockedFace.setSize(mesh.nFaces(), true);
const faceZoneMesh& fZones = mesh.faceZones();
const meshFaceZones& fZones = mesh.faceZones();
const labelList zoneIDs = findStrings(zones_, fZones.names());
@ -167,7 +167,7 @@ void Foam::decompositionConstraints::preserveFaceZonesConstraint::apply
// Override if differing
// ~~~~~~~~~~~~~~~~~~~~~
const faceZoneMesh& fZones = mesh.faceZones();
const meshFaceZones& fZones = mesh.faceZones();
const labelList zoneIDs = findStrings(zones_, fZones.names());