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

Merge branch 'feature-solid-body-mesh-motion-optimisation' into 'develop'

Browse Source 
New solid body motion mesh update optimisations

See merge request Development/openfoam!537
This commit is contained in:
Mattijs Janssens
2022-05-19 16:19:47 +00:00
parent 6e644a1e8b b6390c2b75
commit a11b5f2310
43 changed files with 1115 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/OpenFOAM/containers/Lists/ListOps/ListOps.H
View File

@ -217,6 +217,10 @@ void uniqueOrder
);
//- Return sorted list with removal of duplicates
template<class T>
List<T> uniqueSort(const UList<T>& input);
//- Inplace sorting and removal of duplicates.
// Do not use FixedList for the input list, since it doesn't resize.
template<class ListType>

27
src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
View File

@ -424,6 +424,33 @@ void Foam::uniqueOrder
}
template<class T>
Foam::List<T> Foam::uniqueSort(const UList<T>& input)
{
List<T> output(input);
const label len = output.size();
if (len > 1)
{
Foam::stableSort(output);
label count = 0;
for (label i = 1; i < len; ++i)
{
if (output[count] != output[i])
{
output[++count] = output[i];
}
}
output.resize(count+1);
}
return output;
}
template<class ListType>
void Foam::inplaceUniqueSort(ListType& input)
{

23
src/OpenFOAM/meshes/polyMesh/polyMesh.C
View File

@ -1156,10 +1156,7 @@ const Foam::pointField& Foam::polyMesh::oldCellCentres() const
}
Foam::tmp<Foam::scalarField> Foam::polyMesh::movePoints
(
const pointField& newPoints
)
void Foam::polyMesh::movePoints(const pointField& newPoints)
{
DebugInFunction
<< "Moving points for time " << time().value()
@ -1227,11 +1224,17 @@ Foam::tmp<Foam::scalarField> Foam::polyMesh::movePoints
tetBasePtIsPtr_->eventNo() = getEvent();
}
tmp<scalarField> sweptVols = primitiveMesh::movePoints
(
points_,
oldPoints()
);
// Currently a no-op; earlier versions set meshPhi and call
// primitiveMesh::clearGeom
(void)primitiveMesh::movePoints(points_, oldPoints());
// Update the mesh geometry (via fvGeometryScheme)
// - updateGeom is virtual -> calls fvMesh::updateGeom (or higher)
// - fvMesh::updateGeom defers to surfaceInterpolation::updateGeom(),
// which defers to fvGeometryScheme::movePoints()
// - set the mesh flux
// - clear out/recalculate stale geometry
updateGeom();
// Adjust parallel shared points
if (globalMeshDataPtr_)
@ -1279,8 +1282,6 @@ Foam::tmp<Foam::scalarField> Foam::polyMesh::movePoints
// e.g. fvMesh::write since meshPhi not yet complete.
polyMesh::write();
}
return sweptVols;
}

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

@ -556,8 +556,8 @@ public:
return (moving() || topoChanging());
}
//- Move points, returns volumes swept by faces in motion
virtual tmp<scalarField> movePoints(const pointField&);
//- Move points
virtual void movePoints(const pointField&);
//- Reset motion
void resetMotion() const;

40
src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -136,7 +137,7 @@ bool Foam::primitiveMesh::calcPointOrder
// Internal points are points that are not used by a boundary face.
// Map from old to new position
oldToNew.setSize(nPoints);
oldToNew.resize_nocopy(nPoints);
oldToNew = -1;
@ -144,14 +145,12 @@ bool Foam::primitiveMesh::calcPointOrder
// from 0 inside oldToNew. (shifted up later on)
label nBoundaryPoints = 0;
for (label facei = nInternalFaces; facei < faces.size(); facei++)
for (label facei = nInternalFaces; facei < faces.size(); ++facei)
{
const face& f = faces[facei];
forAll(f, fp)
for (label pointi : f)
{
label pointi = f[fp];
if (oldToNew[pointi] == -1)
{
oldToNew[pointi] = nBoundaryPoints++;
@ -184,10 +183,8 @@ bool Foam::primitiveMesh::calcPointOrder
{
const face& f = faces[facei];
forAll(f, fp)
for (label pointi : f)
{
label pointi = f[fp];
if (oldToNew[pointi] == -1)
{
if (pointi >= nInternalPoints)
@ -318,35 +315,17 @@ void Foam::primitiveMesh::resetGeometry
}
Foam::tmp<Foam::scalarField> Foam::primitiveMesh::movePoints
void Foam::primitiveMesh::movePoints
(
const pointField& newPoints,
const pointField& oldPoints
)
{
if (newPoints.size() < nPoints() || oldPoints.size() < nPoints())
{
FatalErrorInFunction
<< "Cannot move points: size of given point list smaller "
<< "than the number of active points"
<< abort(FatalError);
}
// Create swept volumes
const faceList& fcs = faces();
auto tsweptVols = tmp<scalarField>::New(fcs.size());
auto& sweptVols = tsweptVols.ref();
forAll(fcs, facei)
{
sweptVols[facei] = fcs[facei].sweptVol(oldPoints, newPoints);
}
// Note: the following clearout is now handled by the fvGeometryScheme
// triggered by the call to updateGeom() in polyMesh::movePoints
// Force recalculation of all geometric data with new points
clearGeom();
return tsweptVols;
//clearGeom();
}
@ -361,7 +340,6 @@ const Foam::cellShapeList& Foam::primitiveMesh::cellShapes() const
}
void Foam::primitiveMesh::updateGeom()
{
if (!faceCentresPtr_ || !faceAreasPtr_)

6
src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018 OpenCFD Ltd.
Copyright (C) 2018-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -598,8 +598,8 @@ public:
// Mesh motion
//- Move points, returns volumes swept by faces in motion
tmp<scalarField> movePoints
//- Move points
void movePoints
(
const pointField& p,
const pointField& oldP

5
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCellCentresAndVols.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -52,11 +53,11 @@ void Foam::primitiveMesh::calcCellCentresAndVols() const
}
// set the accumulated cell centre to zero vector
cellCentresPtr_ = new vectorField(nCells());
cellCentresPtr_ = new vectorField(nCells(), Zero);
vectorField& cellCtrs = *cellCentresPtr_;
// Initialise cell volumes to 0
cellVolumesPtr_ = new scalarField(nCells());
cellVolumesPtr_ = new scalarField(nCells(), Zero);
scalarField& cellVols = *cellVolumesPtr_;
// Make centres and volumes

172
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshTools.C
View File

@ -34,6 +34,172 @@ License
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
void Foam::primitiveMeshTools::updateFaceCentresAndAreas
(
const primitiveMesh& mesh,
const UList<label>& faceIDs,
const pointField& p,
vectorField& fCtrs,
vectorField& fAreas
)
{
const faceList& fs = mesh.faces();
for (const label facei : faceIDs)
{
const labelList& f = fs[facei];
const label nPoints = f.size();
// If the face is a triangle, do a direct calculation for efficiency
// and to avoid round-off error-related problems
if (nPoints == 3)
{
fCtrs[facei] = (1.0/3.0)*(p[f[0]] + p[f[1]] + p[f[2]]);
fAreas[facei] = 0.5*((p[f[1]] - p[f[0]])^(p[f[2]] - p[f[0]]));
}
else
{
typedef Vector<solveScalar> solveVector;
solveVector sumN = Zero;
solveScalar sumA = 0.0;
solveVector sumAc = Zero;
solveVector fCentre = p[f[0]];
for (label pi = 1; pi < nPoints; ++pi)
{
fCentre += solveVector(p[f[pi]]);
}
fCentre /= nPoints;
for (label pi = 0; pi < nPoints; ++pi)
{
const label nextPi(pi == nPoints-1 ? 0 : pi+1);
const solveVector nextPoint(p[f[nextPi]]);
const solveVector thisPoint(p[f[pi]]);
solveVector c = thisPoint + nextPoint + fCentre;
solveVector n = (nextPoint - thisPoint)^(fCentre - thisPoint);
solveScalar a = mag(n);
sumN += n;
sumA += a;
sumAc += a*c;
}
// This is to deal with zero-area faces. Mark very small faces
// to be detected in e.g., processorPolyPatch.
if (sumA < ROOTVSMALL)
{
fCtrs[facei] = fCentre;
fAreas[facei] = Zero;
}
else
{
fCtrs[facei] = (1.0/3.0)*sumAc/sumA;
fAreas[facei] = 0.5*sumN;
}
}
}
}
void Foam::primitiveMeshTools::updateCellCentresAndVols
(
const primitiveMesh& mesh,
const vectorField& fCtrs,
const vectorField& fAreas,
const List<label>& cellIDs,
const List<cell>& cells,
vectorField& cellCtrs_s,
scalarField& cellVols_s
)
{
typedef Vector<solveScalar> solveVector;
PrecisionAdaptor<solveVector, vector> tcellCtrs(cellCtrs_s, false);
PrecisionAdaptor<solveScalar, scalar> tcellVols(cellVols_s, false);
Field<solveVector>& cellCtrs = tcellCtrs.ref();
Field<solveScalar>& cellVols = tcellVols.ref();
// Use current cell centres as estimates for the new cell centres
// Note - not currently used
// - Introduces a small difference (seen when write precision extended to
// 16) to the cell centre and volume values, typically last 4 digits
//const vectorField Cc0(cellCtrs, cellIDs);
// Estimate cell centres using current face centres
// - Same method as used by makeCellCentresAndVols()
vectorField Cc0(cellIDs.size(), Zero);
{
labelField nCellFaces(cellIDs.size(), Zero);
const auto& cells = mesh.cells();
forAll(cellIDs, i)
{
const label celli = cellIDs[i];
const cell& c = cells[celli];
for (const auto facei : c)
{
Cc0[i] += fCtrs[facei];
++nCellFaces[i];
}
}
forAll(Cc0, i)
{
Cc0[i] /= nCellFaces[i];
}
}
// Clear the fields for accumulation
for (const label celli : cellIDs)
{
cellCtrs[celli] = Zero;
cellVols[celli] = Zero;
}
const auto& own = mesh.faceOwner();
forAll(cellIDs, i)
{
const label celli = cellIDs[i];
const auto& c = cells[celli];
const solveVector cc(Cc0[i]);
for (const label facei : c)
{
const solveVector fc(fCtrs[facei]);
const solveVector fA(fAreas[facei]);
const solveScalar pyr3Vol = own[facei] == celli
? fA & (fc - cc)
: fA & (cc - fc);
// Calculate face-pyramid centre
const solveVector pc = (3.0/4.0)*fc + (1.0/4.0)*cc;
// Accumulate volume-weighted face-pyramid centre
cellCtrs[celli] += pyr3Vol*pc;
// Accumulate face-pyramid volume
cellVols[celli] += pyr3Vol;
}
if (mag(cellVols[celli]) > VSMALL)
{
cellCtrs[celli] /= cellVols[celli];
cellVols[celli] *= (1.0/3.0);
}
else
{
cellCtrs[celli] = Cc0[i];
}
}
}
void Foam::primitiveMeshTools::makeFaceCentresAndAreas
(
const UList<face>& fcs,
@ -164,8 +330,7 @@ void Foam::primitiveMeshTools::makeCellCentresAndVols
const solveVector fA(fAreas[facei]);
// Calculate 3*face-pyramid volume
solveScalar pyr3Vol =
fA & (fc - cEst[own[facei]]);
solveScalar pyr3Vol = fA & (fc - cEst[own[facei]]);
// Calculate face-pyramid centre
solveVector pc = (3.0/4.0)*fc + (1.0/4.0)*cEst[own[facei]];
@ -183,8 +348,7 @@ void Foam::primitiveMeshTools::makeCellCentresAndVols
const solveVector fA(fAreas[facei]);
// Calculate 3*face-pyramid volume
solveScalar pyr3Vol =
fA & (cEst[nei[facei]] - fc);
solveScalar pyr3Vol = fA & (cEst[nei[facei]] - fc);
// Calculate face-pyramid centre
solveVector pc = (3.0/4.0)*fc + (1.0/4.0)*cEst[nei[facei]];

25
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshCheck/primitiveMeshTools.H
View File

@ -48,6 +48,7 @@ namespace Foam
{
// Forward Declarations
class cell;
class face;
class primitiveMesh;
@ -59,6 +60,28 @@ class primitiveMeshTools
{
public:
//- Update face centres and areas for the faces in the set faceIDs
static void updateFaceCentresAndAreas
(
const primitiveMesh& mesh,
const UList<label>& faceIDs,
const pointField& p,
vectorField& fCtrs,
vectorField& fAreas
);
//- Update cell centres and volumes for the cells in the set cellIDs
static void updateCellCentresAndVols
(
const primitiveMesh& mesh,
const vectorField& fCtrs,
const vectorField& fAreas,
const List<label>& cellIDs,
const List<cell>& cells,
vectorField& cellCtrs_s,
scalarField& cellVols_s
);
//- Calculate face centres and areas for specified faces.
// Adjusts the lengths of centres and area normals if required.
static void makeFaceCentresAndAreas
@ -117,7 +140,7 @@ public:
const vectorField& cellCtrs
);
//- Generate cell openness and cell ascpect ratio field
//- Generate cell openness and cell aspect ratio field
static void cellClosedness
(
const primitiveMesh& mesh,

1
src/OpenFOAM/meshes/primitiveMesh/primitiveMeshFaceCentresAndAreas.C
View File

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.

4
src/dynamicFvMesh/dynamicFvMesh/dynamicFvMesh.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2012 OpenFOAM Foundation
Copyright (C) 2018-2020 OpenCFD Ltd.
Copyright (C) 2018-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -27,6 +27,7 @@ License
\*---------------------------------------------------------------------------*/
#include "dynamicFvMesh.H"
#include "profiling.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -174,6 +175,7 @@ bool Foam::dynamicFvMesh::controlledUpdate()
<< timeControl_.type() << nl;
}
addProfiling(mesh, "mesh.update()");
return this->update();
}

10
src/dynamicFvMesh/dynamicMotionSolverFvMesh/dynamicMotionSolverFvMesh.C
View File

@ -30,6 +30,7 @@ License
#include "addToRunTimeSelectionTable.H"
#include "motionSolver.H"
#include "volFields.H"
#include "zoneMotion.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -104,12 +105,6 @@ Foam::dynamicMotionSolverFvMesh::dynamicMotionSolverFvMesh
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::dynamicMotionSolverFvMesh::~dynamicMotionSolverFvMesh()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
const Foam::motionSolver& Foam::dynamicMotionSolverFvMesh::motion() const
@ -120,9 +115,6 @@ const Foam::motionSolver& Foam::dynamicMotionSolverFvMesh::motion() const
bool Foam::dynamicMotionSolverFvMesh::update()
{
// Scan through AMI patches and update
fvMesh::movePoints(motionPtr_->newPoints());
volVectorField* Uptr = getObjectPtr<volVectorField>("U");

2
src/dynamicFvMesh/dynamicMotionSolverFvMesh/dynamicMotionSolverFvMesh.H
View File

@ -94,7 +94,7 @@ public:
//- Destructor
~dynamicMotionSolverFvMesh();
virtual ~dynamicMotionSolverFvMesh() = default;
// Member Functions

2
src/dynamicFvMesh/simplifiedDynamicFvMesh/simplifiedDynamicFvMeshes.C
View File

@ -29,7 +29,7 @@ License
#include "simplifiedDynamicFvMesh.H"
#include "staticFvMesh.H"
#include "dynamicMotionSolverFvMesh.H"
#include "motionSolver.H"
namespace Foam
{

6
src/dynamicMesh/motionSolvers/displacement/displacement/displacementMotionSolver.C
View File

@ -134,10 +134,4 @@ Foam::displacementMotionSolver::New
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::displacementMotionSolver::~displacementMotionSolver()
{}
// ************************************************************************* //

2
src/dynamicMesh/motionSolvers/displacement/displacement/displacementMotionSolver.H
View File

@ -133,7 +133,7 @@ public:
//- Destructor
virtual ~displacementMotionSolver();
virtual ~displacementMotionSolver() = default;
// Member Functions

10
src/dynamicMesh/motionSolvers/displacement/displacement/zoneMotion.C
View File

@ -98,16 +98,14 @@ Foam::zoneMotion::zoneMotion
{
boolList movePts(mesh.nPoints(), false);
forAll(cellIDs, i)
for (label celli : cellIDs)
{
label celli = cellIDs[i];
const cell& c = mesh.cells()[celli];
forAll(c, j)
for (label cellFacei : c)
{
const face& f = mesh.faces()[c[j]];
forAll(f, k)
const face& f = mesh.faces()[cellFacei];
for (label pointi : f)
{
label pointi = f[k];
movePts[pointi] = true;
}
}

6
src/dynamicMesh/motionSolvers/displacement/points0/points0MotionSolver.C
View File

@ -142,12 +142,6 @@ Foam::points0MotionSolver::points0MotionSolver
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::points0MotionSolver::~points0MotionSolver()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::points0MotionSolver::movePoints(const pointField&)

2
src/dynamicMesh/motionSolvers/displacement/points0/points0MotionSolver.H
View File

@ -106,7 +106,7 @@ public:
//- Destructor
virtual ~points0MotionSolver();
virtual ~points0MotionSolver() = default;
// Member Functions

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

@ -133,12 +133,6 @@ Foam::multiSolidBodyMotionSolver::multiSolidBodyMotionSolver
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::multiSolidBodyMotionSolver::~multiSolidBodyMotionSolver()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::pointField> Foam::multiSolidBodyMotionSolver::curPoints() const

2
src/dynamicMesh/motionSolvers/displacement/solidBody/multiSolidBodyMotionSolver.H
View File

@ -92,7 +92,7 @@ public:
//- Destructor
~multiSolidBodyMotionSolver();
virtual ~multiSolidBodyMotionSolver() = default;
// Member Functions

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

@ -118,16 +118,14 @@ Foam::solidBodyMotionSolver::solidBodyMotionSolver
boolList movePts(mesh.nPoints(), false);
forAll(cellIDs, i)
for (label celli : cellIDs)
{
label celli = cellIDs[i];
const cell& c = mesh.cells()[celli];
forAll(c, j)
for (label cellFacei : c)
{
const face& f = mesh.faces()[c[j]];
forAll(f, k)
const face& f = mesh.faces()[cellFacei];
for (label pointi : f)
{
label pointi = f[k];
movePts[pointi] = true;
}
}
@ -149,12 +147,6 @@ Foam::solidBodyMotionSolver::solidBodyMotionSolver
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::solidBodyMotionSolver::~solidBodyMotionSolver()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
Foam::tmp<Foam::pointField> Foam::solidBodyMotionSolver::curPoints() const
@ -165,7 +157,7 @@ Foam::tmp<Foam::pointField> Foam::solidBodyMotionSolver::curPoints() const
}
else
{
tmp<pointField> ttransformedPts(new pointField(mesh().points()));
auto ttransformedPts = tmp<pointField>::New(mesh().points());
pointField& transformedPts = ttransformedPts.ref();
UIndirectList<point>(transformedPts, pointIDs_) = transformPoints

2
src/dynamicMesh/motionSolvers/displacement/solidBody/solidBodyMotionSolver.H
View File

@ -92,7 +92,7 @@ public:
//- Destructor
~solidBodyMotionSolver();
virtual ~solidBodyMotionSolver() = default;
// Member Functions

1
src/finiteVolume/Make/files
View File

@ -8,6 +8,7 @@ $(fvGeometryScheme)/highAspectRatio/highAspectRatioFvGeometryScheme.C
$(fvGeometryScheme)/highAspectRatio/cellAspectRatio.C
$(fvGeometryScheme)/averageNeighbour/averageNeighbourFvGeometryScheme.C
$(fvGeometryScheme)/stabilised/stabilisedFvGeometryScheme.C
$(fvGeometryScheme)/solidBody/solidBodyFvGeometryScheme.C
surfaceInterpolation = interpolation/surfaceInterpolation
$(surfaceInterpolation)/surfaceInterpolation/surfaceInterpolation.C

65
src/finiteVolume/fvMesh/fvGeometryScheme/basic/basicFvGeometryScheme.C
View File

@ -55,11 +55,14 @@ Foam::basicFvGeometryScheme::basicFvGeometryScheme
void Foam::basicFvGeometryScheme::movePoints()
{
fvGeometryScheme::movePoints();
if (debug)
{
Pout<< "basicFvGeometryScheme::movePoints() : "
<< "recalculating primitiveMesh centres" << endl;
}
// Use lower level to calculate the geometry
const_cast<fvMesh&>(mesh_).primitiveMesh::updateGeom();
}
@ -74,9 +77,8 @@ Foam::tmp<Foam::surfaceScalarField> Foam::basicFvGeometryScheme::weights() const
<< endl;
}
tmp<surfaceScalarField> tweights
(
new surfaceScalarField
auto tweights =
tmp<surfaceScalarField>::New
(
IOobject
(
@ -89,9 +91,9 @@ Foam::tmp<Foam::surfaceScalarField> Foam::basicFvGeometryScheme::weights() const
),
mesh_,
dimless
)
);
surfaceScalarField& weights = tweights.ref();
);
auto& weights = tweights.ref();
weights.setOriented();
// Set local references to mesh data
@ -128,7 +130,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::basicFvGeometryScheme::weights() const
}
}
surfaceScalarField::Boundary& wBf = weights.boundaryFieldRef();
auto& wBf = weights.boundaryFieldRef();
forAll(mesh_.boundary(), patchi)
{
@ -159,9 +161,8 @@ Foam::basicFvGeometryScheme::deltaCoeffs() const
// needed to make sure deltaCoeffs are calculated for parallel runs.
(void)mesh_.weights();
tmp<surfaceScalarField> tdeltaCoeffs
(
new surfaceScalarField
auto tdeltaCoeffs =
tmp<surfaceScalarField>::New
(
IOobject
(
@ -174,14 +175,14 @@ Foam::basicFvGeometryScheme::deltaCoeffs() const
),
mesh_,
dimless/dimLength
)
);
surfaceScalarField& deltaCoeffs = tdeltaCoeffs.ref();
);
auto& deltaCoeffs = tdeltaCoeffs.ref();
deltaCoeffs.setOriented();
// Set local references to mesh data
const volVectorField& C = mesh_.C();
const vectorField& C = mesh_.cellCentres();
const labelUList& owner = mesh_.owner();
const labelUList& neighbour = mesh_.neighbour();
@ -190,8 +191,7 @@ Foam::basicFvGeometryScheme::deltaCoeffs() const
deltaCoeffs[facei] = 1.0/mag(C[neighbour[facei]] - C[owner[facei]]);
}
surfaceScalarField::Boundary& deltaCoeffsBf =
deltaCoeffs.boundaryFieldRef();
auto& deltaCoeffsBf = deltaCoeffs.boundaryFieldRef();
forAll(deltaCoeffsBf, patchi)
{
@ -220,9 +220,8 @@ Foam::basicFvGeometryScheme::nonOrthDeltaCoeffs() const
// needed to make sure deltaCoeffs are calculated for parallel runs.
weights();
tmp<surfaceScalarField> tnonOrthDeltaCoeffs
(
new surfaceScalarField
auto tnonOrthDeltaCoeffs =
tmp<surfaceScalarField>::New
(
IOobject
(
@ -235,9 +234,9 @@ Foam::basicFvGeometryScheme::nonOrthDeltaCoeffs() const
),
mesh_,
dimless/dimLength
)
);
surfaceScalarField& nonOrthDeltaCoeffs = tnonOrthDeltaCoeffs.ref();
);
auto& nonOrthDeltaCoeffs = tnonOrthDeltaCoeffs.ref();
nonOrthDeltaCoeffs.setOriented();
@ -266,8 +265,7 @@ Foam::basicFvGeometryScheme::nonOrthDeltaCoeffs() const
nonOrthDeltaCoeffs[facei] = 1.0/max(unitArea & delta, 0.05*mag(delta));
}
surfaceScalarField::Boundary& nonOrthDeltaCoeffsBf =
nonOrthDeltaCoeffs.boundaryFieldRef();
auto& nonOrthDeltaCoeffsBf = nonOrthDeltaCoeffs.boundaryFieldRef();
forAll(nonOrthDeltaCoeffsBf, patchi)
{
@ -306,9 +304,8 @@ Foam::basicFvGeometryScheme::nonOrthCorrectionVectors() const
<< endl;
}
tmp<surfaceVectorField> tnonOrthCorrectionVectors
(
new surfaceVectorField
auto tnonOrthCorrectionVectors =
tmp<surfaceVectorField>::New
(
IOobject
(
@ -321,9 +318,9 @@ Foam::basicFvGeometryScheme::nonOrthCorrectionVectors() const
),
mesh_,
dimless
)
);
surfaceVectorField& corrVecs = tnonOrthCorrectionVectors.ref();
);
auto& corrVecs = tnonOrthCorrectionVectors.ref();
corrVecs.setOriented();
// Set local references to mesh data
@ -337,8 +334,8 @@ Foam::basicFvGeometryScheme::nonOrthCorrectionVectors() const
forAll(owner, facei)
{
vector unitArea = Sf[facei]/magSf[facei];
vector delta = C[neighbour[facei]] - C[owner[facei]];
vector unitArea(Sf[facei]/magSf[facei]);
vector delta(C[neighbour[facei]] - C[owner[facei]]);
corrVecs[facei] = unitArea - delta*NonOrthDeltaCoeffs[facei];
}
@ -347,7 +344,7 @@ Foam::basicFvGeometryScheme::nonOrthCorrectionVectors() const
// and calculated consistently with internal corrections for
// coupled patches
surfaceVectorField::Boundary& corrVecsBf = corrVecs.boundaryFieldRef();
auto& corrVecsBf = corrVecs.boundaryFieldRef();
forAll(corrVecsBf, patchi)
{
@ -361,7 +358,7 @@ Foam::basicFvGeometryScheme::nonOrthCorrectionVectors() const
}
else
{
const fvsPatchScalarField& patchNonOrthDeltaCoeffs =
const auto& patchNonOrthDeltaCoeffs =
NonOrthDeltaCoeffs.boundaryField()[patchi];
const vectorField patchDeltas(mesh_.boundary()[patchi].delta());

84
src/finiteVolume/fvMesh/fvGeometryScheme/fvGeometryScheme/fvGeometryScheme.C
View File

@ -26,6 +26,8 @@ License
\*---------------------------------------------------------------------------*/
#include "fvGeometryScheme.H"
#include "fvMesh.H"
#include "surfaceFields.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -37,10 +39,63 @@ namespace Foam
}
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
bool Foam::fvGeometryScheme::setMeshPhi() const
{
if (!mesh_.moving())
{
return false;
}
const pointField& oldPoints = mesh_.oldPoints();
const pointField& currPoints = mesh_.points();
if (oldPoints.size() != currPoints.size())
{
FatalErrorInFunction
<< "Old and current points sizes must be the same. "
<< "Old points:" << oldPoints.size()
<< " Current points:" << currPoints.size()
<< abort(FatalError);
}
const faceList& faces = mesh_.faces();
const scalar rdt = 1.0/mesh_.time().deltaTValue();
auto& meshPhi = const_cast<fvMesh&>(mesh_).setPhi();
auto& meshPhii = meshPhi.primitiveFieldRef();
forAll(meshPhii, facei)
{
const face& f = faces[facei];
meshPhii[facei] = f.sweptVol(oldPoints, currPoints)*rdt;
}
auto& meshPhiBf = meshPhi.boundaryFieldRef();
for (auto& meshPhip : meshPhiBf)
{
if (!meshPhip.size())
{
// Empty patches
continue;
}
const auto& pp = meshPhip.patch().patch();
forAll(pp, facei)
{
const face& f = pp[facei];
meshPhip[facei] = f.sweptVol(oldPoints, currPoints)*rdt;
}
}
return true;
}
// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
Foam::tmp<Foam::fvGeometryScheme>
Foam::fvGeometryScheme::New
Foam::tmp<Foam::fvGeometryScheme> Foam::fvGeometryScheme::New
(
const fvMesh& mesh,
const dictionary& dict,
@ -55,10 +110,7 @@ Foam::fvGeometryScheme::New
: dict.getOrDefault<word>("type", defaultScheme)
);
if (debug)
{
InfoInFunction << "Geometry scheme = " << schemeName << endl;
}
DebugInFunction << "Geometry scheme = " << schemeName << endl;
auto* ctorPtr = dictConstructorTable(schemeName);
@ -77,4 +129,24 @@ Foam::fvGeometryScheme::New
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::fvGeometryScheme::movePoints()
{
if (mesh_.moving())
{
// Set the mesh motion fluxes
setMeshPhi();
// Clear out old geometry
// Note: this recreates the old primitiveMesh::movePoints behaviour
const_cast<fvMesh&>(mesh_).primitiveMesh::clearGeom();
}
}
void Foam::fvGeometryScheme::updateMesh(const mapPolyMesh& mpm)
{}
// ************************************************************************* //

16
src/finiteVolume/fvMesh/fvGeometryScheme/fvGeometryScheme/fvGeometryScheme.H
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2020 OpenCFD Ltd.
Copyright (C) 2020-2021 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -69,10 +69,18 @@ class fvGeometryScheme
protected:
// Protected Data
//- Hold reference to mesh
const fvMesh& mesh_;
// Protected Member Functions
//- Set the mesh motion flux
bool setMeshPhi() const;
public:
//- Runtime type information
@ -127,8 +135,10 @@ public:
}
//- Update basic geometric properties from provided points
virtual void movePoints()
{}
virtual void movePoints();
//- Update mesh for topology changes
virtual void updateMesh(const mapPolyMesh& mpm);
//- Return linear difference weighting factors
virtual tmp<surfaceScalarField> weights() const = 0;

3
src/finiteVolume/fvMesh/fvGeometryScheme/highAspectRatio/highAspectRatioFvGeometryScheme.C
View File

@ -387,6 +387,9 @@ Foam::highAspectRatioFvGeometryScheme::highAspectRatioFvGeometryScheme
void Foam::highAspectRatioFvGeometryScheme::movePoints()
{
//basicFvGeometryScheme::movePoints();
fvGeometryScheme::movePoints();
if (debug)
{
Pout<< "highAspectRatioFvGeometryScheme::movePoints() : "

341
src/finiteVolume/fvMesh/fvGeometryScheme/solidBody/solidBodyFvGeometryScheme.C Normal file
View File

@ -0,0 +1,341 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "solidBodyFvGeometryScheme.H"
#include "addToRunTimeSelectionTable.H"
#include "surfaceFields.H"
#include "primitiveMeshTools.H"
#include "emptyPolyPatch.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(solidBodyFvGeometryScheme, 0);
addToRunTimeSelectionTable
(
fvGeometryScheme,
solidBodyFvGeometryScheme,
dict
);
}
void Foam::solidBodyFvGeometryScheme::setMeshMotionData()
{
if (!cacheInitialised_ || !cacheMotion_)
{
DebugInFunction << "Creating cache" << endl;
changedFaceIDs_.clear(); // used for face areas, meshPhi
changedPatchIDs_.clear(); // used for meshPhi
changedCellIDs_.clear(); // used for cell volumes
const pointField& oldPoints = mesh_.oldPoints();
const pointField& currPoints = mesh_.points();
if (oldPoints.size() != currPoints.size())
{
FatalErrorInFunction
<< "Old and current points sizes must be the same. "
<< "Old points:" << oldPoints.size()
<< " Current points:" << currPoints.size()
<< abort(FatalError);
}
bitSet changedPoints(oldPoints.size());
// Check for non-identical points
forAll(changedPoints, pointi)
{
changedPoints.set(pointi, oldPoints[pointi] != currPoints[pointi]);
}
DebugInfo
<< "SBM --- Changed points:"
<< returnReduce(changedPoints.count(), sumOp<label>())
<< endl;
// Quick return if no points have moved
if (returnReduce(changedPoints.none(), andOp<label>()))
{
return;
}
bitSet cellIDs(mesh_.nCells());
bitSet faceIDs(mesh_.nFaces());
const auto& pointFaces = mesh_.pointFaces();
const auto& own = mesh_.faceOwner();
const auto& nbr = mesh_.faceNeighbour();
// Identify faces and cells attached to moving points
for (const label pointi : changedPoints)
{
for (const auto facei : pointFaces[pointi])
{
faceIDs.set(facei);
cellIDs.set(own[facei]);
if (facei < mesh_.nInternalFaces())
{
cellIDs.set(nbr[facei]);
}
}
}
changedCellIDs_ = cellIDs.toc();
DebugInfo
<< "SBM --- Changed cells:"
<< returnReduce(changedCellIDs_.size(), sumOp<label>())
<< endl;
// Construct face and patch ID info
const auto changedFaceFlag = faceIDs.values();
DynamicList<label> changedFaceIDs(faceIDs.count());
DynamicList<label> changedPatchIDs(faceIDs.count());
for (label facei = 0; facei < mesh_.nInternalFaces(); ++facei)
{
if (changedFaceFlag[facei])
{
changedFaceIDs.append(facei);
changedPatchIDs.append(-1);
}
}
const auto& pbm = mesh_.boundaryMesh();
for (label patchi = 0; patchi < pbm.size(); ++patchi)
{
const polyPatch& pp = pbm[patchi];
for (const label meshFacei : pp.range())
{
if (changedFaceFlag[meshFacei])
{
changedFaceIDs.append(meshFacei);
changedPatchIDs.append(patchi);
}
}
}
changedFaceIDs_.transfer(changedFaceIDs);
changedPatchIDs_.transfer(changedPatchIDs);
}
cacheInitialised_ = true;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::solidBodyFvGeometryScheme::solidBodyFvGeometryScheme
(
const fvMesh& mesh,
const dictionary& dict
)
:
basicFvGeometryScheme(mesh, dict),
partialUpdate_(dict.getOrDefault<bool>("partialUpdate", true)),
cacheMotion_(dict.getOrDefault<bool>("cacheMotion", true)),
cacheInitialised_(false),
changedFaceIDs_(),
changedPatchIDs_(),
changedCellIDs_()
{
DebugInFunction
<< "partialUpdate:" << partialUpdate_
<< " cacheMotion:" << cacheMotion_
<< endl;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::solidBodyFvGeometryScheme::movePoints()
{
// Note: not calling fvGeometryScheme::movePoints since we want to perform
// our own geometry manipulations
bool haveGeometry =
mesh_.hasCellCentres()
&& mesh_.hasFaceCentres()
&& mesh_.hasCellVolumes()
&& mesh_.hasFaceAreas();
if (!haveGeometry)
{
DebugInFunction
<< "Creating initial geometry using primitiveMesh::updateGeom"
<< endl;
const_cast<fvMesh&>(mesh_).primitiveMesh::updateGeom();
return;
}
if (mesh_.moving())
{
setMeshMotionData();
DebugInFunction << "Performing partial meshPhi construction" << endl;
const pointField& oldPoints = mesh_.oldPoints();
const pointField& currPoints = mesh_.points();
if (oldPoints.size() != currPoints.size())
{
FatalErrorInFunction
<< "Old and current points sizes must be the same. "
<< "Old points:" << oldPoints.size()
<< " Current points:" << currPoints.size()
<< abort(FatalError);
}
const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
const faceList& faces = mesh_.faces();
const scalar rdt = 1.0/mesh_.time().deltaTValue();
// Set the mesh flux
auto& meshPhi = const_cast<fvMesh&>(mesh_).setPhi();
auto& meshPhii = meshPhi.primitiveFieldRef();
auto& meshPhiBf = meshPhi.boundaryFieldRef();
//meshPhi == dimensionedScalar(dimVolume/dimTime, Zero);
meshPhii = Zero;
meshPhiBf == Zero;
forAll(changedFaceIDs_, i)
{
const face& f = faces[changedFaceIDs_[i]];
if (changedPatchIDs_[i] == -1)
{
const label facei = changedFaceIDs_[i];
meshPhii[facei] = f.sweptVol(oldPoints, currPoints)*rdt;
}
else
{
const label patchi = changedPatchIDs_[i];
const polyPatch& pp = pbm[patchi];
if (isA<emptyPolyPatch>(pp))
{
continue;
}
const label patchFacei = changedFaceIDs_[i] - pp.start();
meshPhiBf[patchi][patchFacei] =
f.sweptVol(oldPoints, currPoints)*rdt;
}
}
if (partialUpdate_ && haveGeometry)
{
// Keep base geometry and update as needed
DebugInFunction << "Performing partial geometry update" << endl;
// Initialise geometry using the old/existing values
vectorField faceCentres(mesh_.faceCentres());
vectorField faceAreas(mesh_.faceAreas());
// Make face centres and areas consistent with new points
primitiveMeshTools::updateFaceCentresAndAreas
(
mesh_,
changedFaceIDs_,
mesh_.points(),
faceCentres,
faceAreas
);
vectorField cellCentres(mesh_.cellCentres());
scalarField cellVolumes(mesh_.cellVolumes());
primitiveMeshTools::updateCellCentresAndVols
(
mesh_,
faceCentres,
faceAreas,
changedCellIDs_,
mesh_.cells(),
cellCentres,
cellVolumes
);
const_cast<fvMesh&>(mesh_).primitiveMesh::resetGeometry
(
std::move(faceCentres),
std::move(faceAreas),
std::move(cellCentres),
std::move(cellVolumes)
);
if (debug)
{
for (const auto& p : mesh_.boundaryMesh())
{
Pout<< "SBM --- " << p.name()
<< " sum(Sf)=" << sum(p.faceAreas())
<< " sum(mag(Sf))=" << sum(mag(p.faceAreas()))
<< endl;
}
}
}
else
{
DebugInFunction
<< "Performing complete geometry clear and update" << endl;
// Clear out old geometry
// Note: this recreates the old primitiveMesh::movePoints behaviour
const_cast<fvMesh&>(mesh_).primitiveMesh::clearGeom();
// Use lower level to calculate the geometry
const_cast<fvMesh&>(mesh_).primitiveMesh::updateGeom();
}
}
else
{
DebugInFunction << "Performing complete geometry update" << endl;
// Use lower level to calculate the geometry
const_cast<fvMesh&>(mesh_).primitiveMesh::updateGeom();
}
}
void Foam::solidBodyFvGeometryScheme::updateMesh(const mapPolyMesh& mpm)
{
cacheInitialised_ = false;
}
// ************************************************************************* //

141
src/finiteVolume/fvMesh/fvGeometryScheme/solidBody/solidBodyFvGeometryScheme.H Normal file
View File

@ -0,0 +1,141 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2021-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::solidBodyFvGeometryScheme
Description
Geometry calculation scheme that performs geometry updates only in regions
where the mesh has changed.
Example usage in fvSchemes:
\verbatim
geometry
{
type solidBody;
// Optional entries
// If set to false, update the entire mesh
partialUpdate yes;
// Cache the motion addressing (changed points, faces, cells etc)
cacheMotion yes;
}
\endverbatim
SourceFiles
solidBodyFvGeometryScheme.C
\*---------------------------------------------------------------------------*/
#ifndef solidBodyFvGeometryScheme_H
#define solidBodyFvGeometryScheme_H
#include "basicFvGeometryScheme.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class solidBodyFvGeometryScheme Declaration
\*---------------------------------------------------------------------------*/
class solidBodyFvGeometryScheme
:
public basicFvGeometryScheme
{
// Private Data
//- Partial update flag
bool partialUpdate_;
//- Cache mesh motion flag
bool cacheMotion_;
//- Flag to indicate that the cache has been initialised
bool cacheInitialised_;
//- Changed face IDs
labelList changedFaceIDs_;
//- Changed patch IDs
labelList changedPatchIDs_;
//- Changed cell IDs
labelList changedCellIDs_;
// Private Member Functions
//- Set the mesh motion data (point, face IDs)
void setMeshMotionData();
//- No copy construct
solidBodyFvGeometryScheme(const solidBodyFvGeometryScheme&) = delete;
//- No copy assignment
void operator=(const solidBodyFvGeometryScheme&) = delete;
public:
//- Runtime type information
TypeName("solidBody");
// Constructors
//- Construct from mesh
solidBodyFvGeometryScheme(const fvMesh& mesh, const dictionary& dict);
//- Destructor
virtual ~solidBodyFvGeometryScheme() = default;
// Member Functions
//- Do what is necessary if the mesh has moved
virtual void movePoints();
//- Update mesh for topology changes
virtual void updateMesh(const mapPolyMesh& mpm);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

2
src/finiteVolume/fvMesh/fvGeometryScheme/stabilised/stabilisedFvGeometryScheme.C
View File

@ -157,6 +157,8 @@ Foam::stabilisedFvGeometryScheme::stabilisedFvGeometryScheme
void Foam::stabilisedFvGeometryScheme::movePoints()
{
fvGeometryScheme::movePoints();
if (debug)
{
Pout<< "stabilisedFvGeometryScheme::movePoints() : "

56
src/finiteVolume/fvMesh/fvMesh.C
View File

@ -90,18 +90,22 @@ void Foam::fvMesh::updateGeomNotOldVol()
{
(void)V();
}
if (haveSf)
{
(void)Sf();
}
if (haveMagSf)
{
(void)magSf();
}
if (haveCP)
{
(void)C();
}
if (haveCf)
{
(void)Cf();
@ -277,7 +281,7 @@ bool Foam::fvMesh::init(const bool doInit)
// doing anything with primitiveMesh::cellCentres etc.
(void)geometry();
// Intialise my data
// Initialise my data
polyMesh::init(doInit);
}
@ -285,6 +289,10 @@ bool Foam::fvMesh::init(const bool doInit)
// and set the storage of V00
if (fileHandler().isFile(time().timePath()/dbDir()/"V0"))
{
// Set the moving flag early in case the demand-driven geometry
// construction checks for it
moving(true);
V0Ptr_ = new DimensionedField<scalar, volMesh>
(
IOobject
@ -306,6 +314,10 @@ bool Foam::fvMesh::init(const bool doInit)
// mesh to be moving
if (fileHandler().isFile(time().timePath()/dbDir()/"meshPhi"))
{
// Set the moving flag early in case the demand-driven geometry
// construction checks for it
moving(true);
phiPtr_ = new surfaceScalarField
(
IOobject
@ -339,8 +351,6 @@ bool Foam::fvMesh::init(const bool doInit)
V()
);
}
moving(true);
}
// Assume something changed
@ -643,7 +653,7 @@ void Foam::fvMesh::removeFvBoundary()
Foam::polyMesh::readUpdateState Foam::fvMesh::readUpdate()
{
DebugInFunction << "Updating fvMesh. ";
DebugInFunction << "Updating fvMesh";
polyMesh::readUpdateState state = polyMesh::readUpdate();
@ -861,7 +871,8 @@ void Foam::fvMesh::mapFields(const mapPolyMesh& meshMap)
}
Foam::tmp<Foam::scalarField> Foam::fvMesh::movePoints(const pointField& p)
void Foam::fvMesh::movePoints(const pointField& p)
{
DebugInFunction << endl;
@ -873,12 +884,8 @@ Foam::tmp<Foam::scalarField> Foam::fvMesh::movePoints(const pointField& p)
}
// Move the polyMesh and set the mesh motion fluxes to the swept-volumes
scalar rDeltaT = 1.0/time().deltaTValue();
tmp<scalarField> tsweptVols = polyMesh::movePoints(p);
scalarField& sweptVols = tsweptVols.ref();
// Move the polyMesh and initialise the mesh motion fluxes field
// Note: mesh flux updated by the fvGeometryScheme
if (!phiPtr_)
{
@ -895,7 +902,7 @@ Foam::tmp<Foam::scalarField> Foam::fvMesh::movePoints(const pointField& p)
false
),
*this,
dimVolume/dimTime
dimensionedScalar(dimVolume/dimTime, Zero)
);
}
else
@ -907,19 +914,7 @@ Foam::tmp<Foam::scalarField> Foam::fvMesh::movePoints(const pointField& p)
}
}
surfaceScalarField& phi = *phiPtr_;
phi.primitiveFieldRef() =
scalarField::subField(sweptVols, nInternalFaces());
phi.primitiveFieldRef() *= rDeltaT;
const fvPatchList& patches = boundary();
surfaceScalarField::Boundary& phibf = phi.boundaryFieldRef();
forAll(patches, patchi)
{
phibf[patchi] = patches[patchi].patchSlice(sweptVols);
phibf[patchi] *= rDeltaT;
}
polyMesh::movePoints(p);
// Update or delete the local geometric properties as early as possible so
// they can be used if necessary. These get recreated here instead of
@ -929,20 +924,21 @@ Foam::tmp<Foam::scalarField> Foam::fvMesh::movePoints(const pointField& p)
// should use the local geometric properties.
updateGeomNotOldVol();
// Update other local data
boundary_.movePoints();
surfaceInterpolation::movePoints();
// Clear weights, deltaCoeffs, nonOrthoDeltaCoeffs, nonOrthCorrectionVectors
surfaceInterpolation::clearOut();
meshObject::movePoints<fvMesh>(*this);
meshObject::movePoints<lduMesh>(*this);
return tsweptVols;
}
void Foam::fvMesh::updateGeom()
{
DebugInFunction << endl;
// Let surfaceInterpolation handle geometry calculation. Note: this does
// lower levels updateGeom
surfaceInterpolation::updateGeom();
@ -1003,7 +999,7 @@ void Foam::fvMesh::updateMesh(const mapPolyMesh& mpm)
mapFields(mpm);
// Clear the current volume and other geometry factors
surfaceInterpolation::clearOut();
surfaceInterpolation::updateMesh(mpm);
// Clear any non-updateable addressing
clearAddressing(true);

2
src/finiteVolume/fvMesh/fvMesh.H
View File

@ -469,7 +469,7 @@ public:
using surfaceInterpolation::movePoints;
//- Move points, returns volumes swept by faces in motion
virtual tmp<scalarField> movePoints(const pointField&);
virtual void movePoints(const pointField&);
//- Update all geometric data. This gets redirected up from
//- primitiveMesh level

23
src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolation/surfaceInterpolation.C
View File

@ -48,6 +48,8 @@ namespace Foam
void Foam::surfaceInterpolation::clearOut()
{
// TBD: potential to apply partial clear out only?
// Move to fvGeometryScheme?
weights_.clear();
deltaCoeffs_.clear();
nonOrthDeltaCoeffs_.clear();
@ -161,10 +163,7 @@ bool Foam::surfaceInterpolation::movePoints()
// Do any primitive geometry calculation
const_cast<fvGeometryScheme&>(geometry()).movePoints();
weights_.clear();
deltaCoeffs_.clear();
nonOrthDeltaCoeffs_.clear();
nonOrthCorrectionVectors_.clear();
clearOut();
return true;
}
@ -179,6 +178,22 @@ void Foam::surfaceInterpolation::updateGeom()
}
const_cast<fvGeometryScheme&>(geometry()).movePoints();
clearOut();
}
void Foam::surfaceInterpolation::updateMesh(const mapPolyMesh& mpm)
{
if (debug)
{
Pout<< "surfaceInterpolation::updateMesh() : "
<< "Updating geometric properties" << endl;
}
const_cast<fvGeometryScheme&>(geometry()).updateMesh(mpm);
clearOut();
}

6
src/finiteVolume/interpolation/surfaceInterpolation/surfaceInterpolation/surfaceInterpolation.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011 OpenFOAM Foundation
Copyright (C) 2020 OpenCFD Ltd.
Copyright (C) 2020-2022 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -52,6 +52,7 @@ namespace Foam
// Forward Declarations
class fvMesh;
class fvGeometryScheme;
class mapPolyMesh;
/*---------------------------------------------------------------------------*\
Class surfaceInterpolation Declaration
@ -141,6 +142,9 @@ public:
//- Has weights
bool hasWeights() const noexcept { return bool(weights_); }
//- Update mesh for topology changes
virtual void updateMesh(const mapPolyMesh& mpm);
};

24
src/functionObjects/utilities/writeObjects/writeObjects.C
View File

@ -60,6 +60,22 @@ Foam::functionObjects::writeObjects::writeOptionNames_
{ writeOption::ANY_WRITE, "anyWrite" },
});
const Foam::objectRegistry& setRegistry
(
const Foam::Time& runTime,
const Foam::dictionary& dict
)
{
const Foam::word regionName =
dict.getOrDefault("region", Foam::polyMesh::defaultRegion);
if (regionName == "__TIME__")
{
return runTime;
}
return runTime.lookupObject<Foam::objectRegistry>(regionName);
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -71,13 +87,7 @@ Foam::functionObjects::writeObjects::writeObjects
)
:
functionObject(name),
obr_
(
runTime.lookupObject<objectRegistry>
(
dict.getOrDefault("region", polyMesh::defaultRegion)
)
),
obr_(setRegistry(runTime, dict)),
writeOption_(ANY_WRITE),
objectNames_()
{

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

@ -1135,6 +1135,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::doRemoveCells
meshMod
);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -1327,6 +1331,10 @@ Foam::label Foam::meshRefinement::splitFacesUndo
// Insert the mesh changes
doSplitFaces(splitFaces, splits, meshMod);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -1339,6 +1347,10 @@ Foam::label Foam::meshRefinement::splitFacesUndo
{
mesh_.movePoints(map.preMotionPoints());
}
else
{
mesh_.clearOut();
}
// Reset the instance for if in overwrite mode
mesh_.setInstance(timeName());
@ -1550,6 +1562,10 @@ Foam::label Foam::meshRefinement::splitFacesUndo
nSplit -= n;
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -1562,6 +1578,10 @@ Foam::label Foam::meshRefinement::splitFacesUndo
{
mesh_.movePoints(map.preMotionPoints());
}
else
{
mesh_.clearOut();
}
// Reset the instance for if in overwrite mode
mesh_.setInstance(timeName());

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

@ -600,6 +600,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createBaffles
autoPtr<mapPolyMesh> mapPtr;
if (returnReduce(nBaffles, sumOp<label>()))
{
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation, parallel sync)
mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -1314,6 +1318,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergeBaffles
}
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -5346,6 +5354,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::dupNonManifoldPoints
// Insert changes into meshMod
pointDuplicator.setRefinement(regionSide, meshMod);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation, parallel sync)
mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -5421,6 +5433,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::mergePoints
// Insert changes
polyMeshAdder::mergePoints(mesh_, pointToMaster, meshMod);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation, parallel sync)
mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -5988,6 +6004,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
meshMod
);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation, parallel sync)
autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);

24
src/mesh/snappyHexMesh/meshRefinement/meshRefinementMerge.C
View File

@ -108,6 +108,10 @@ Foam::label Foam::meshRefinement::mergePatchFaces
// unused points.
faceCombiner.setRefinement(mergeSets, meshMod);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -197,6 +201,10 @@ Foam::label Foam::meshRefinement::mergePatchFaces
//
// pointRemover.setRefinement(pointCanBeDeleted, meshMod);
//
// // Remove any unnecessary fields
// mesh_.clearOut();
// mesh_.moving(false);
//
// // Change the mesh (no inflation)
// map = meshMod.changeMesh(mesh_, false, true);
//
@ -359,6 +367,10 @@ Foam::label Foam::meshRefinement::mergePatchFacesUndo
labelList(0) // cells to store
);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
@ -544,6 +556,10 @@ Foam::label Foam::meshRefinement::mergePatchFacesUndo
restoredCells
);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> map = meshMod.changeMesh(mesh_, false, true);
@ -629,6 +645,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::doRemovePoints
pointRemover.setRefinement(pointCanBeDeleted, meshMod);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;
@ -702,6 +722,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::doRestorePoints
meshMod
);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Change the mesh (no inflation)
autoPtr<mapPolyMesh> mapPtr = meshMod.changeMesh(mesh_, false, true);
mapPolyMesh& map = *mapPtr;

8
src/mesh/snappyHexMesh/meshRefinement/meshRefinementRefine.C
View File

@ -2352,6 +2352,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::refine
// Play refinement commands into mesh changer.
meshCutter_.setRefinement(cellsToRefine, meshMod);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
// Create mesh (no inflation), return map from old to new mesh.
autoPtr<mapPolyMesh> mapPtr = meshMod.changeMesh(mesh_, false);
mapPolyMesh& map = *mapPtr;
@ -2774,6 +2778,10 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::directionalRefine
// Insert mesh refinement into polyTopoChange.
meshRefiner.setRefinement(cuts, meshMod);
// Remove any unnecessary fields
mesh_.clearOut();
mesh_.moving(false);
autoPtr<mapPolyMesh> morphMap = meshMod.changeMesh(mesh_, false);
// Update fields

93
src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
View File

@ -30,6 +30,7 @@ License
#include "SubField.H"
#include "Time.H"
#include "addToRunTimeSelectionTable.H"
#include "primitiveMeshTools.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -191,8 +192,7 @@ void Foam::cyclicACMIPolyPatch::scalePatchFaceAreas
const vectorList& noFaceArea // nonOverlapPatch.faceAreas()
)
{
// Primitive patch face areas have been cleared/reset based on the raw
// points - need to reset to avoid double-accounting of face areas
// Set/scale polyPatch face areas to avoid double-accounting of face areas
const scalar maxTol = scalar(1) - tolerance_;
@ -251,14 +251,31 @@ void Foam::cyclicACMIPolyPatch::scalePatchFaceAreas
{
scalar& sum = weightsSum[i];
forAll(wghts, j)
for (scalar& w : wghts)
{
wghts[j] /= sum;
w /= sum;
}
sum = 1.0;
}
}
}
const polyMesh& mesh = boundaryMesh().mesh();
// Recompute the cell volumes adjacent to the patches since the cells with
// duplicate faces are only closed after the duplicate faces have been
// scaled.
primitiveMeshTools::updateCellCentresAndVols
(
mesh,
mesh.faceCentres(),
mesh.faceAreas(), // already scaled
uniqueSort(acmipp.faceCells()), // unique cells only
mesh.cells(),
const_cast<vectorField&>(mesh.cellCentres()),
const_cast<scalarField&>(mesh.cellVolumes())
);
}
@ -284,22 +301,6 @@ void Foam::cyclicACMIPolyPatch::resetAMI(const UList<point>& points) const
const polyMesh& mesh = boundaryMesh().mesh();
if (!createAMIFaces_ && mesh.hasCellCentres())
{
DebugPout
<< "cyclicACMIPolyPatch::resetAMI : clearing cellCentres"
<< " for " << name() << " and " << nonOverlapPatch.name() << nl
<< "The mesh already has cellCentres calculated when"
<< " resetting ACMI " << name() << "." << nl
<< "This is a problem since ACMI adapts the face areas"
<< " (to close cells) so this has" << nl
<< "to be done before cell centre calculation." << nl
<< "This can happen if e.g. the cyclicACMI is after"
<< " any processor patches in the boundary." << endl;
const_cast<polyMesh&>(mesh).primitiveMesh::clearCellGeom();
}
// At this point we want face geometry but not cell geometry since we want
// correct the face area on duplicate baffles before calculating the cell
// centres and volumes.
@ -363,6 +364,8 @@ void Foam::cyclicACMIPolyPatch::scalePatchFaceAreas()
if (srcScalePtr_)
{
// Use primitivePatch::faceAreas() to avoid need for additional copy?
// Save overlap geometry for later scaling
thisSf_ = this->faceAreas();
thisNoSf_ = nonOverlapPatch.faceAreas();
@ -370,24 +373,53 @@ void Foam::cyclicACMIPolyPatch::scalePatchFaceAreas()
nbrNoSf_ = nbrNonOverlapPatch.faceAreas();
}
// In-place scale the patch areas
// In-place scale the polyPatch face areas
// Note
// - using primitivePatch face areas since these are based on the raw
// point locations (not affected by ACMI scaling)
scalePatchFaceAreas
(
*this,
srcMask_, // unscaled mask
this->faceAreas(),
nonOverlapPatch.faceAreas()
this->primitivePatch::faceAreas(),
nonOverlapPatch.primitivePatch::faceAreas()
);
scalePatchFaceAreas
(
nbrPatch,
tgtMask_, // unscaled mask
nbrPatch.faceAreas(),
nbrNonOverlapPatch.faceAreas()
nbrPatch.primitivePatch::faceAreas(),
nbrNonOverlapPatch.primitivePatch::faceAreas()
);
// Mark current AMI as up to date with points
boundaryMesh().mesh().setUpToDatePoints(AMITime_);
if (debug)
{
const auto& acmipp = *this;
const auto& mesh = boundaryMesh().mesh();
const auto& vols = mesh.cellVolumes();
Info<< "cyclicACMI PP: " << acmipp.name()
<< " V:" << sum(scalarField(vols, acmipp.faceCells()))
<< nl
<< "cyclicACMI N-O PP: " << nonOverlapPatch.name()
<< " V:" << sum(scalarField(vols, nonOverlapPatch.faceCells()))
<< nl
<< "cyclicACMI NBR PP: " << nbrPatch.name()
<< " V:" << sum(scalarField(vols, nbrPatch.faceCells()))
<< nl
<< "cyclicACMI NBR N-O PP: " << nbrNonOverlapPatch.name()
<< " V:" << sum(scalarField(vols, nbrNonOverlapPatch.faceCells()))
<< nl
<< "cyclicACMI PP+N-O AREA: "
<< sum(faceAreas() + nonOverlapPatch.faceAreas()) << nl
<< "cyclicACMI NBR PP+N-O AREA: "
<< sum(nbrPatch.faceAreas() + nbrNonOverlapPatch.faceAreas())
<< endl;
}
}
@ -735,13 +767,13 @@ void Foam::cyclicACMIPolyPatch::newInternalProcFaces
const scalarField& fMask = srcMask();
// Add new faces as many weights for AMI
forAll (addSourceFaces, faceI)
forAll(addSourceFaces, faceI)
{
if (fMask[faceI] > tolerance_)
{
const labelList& nbrFaceIs = addSourceFaces[faceI];
forAll (nbrFaceIs, j)
forAll(nbrFaceIs, j)
{
label nbrFaceI = nbrFaceIs[j];
@ -761,20 +793,21 @@ void Foam::cyclicACMIPolyPatch::newInternalProcFaces
}
Foam::refPtr<Foam::labelListList> Foam::cyclicACMIPolyPatch::mapCollocatedFaces() const
Foam::refPtr<Foam::labelListList>
Foam::cyclicACMIPolyPatch::mapCollocatedFaces() const
{
const scalarField& fMask = srcMask();
const labelListList& srcFaces = AMI().srcAddress();
labelListList dOverFaces;
dOverFaces.setSize(srcFaces.size());
forAll (dOverFaces, faceI)
forAll(dOverFaces, faceI)
{
if (fMask[faceI] > tolerance_)
{
dOverFaces[faceI].setSize(srcFaces[faceI].size());
forAll (dOverFaces[faceI], subFaceI)
forAll(dOverFaces[faceI], subFaceI)
{
dOverFaces[faceI][subFaceI] = srcFaces[faceI][subFaceI];
}

2
src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H
View File

@ -106,7 +106,7 @@ private:
//- Weighting for target mask
mutable autoPtr<PatchFunction1<scalar>> tgtScalePtr_;
//- Stored face areas
//- Stored raw/non-scaled face areas
mutable vectorField thisSf_;
mutable vectorField thisNoSf_;
mutable vectorField nbrSf_;

81
src/meshTools/primitiveMeshGeometry/primitiveMeshGeometry.C
View File

@ -49,10 +49,8 @@ void Foam::primitiveMeshGeometry::updateFaceCentresAndAreas
{
const faceList& fs = mesh_.faces();
forAll(changedFaces, i)
for (label facei : changedFaces)
{
label facei = changedFaces[i];
const labelList& f = fs[facei];
label nPoints = f.size();
@ -70,19 +68,19 @@ void Foam::primitiveMeshGeometry::updateFaceCentresAndAreas
vector sumAc = Zero;
point fCentre = p[f[0]];
for (label pi = 1; pi < nPoints; pi++)
for (label pi = 1; pi < nPoints; ++pi)
{
fCentre += p[f[pi]];
}
fCentre /= nPoints;
for (label pi = 0; pi < nPoints; pi++)
for (label pi = 0; pi < nPoints; ++pi)
{
const point& nextPoint = p[f[(pi + 1) % nPoints]];
vector c = p[f[pi]] + nextPoint + fCentre;
vector n = (nextPoint - p[f[pi]])^(fCentre - p[f[pi]]);
vector c(p[f[pi]] + nextPoint + fCentre);
vector n((nextPoint - p[f[pi]])^(fCentre - p[f[pi]]));
scalar a = mag(n);
sumN += n;
@ -117,9 +115,8 @@ void Foam::primitiveMeshGeometry::updateCellCentresAndVols
scalarField nCellFaces(mesh_.nCells());
UIndirectList<scalar>(nCellFaces, changedCells) = 0.0;
forAll(changedFaces, i)
for (label facei : changedFaces)
{
label facei = changedFaces[i];
cEst[own[facei]] += faceCentres_[facei];
nCellFaces[own[facei]] += 1;
@ -130,16 +127,13 @@ void Foam::primitiveMeshGeometry::updateCellCentresAndVols
}
}
forAll(changedCells, i)
for (label celli : changedCells)
{
label celli = changedCells[i];
cEst[celli] /= nCellFaces[celli];
}
forAll(changedFaces, i)
for (label facei : changedFaces)
{
label facei = changedFaces[i];
// Calculate 3*face-pyramid volume
scalar pyr3Vol = max
(
@ -198,10 +192,8 @@ Foam::labelList Foam::primitiveMeshGeometry::affectedCells
labelHashSet affectedCells(2*changedFaces.size());
forAll(changedFaces, i)
for (label facei : changedFaces)
{
label facei = changedFaces[i];
affectedCells.insert(own[facei]);
if (mesh_.isInternalFace(facei))
@ -213,10 +205,8 @@ Foam::labelList Foam::primitiveMeshGeometry::affectedCells
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components
Foam::primitiveMeshGeometry::primitiveMeshGeometry
(
const primitiveMesh& mesh
@ -228,9 +218,6 @@ Foam::primitiveMeshGeometry::primitiveMeshGeometry
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::primitiveMeshGeometry::correct()
@ -312,7 +299,7 @@ bool Foam::primitiveMeshGeometry::checkFaceDotProduct
setPtr->insert(facei);
}
severeNonOrth++;
++severeNonOrth;
}
else
{
@ -328,7 +315,7 @@ bool Foam::primitiveMeshGeometry::checkFaceDotProduct
<< " deg." << endl;
}
errorNonOrth++;
++errorNonOrth;
if (setPtr)
{
@ -415,10 +402,8 @@ bool Foam::primitiveMeshGeometry::checkFacePyramids
label nErrorPyrs = 0;
forAll(checkFaces, i)
for (label facei : checkFaces)
{
label facei = checkFaces[i];
// Create the owner pyramid - it will have negative volume
scalar pyrVol = pyramidPointFaceRef
(
@ -448,7 +433,7 @@ bool Foam::primitiveMeshGeometry::checkFacePyramids
setPtr->insert(facei);
}
nErrorPyrs++;
++nErrorPyrs;
}
if (mesh.isInternalFace(facei))
@ -478,7 +463,7 @@ bool Foam::primitiveMeshGeometry::checkFacePyramids
setPtr->insert(facei);
}
nErrorPyrs++;
++nErrorPyrs;
}
}
}
@ -529,10 +514,8 @@ bool Foam::primitiveMeshGeometry::checkFaceSkewness
label nWarnSkew = 0;
forAll(checkFaces, i)
for (label facei : checkFaces)
{
label facei = checkFaces[i];
if (mesh.isInternalFace(facei))
{
scalar dOwn = mag(faceCentres[facei] - cellCentres[own[facei]]);
@ -565,7 +548,7 @@ bool Foam::primitiveMeshGeometry::checkFaceSkewness
setPtr->insert(facei);
}
nWarnSkew++;
++nWarnSkew;
}
if (skewness > maxSkew)
@ -606,7 +589,7 @@ bool Foam::primitiveMeshGeometry::checkFaceSkewness
setPtr->insert(facei);
}
nWarnSkew++;
++nWarnSkew;
}
if (skewness > maxSkew)
@ -664,10 +647,8 @@ bool Foam::primitiveMeshGeometry::checkFaceWeights
label nWarnWeight = 0;
forAll(checkFaces, i)
for (label facei : checkFaces)
{
label facei = checkFaces[i];
if (mesh.isInternalFace(facei))
{
const point& fc = faceCentres[facei];
@ -690,7 +671,7 @@ bool Foam::primitiveMeshGeometry::checkFaceWeights
setPtr->insert(facei);
}
nWarnWeight++;
++nWarnWeight;
}
minWeight = min(minWeight, weight);
@ -755,10 +736,8 @@ bool Foam::primitiveMeshGeometry::checkFaceAngles
label errorFacei = -1;
forAll(checkFaces, i)
for (label facei : checkFaces)
{
label facei = checkFaces[i];
const face& f = fcs[facei];
const vector faceNormal = normalised(faceAreas[facei]);
@ -795,7 +774,7 @@ bool Foam::primitiveMeshGeometry::checkFaceAngles
{
// Count only one error per face.
errorFacei = facei;
nConcave++;
++nConcave;
}
if (setPtr)
@ -916,13 +895,13 @@ bool Foam::primitiveMeshGeometry::checkFaceAngles
// scalar flatness = magArea / (sumA+VSMALL);
//
// sumFlatness += flatness;
// nSummed++;
// ++nSummed;
//
// minFlatness = min(minFlatness, flatness);
//
// if (flatness < warnFlatness)
// {
// nWarped++;
// ++nWarped;
//
// if (setPtr)
// {
@ -1098,17 +1077,15 @@ bool Foam::primitiveMeshGeometry::checkFaceArea
{
label nZeroArea = 0;
forAll(checkFaces, i)
for (label facei : checkFaces)
{
label facei = checkFaces[i];
if (mag(faceAreas[facei]) < minArea)
{
if (setPtr)
{
setPtr->insert(facei);
}
nZeroArea++;
++nZeroArea;
}
}
@ -1163,9 +1140,9 @@ bool Foam::primitiveMeshGeometry::checkCellDeterminant
label nSumDet = 0;
label nWarnDet = 0;
forAll(affectedCells, i)
for (label celli : affectedCells)
{
const cell& cFaces = cells[affectedCells[i]];
const cell& cFaces = cells[celli];
tensor areaSum(Zero);
scalar magAreaSum = 0;
@ -1184,7 +1161,7 @@ bool Foam::primitiveMeshGeometry::checkCellDeterminant
minDet = min(minDet, scaledDet);
sumDet += scaledDet;
nSumDet++;
++nSumDet;
if (scaledDet < warnDet)
{
@ -1197,7 +1174,7 @@ bool Foam::primitiveMeshGeometry::checkCellDeterminant
setPtr->insert(facei);
}
}
nWarnDet++;
++nWarnDet;
}
}