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

ENH: add missing construct GeometricField from primitive field (tmp)

Browse Source 
ENH: improvements for GeometricBoundaryField evaluation

- early termination from evaluate_if() and evaluateCoupled().

- evaluateCoupled() now forwards to evaluate_if() and receives
  additional handling for a 'void' parameter type.

BREAKING: extra template parameter for overset correctBoundaryCondition

- the true/false flag as a template parameter instead of as an
  argument to use 'if constexpr' code
This commit is contained in:
Mark Olesen
2025-05-28 09:22:05 +02:00
parent 1d6c77f8f4
commit d6e6450834
18 changed files with 362 additions and 470 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
applications/utilities/preProcessing/mapFieldsPar/MapVolFields.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2018-2023 OpenCFD Ltd.
Copyright (C) 2018-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -39,74 +39,23 @@ namespace Foam
{
template<class Type>
void evaluateConstraintTypes(GeometricField<Type, fvPatchField, volMesh>& fld)
void evaluateConstraintTypes
(
GeometricField<Type, fvPatchField, volMesh>& fld
)
{
auto& bfld = fld.boundaryFieldRef();
const UPstream::commsTypes commsType = UPstream::defaultCommsType;
if
fld.boundaryFieldRef().evaluate_if
(
commsType == UPstream::commsTypes::buffered
|| commsType == UPstream::commsTypes::nonBlocking
)
{
const label startOfRequests = UPstream::nRequests();
for (auto& pfld : bfld)
[](const auto& pfld) -> bool
{
if
return
(
pfld.type() == pfld.patch().patch().type()
&& polyPatch::constraintType(pfld.patch().patch().type())
)
{
pfld.initEvaluate(commsType);
}
}
// Wait for outstanding requests (non-blocking)
UPstream::waitRequests(startOfRequests);
for (auto& pfld : bfld)
{
if
(
pfld.type() == pfld.patch().patch().type()
&& polyPatch::constraintType(pfld.patch().patch().type())
)
{
pfld.evaluate(commsType);
}
}
}
else if (commsType == UPstream::commsTypes::scheduled)
{
const lduSchedule& patchSchedule =
fld.mesh().globalData().patchSchedule();
for (const auto& schedEval : patchSchedule)
{
const label patchi = schedEval.patch;
auto& pfld = bfld[patchi];
if
(
pfld.type() == pfld.patch().patch().type()
&& polyPatch::constraintType(pfld.patch().patch().type())
)
{
if (schedEval.init)
{
pfld.initEvaluate(commsType);
}
else
{
pfld.evaluate(commsType);
}
}
}
}
);
},
UPstream::defaultCommsType
);
}

27
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H
View File

@ -373,6 +373,33 @@ public:
Field<Type>&& iField
);
//- Return tmp field (NO_READ, NO_WRITE)
//- from name, mesh, dimensions, primitive field (tmp).
//- [Takes current timeName from the mesh registry].
// For LEGACY_REGISTER, registration is determined by
// objectRegistry::is_cacheTemporaryObject().
static tmp<DimensionedField<Type, GeoMesh>> New
(
const word& name,
IOobjectOption::registerOption regOpt,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield
);
//- Return tmp field (NO_READ, NO_WRITE)
//- from name, mesh, dimensions, primitive field (tmp).
//- [Takes current timeName from the mesh registry].
// Registration/persistence determined by
// objectRegistry::is_cacheTemporaryObject().
static tmp<DimensionedField<Type, GeoMesh>> New
(
const word& name,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield
);
//- Return tmp field (NO_READ, NO_WRITE)
//- from name, mesh, dimensions.
//- [Takes current timeName from the mesh registry].

45
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldNew.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2022-2024 OpenCFD Ltd.
Copyright (C) 2022-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -163,6 +163,49 @@ Foam::DimensionedField<Type, GeoMesh>::New
}
template<class Type, class GeoMesh>
Foam::tmp<Foam::DimensionedField<Type, GeoMesh>>
Foam::DimensionedField<Type, GeoMesh>::New
(
const word& name,
IOobjectOption::registerOption regOpt,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield
)
{
return DimensionedField<Type, GeoMesh>::New_impl
(
regOpt,
name,
mesh,
dims,
tfield
);
}
template<class Type, class GeoMesh>
Foam::tmp<Foam::DimensionedField<Type, GeoMesh>>
Foam::DimensionedField<Type, GeoMesh>::New
(
const word& name,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield
)
{
return DimensionedField<Type, GeoMesh>::New_impl
(
IOobjectOption::LEGACY_REGISTER,
name,
mesh,
dims,
tfield
);
}
template<class Type, class GeoMesh>
Foam::tmp<Foam::DimensionedField<Type, GeoMesh>>
Foam::DimensionedField<Type, GeoMesh>::New

145
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2017,2022 OpenFOAM Foundation
Copyright (C) 2016-2024 OpenCFD Ltd.
Copyright (C) 2016-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -64,6 +64,8 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
//Note: areaFields (finiteArea) do not have manipulatedMatrix() flag. TBD.
//boolList oldManipulated(this->size());
label nEvaluated(0);
for (auto& pfld : bfld)
{
if (isA<CheckPatchFieldType>(pfld))
@ -72,19 +74,24 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
oldUpdated[patchi] = pfld.updated();
oldBfld[patchi] = pfld;
//oldManipulated[patchi] = pfld.manipulatedMatrix();
++nEvaluated;
}
}
if (!nEvaluated) return true; // Early termination
// Re-evaluate
{
const label startOfRequests = UPstream::nRequests();
nEvaluated = 0;
for (auto& pfld : bfld)
{
if (isA<CheckPatchFieldType>(pfld))
{
pfld.initEvaluate(UPstream::commsTypes::nonBlocking);
++nEvaluated;
}
}
@ -96,13 +103,15 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
if (isA<CheckPatchFieldType>(pfld))
{
pfld.evaluate(UPstream::commsTypes::nonBlocking);
if (--nEvaluated == 0) break; // Early termination
}
}
}
// Check
bool ok = true;
bool allOk(true);
for (auto& pfld : bfld)
{
if (isA<CheckPatchFieldType>(pfld))
@ -110,16 +119,23 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
const label patchi = pfld.patch().index();
const auto& oldPfld = oldBfld[patchi];
forAll(pfld, facei)
bool localOk(true);
if (allOk)
{
if (mag(pfld[facei]-oldPfld[facei]) > tol)
// Only check once
forAll(pfld, facei)
{
ok = false;
break;
if (mag(pfld[facei]-oldPfld[facei]) > tol)
{
allOk = false;
localOk = false;
break;
}
}
}
if (!ok)
if (!localOk)
{
if (doExit)
{
@ -133,7 +149,7 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
<< ". Average of evaluated field = "
<< average(pfld)
<< ". Difference:" << average(pfld-oldPfld)
<< ". Tolerance:" << tol
<< ". Tolerance:" << tol << endl
<< exit(FatalError);
}
else
@ -148,25 +164,13 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
<< ". Average of evaluated field = "
<< average(pfld)
<< ". Difference:" << average(pfld-oldPfld)
<< ". Tolerance:" << tol
<< endl;
// Skip other patches
break;
<< ". Tolerance:" << tol << endl;
}
}
}
}
// Restore bfld, updated
for (auto& pfld : bfld)
{
if (isA<CheckPatchFieldType>(pfld))
{
const label patchi = pfld.patch().index();
// Restore bfld, updated
pfld.setUpdated(oldUpdated[patchi]);
Field<Type>& vals = pfld;
vals = std::move(oldBfld[patchi]);
static_cast<Field<Type>&>(pfld) = std::move(oldBfld[patchi]);
//pfld.setManipulated(oldManipulated[patchi]);
}
}
@ -176,10 +180,10 @@ bool Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::checkConsistency
const auto& pfld0 = this->operator[](0);
PoutInFunction
<< " Result of checking for field "
<< pfld0.internalField().name() << " : " << ok << endl;
<< pfld0.internalField().name() << " : " << allOk << endl;
}
return ok;
return allOk;
}
@ -626,6 +630,7 @@ void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::evaluate_if
|| commsType == UPstream::commsTypes::nonBlocking
)
{
label nEvaluated(0);
const label startOfRequests = UPstream::nRequests();
for (auto& pfld : *this)
@ -633,17 +638,21 @@ void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::evaluate_if
if (pred(pfld))
{
pfld.initEvaluate(commsType);
++nEvaluated;
}
}
// Wait for outstanding requests (non-blocking)
UPstream::waitRequests(startOfRequests);
if (!nEvaluated) return; // Early termination
for (auto& pfld : *this)
{
if (pred(pfld))
{
pfld.evaluate(commsType);
if (--nEvaluated == 0) break; // Early termination
}
}
}
@ -778,81 +787,25 @@ void Foam::GeometricBoundaryField<Type, PatchField, GeoMesh>::evaluateCoupled
const UPstream::commsTypes commsType
)
{
// Alternative (C++14)
//
// this->evaluate_if
// (
// [](const auto& pfld) -> bool
// {
// const auto* cpp = isA<CoupledPatchType>(pfld.patch());
// return (cpp && cpp->coupled());
// },
// commsType
// );
// DebugInFunction << nl;
if
(
commsType == UPstream::commsTypes::buffered
|| commsType == UPstream::commsTypes::nonBlocking
)
if constexpr (std::is_void_v<CoupledPatchType>)
{
const label startOfRequests = UPstream::nRequests();
for (auto& pfld : *this)
{
const auto* cpp = isA<CoupledPatchType>(pfld.patch());
if (cpp && cpp->coupled())
{
pfld.initEvaluate(commsType);
}
}
// Wait for outstanding requests (non-blocking)
UPstream::waitRequests(startOfRequests);
for (auto& pfld : *this)
{
const auto* cpp = isA<CoupledPatchType>(pfld.patch());
if (cpp && cpp->coupled())
{
pfld.evaluate(commsType);
}
}
}
else if (commsType == UPstream::commsTypes::scheduled)
{
const lduSchedule& patchSchedule =
bmesh_.mesh().globalData().patchSchedule();
for (const auto& schedEval : patchSchedule)
{
const label patchi = schedEval.patch;
auto& pfld = (*this)[patchi];
const auto* cpp = isA<CoupledPatchType>(pfld.patch());
if (cpp && cpp->coupled())
{
if (schedEval.init)
{
pfld.initEvaluate(commsType);
}
else
{
pfld.evaluate(commsType);
}
}
}
this->evaluate_if
(
[](const auto& pfld) { return pfld.coupled(); },
commsType
);
}
else
{
FatalErrorInFunction
<< "Unsupported communications type " << int(commsType) << nl
<< exit(FatalError);
this->evaluate_if
(
[](const auto& pfld) -> bool
{
const auto* cpp = isA<CoupledPatchType>(pfld.patch());
return (cpp && cpp->coupled());
},
commsType
);
}
}

8
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricBoundaryField.H
View File

@ -205,8 +205,12 @@ public:
const UPstream::commsTypes commsType = UPstream::defaultCommsType
);
//- Evaluate boundary conditions on coupled patches of given type.
//- Uses specified or default comms.
//- Evaluate boundary conditions on coupled patches of the given type,
//- using specified or default comms.
//
// \tparam CoupledPatchType The coupled \b patch type that should
// be evaluated. For a \c void type,
// all coupled patch fields will be evaluated.
template<class CoupledPatchType>
void evaluateCoupled
(

69
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.C
View File

@ -63,8 +63,10 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::readFields
if (dict.readIfPresent("referenceLevel", refLevel))
{
Field<Type>::operator+=(refLevel);
// Add to internal (primitive) field
this->field() += refLevel;
// Add to boundary fields
forAll(boundaryField_, patchi)
{
boundaryField_[patchi] == boundaryField_[patchi] + refLevel;
@ -409,7 +411,7 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
boundaryField_(mesh.boundary(), *this, patchFieldType)
{
DebugInFunction
<< "Copy construct from internal field" << nl << this->info() << endl;
<< "Copy construct from primitive field" << nl << this->info() << endl;
readIfPresent();
}
@ -430,7 +432,28 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
boundaryField_(mesh.boundary(), *this, patchFieldType)
{
DebugInFunction
<< "Move construct from internal field" << nl << this->info() << endl;
<< "Move construct from primitive field" << nl << this->info() << endl;
readIfPresent();
}
template<class Type, template<class> class PatchField, class GeoMesh>
Foam::GeometricField<Type, PatchField, GeoMesh>::GeometricField
(
const IOobject& io,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield,
const word& patchFieldType
)
:
Internal(io, mesh, dims, tfield),
timeIndex_(this->time().timeIndex()),
boundaryField_(mesh.boundary(), *this, patchFieldType)
{
DebugInFunction
<< "Construct from tmp primitive field" << nl << this->info() << endl;
readIfPresent();
}
@ -1391,10 +1414,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator=
// Make sure any e.g. jump-cyclic are updated.
boundaryFieldRef().evaluate_if
(
[](const auto& pfld) -> bool
{
return pfld.constraintOverride();
}
[](const auto& pfld) { return pfld.constraintOverride(); }
);
}
@ -1436,10 +1456,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator=
// Make sure any e.g. jump-cyclic are updated.
boundaryFieldRef().evaluate_if
(
[](const auto& pfld) -> bool
{
return pfld.constraintOverride();
}
[](const auto& pfld) { return pfld.constraintOverride(); }
);
}
@ -1456,10 +1473,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator=
// Make sure any e.g. jump-cyclic are updated.
boundaryFieldRef().evaluate_if
(
[](const auto& pfld) -> bool
{
return pfld.constraintOverride();
}
[](const auto& pfld) { return pfld.constraintOverride(); }
);
}
@ -1484,10 +1498,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator==
// Make sure any e.g. jump-cyclic are updated.
boundaryFieldRef().evaluate_if
(
[](const auto& pfld) -> bool
{
return pfld.constraintOverride();
}
[](const auto& pfld) { return pfld.constraintOverride(); }
);
}
@ -1504,10 +1515,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator==
// Make sure any e.g. jump-cyclic are updated.
boundaryFieldRef().evaluate_if
(
[](const auto& pfld) -> bool
{
return pfld.constraintOverride();
}
[](const auto& pfld) { return pfld.constraintOverride(); }
);
}
@ -1527,10 +1535,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator op \
\
boundaryFieldRef().evaluate_if \
( \
[](const auto& pfld) -> bool \
{ \
return pfld.constraintOverride(); \
} \
[](const auto& pfld) { return pfld.constraintOverride(); } \
); \
} \
\
@ -1545,10 +1550,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator op \
\
boundaryFieldRef().evaluate_if \
( \
[](const auto& pfld) -> bool \
{ \
return pfld.constraintOverride(); \
} \
[](const auto& pfld) { return pfld.constraintOverride(); } \
); \
} \
\
@ -1563,10 +1565,7 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::operator op \
\
boundaryFieldRef().evaluate_if \
( \
[](const auto& pfld) -> bool \
{ \
return pfld.constraintOverride(); \
} \
[](const auto& pfld) { return pfld.constraintOverride(); } \
); \
}

53
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricField.H
View File

@ -251,7 +251,7 @@ public:
const PtrList<PatchField<Type>>& ptfl
);
//- Move construct from internal field and a patch list to clone
//- Construct from internal field (tmp) and a patch list to clone
GeometricField
(
const IOobject& io,
@ -273,7 +273,7 @@ public:
const PtrList<PatchField<Type>>& ptfl
);
//- Copy construct from internal field, with specified patch type
//- Copy construct from primitive field, with specified patch type
GeometricField
(
const IOobject& io,
@ -283,7 +283,7 @@ public:
const word& patchFieldType = PatchField<Type>::calculatedType()
);
//- Move construct from internal field, with specified patch type
//- Move construct from primitive field, with specified patch type
GeometricField
(
const IOobject& io,
@ -293,7 +293,17 @@ public:
const word& patchFieldType = PatchField<Type>::calculatedType()
);
//- Copy construct from components
//- Construct from primitive field (tmp), with specified patch type
GeometricField
(
const IOobject& io,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield,
const word& patchFieldType = PatchField<Type>::calculatedType()
);
//- Copy construct from primitive field and a patch list to clone
GeometricField
(
const IOobject& io,
@ -303,7 +313,7 @@ public:
const PtrList<PatchField<Type>>& ptfl
);
//- Move construct from internal field and a patch list to clone
//- Move construct from primitive field and a patch list to clone
GeometricField
(
const IOobject& io,
@ -319,7 +329,7 @@ public:
const IOobject& io,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tiField,
const tmp<Field<Type>>& tfield,
const PtrList<PatchField<Type>>& ptfl
);
@ -508,6 +518,37 @@ public:
const word& patchFieldType = PatchField<Type>::calculatedType()
);
//- Return tmp field (NO_READ, NO_WRITE)
//- from name, mesh, dimensions, tmp of primitive field
//- and patch type.
//- [Takes current timeName from the mesh registry].
// For LEGACY_REGISTER, registration is determined by
// objectRegistry::is_cacheTemporaryObject().
static tmp<GeometricField<Type, PatchField, GeoMesh>> New
(
const word& name,
IOobjectOption::registerOption regOpt,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield,
const word& patchFieldType = PatchField<Type>::calculatedType()
);
//- Return tmp field (NO_READ, NO_WRITE)
//- from name, mesh, dimensions, tmp of primitive field
//- and patch type.
//- [Takes current timeName from the mesh registry].
// Registration/persistence determined by
// objectRegistry::is_cacheTemporaryObject().
static tmp<GeometricField<Type, PatchField, GeoMesh>> New
(
const word& name,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield,
const word& patchFieldType = PatchField<Type>::calculatedType()
);
//- Return tmp field (NO_READ, NO_WRITE)
//- from name, mesh, dimensions, copy of internal field contents
//- and patch list to clone.

49
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldNew.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2017 OpenFOAM Foundation
Copyright (C) 2019-2024 OpenCFD Ltd.
Copyright (C) 2019-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -215,6 +215,53 @@ Foam::GeometricField<Type, PatchField, GeoMesh>::New
}
template<class Type, template<class> class PatchField, class GeoMesh>
Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
Foam::GeometricField<Type, PatchField, GeoMesh>::New
(
const word& name,
IOobjectOption::registerOption regOpt,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield,
const word& patchFieldType
)
{
return GeometricField<Type, PatchField, GeoMesh>::New_impl
(
regOpt,
name,
mesh,
dims,
tfield,
patchFieldType
);
}
template<class Type, template<class> class PatchField, class GeoMesh>
Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
Foam::GeometricField<Type, PatchField, GeoMesh>::New
(
const word& name,
const Mesh& mesh,
const dimensionSet& dims,
const tmp<Field<Type>>& tfield,
const word& patchFieldType
)
{
return GeometricField<Type, PatchField, GeoMesh>::New_impl
(
IOobjectOption::LEGACY_REGISTER,
name,
mesh,
dims,
tfield,
patchFieldType
);
}
template<class Type, template<class> class PatchField, class GeoMesh>
Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>>
Foam::GeometricField<Type, PatchField, GeoMesh>::New

29
src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWaveAddressing/meshWaveAddressingPatchDistMethod.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2023 OpenCFD Ltd.
Copyright (C) 2023-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -88,12 +88,14 @@ bool Foam::patchDistMethods::meshWaveAddressing::correct
// since the supplied options (wall patchIDs and correctWalls)
// are not assumed to be different from the defaults of other usage.
const labelList patchIds(patchIDs_.sortedToc());
// Calculate distance and addressing
const auto& wDist = wallDistAddressing::New
(
"wall",
mesh_,
patchIDs_.sortedToc(),
patchIds,
correctWalls_
);
@ -102,31 +104,18 @@ bool Foam::patchDistMethods::meshWaveAddressing::correct
// Note: copying value only so might not be consistent with supplied
// patch types (e.g. zeroGradient when called from wallDist). Assume
// only affected ones are the supplied patches ...
{
auto& bfld = y.boundaryFieldRef();
const label startOfRequests = UPstream::nRequests();
for (const label patchi : patchIDs_)
{
bfld[patchi].initEvaluate(UPstream::commsTypes::nonBlocking);
}
// Wait for outstanding requests
UPstream::waitRequests(startOfRequests);
for (const label patchi : patchIDs_)
{
bfld[patchi].evaluate(UPstream::commsTypes::nonBlocking);
}
}
y.boundaryFieldRef().evaluateSelected(patchIds);
// Only calculate n if the field is defined
if (notNull(n))
{
for (const label patchi : patchIDs_)
auto& bfld = n.boundaryFieldRef();
for (const label patchi : patchIds)
{
auto& pnf = n.boundaryFieldRef()[patchi];
pnf == pnf.patch().nf();
bfld[patchi] == bfld[patchi].patch().nf();
}
// No problem with inconsistency as for y (see above) since doing

76
src/functionObjects/field/cellDecomposer/cellDecomposerTemplates.C
View File

@ -39,79 +39,17 @@ License
// GeometricField<Type, fvPatchField, volMesh>& fld
//) const
//{
// auto& fldBf = fld.boundaryFieldRef();
//
// const UPstream::commsTypes commsType = UPstream::defaultCommsType;
// const label startOfRequests = UPstream::nRequests();
//
// if
// fld.boundaryFieldRef().evaluate_if
// (
// commsType == UPstream::commsTypes::blocking
// || commsType == UPstream::commsTypes::nonBlocking
// )
// {
// forAll(fldBf, patchi)
// [](const auto& pfld) -> bool
// {
// fvPatchField<Type>& tgtField = fldBf[patchi];
//
// if
// return
// (
// tgtField.type() == tgtField.patch().patch().type()
// && polyPatch::constraintType(tgtField.patch().patch().type())
// )
// {
// tgtField.initEvaluate(commsType);
// }
// pfld.type() == pfld.patch().patch().type()
// && polyPatch::constraintType(pfld.patch().patch().type())
// );
// }
//
// // Wait for outstanding requests
// if (commsType == UPstream::commsTypes::nonBlocking)
// {
// UPstream::waitRequests(startOfRequests);
// }
//
// forAll(fldBf, patchi)
// {
// fvPatchField<Type>& tgtField = fldBf[patchi];
//
// if
// (
// tgtField.type() == tgtField.patch().patch().type()
// && polyPatch::constraintType(tgtField.patch().patch().type())
// )
// {
// tgtField.evaluate(commsType);
// }
// }
// }
// else if (commsType == UPstream::commsTypes::scheduled)
// {
// const lduSchedule& patchSchedule =
// fld.mesh().globalData().patchSchedule();
//
// for (const auto& schedEval : patchSchedule)
// {
// const label patchi = schedEval.patch;
//
// fvPatchField<Type>& tgtField = fldBf[patchi];
//
// if
// (
// tgtField.type() == tgtField.patch().patch().type()
// && polyPatch::constraintType(tgtField.patch().patch().type())
// )
// {
// if (schedEval.init)
// {
// tgtField.initEvaluate(commsType);
// }
// else
// {
// tgtField.evaluate(commsType);
// }
// }
// }
// }
// );
//}
template<class Type>

70
src/functionObjects/field/mapFields/mapFieldsTemplates.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2016-2022 OpenCFD Ltd.
Copyright (C) 2016-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -36,72 +36,18 @@ void Foam::functionObjects::mapFields::evaluateConstraintTypes
GeometricField<Type, fvPatchField, volMesh>& fld
) const
{
auto& bfld = fld.boundaryFieldRef();
const UPstream::commsTypes commsType = UPstream::defaultCommsType;
if
fld.boundaryFieldRef().evaluate_if
(
commsType == UPstream::commsTypes::buffered
|| commsType == UPstream::commsTypes::nonBlocking
)
{
const label startOfRequests = UPstream::nRequests();
for (auto& pfld : bfld)
[](const auto& pfld) -> bool
{
if
return
(
pfld.type() == pfld.patch().patch().type()
&& polyPatch::constraintType(pfld.patch().patch().type())
)
{
pfld.initEvaluate(commsType);
}
}
// Wait for outstanding requests (non-blocking)
UPstream::waitRequests(startOfRequests);
for (auto& pfld : bfld)
{
if
(
pfld.type() == pfld.patch().patch().type()
&& polyPatch::constraintType(pfld.patch().patch().type())
)
{
pfld.evaluate(commsType);
}
}
}
else if (commsType == UPstream::commsTypes::scheduled)
{
const lduSchedule& patchSchedule =
fld.mesh().globalData().patchSchedule();
for (const auto& schedEval : patchSchedule)
{
const label patchi = schedEval.patch;
auto& pfld = bfld[patchi];
if
(
pfld.type() == pfld.patch().patch().type()
&& polyPatch::constraintType(pfld.patch().patch().type())
)
{
if (schedEval.init)
{
pfld.initEvaluate(commsType);
}
else
{
pfld.evaluate(commsType);
}
}
}
}
);
},
UPstream::defaultCommsType
);
}

33
src/overset/cellCellStencil/cellCellStencil/cellCellStencilTemplates.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2018-2023 OpenCFD Ltd.
Copyright (C) 2018-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -182,31 +182,16 @@ void Foam::cellCellStencil::correctBoundaryConditions
GeoField& psi
)
{
// Version of GeoField::correctBoundaryConditions that exclude evaluation
// of oversetFvPatchFields
// correctBoundaryConditions excluding oversetFvPatchFields
auto& bfld = psi.boundaryFieldRef();
const label startOfRequests = UPstream::nRequests();
for (auto& pfld : bfld)
{
if (!isA<SuppressBC>(pfld))
psi.boundaryFieldRef().evaluate_if
(
[](const auto& pfld)
{
pfld.initEvaluate(UPstream::commsTypes::nonBlocking);
}
}
// Wait for outstanding requests (non-blocking)
UPstream::waitRequests(startOfRequests);
for (auto& pfld : bfld)
{
if (!isA<SuppressBC>(pfld))
{
pfld.evaluate(UPstream::commsTypes::nonBlocking);
}
}
return (!isA<SuppressBC>(pfld));
},
UPstream::commsTypes::nonBlocking
);
}

5
src/overset/cellCellStencil/cellVolumeWeight/cellVolumeWeightCellCellStencil.C
View File

@ -1033,8 +1033,9 @@ bool Foam::cellCellStencils::cellVolumeWeight::update()
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(cellInterpolationWeight_.boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(cellInterpolationWeight_.boundaryFieldRef());
DynamicList<label> interpolationCells;
forAll(cellStencil_, cellI)

15
src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C
View File

@ -2351,8 +2351,9 @@ bool Foam::cellCellStencils::inverseDistance::update()
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(cellInterpolationWeight_.boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(cellInterpolationWeight_.boundaryFieldRef());
if ((debug & 2) && mesh_.time().writeTime())
@ -2435,8 +2436,9 @@ bool Foam::cellCellStencils::inverseDistance::update()
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(tfld.ref().boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(tfld.ref().boundaryFieldRef());
tfld().write();
}
@ -2450,8 +2452,9 @@ bool Foam::cellCellStencils::inverseDistance::update()
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(tfld.ref().boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(tfld.ref().boundaryFieldRef());
tfld().write();
}

5
src/overset/cellCellStencil/trackingInverseDistance/trackingInverseDistanceCellCellStencil.C
View File

@ -1059,8 +1059,9 @@ bool Foam::cellCellStencils::trackingInverseDistance::update()
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(cellInterpolationWeight_.boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(cellInterpolationWeight_.boundaryFieldRef());
if ((debug & 2) && mesh_.time().writeTime())

14
src/overset/oversetFvMesh/oversetFvMeshBase.C
View File

@ -445,11 +445,12 @@ void Foam::oversetFvMeshBase::writeAgglomeration
fld[celli] = cellToCoarse[celli];
}
fld /= max(fld);
correctBoundaryConditions
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(scalarAgglomeration.boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(scalarAgglomeration.boundaryFieldRef());
scalarAgglomeration.write();
Info<< "Writing initial cell distribution to "
@ -503,11 +504,12 @@ void Foam::oversetFvMeshBase::writeAgglomeration
//{
// fld /= max(fld);
//}
correctBoundaryConditions
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(scalarAgglomeration.boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(scalarAgglomeration.boundaryFieldRef());
scalarAgglomeration.write();
}
}

9
src/overset/oversetFvMesh/oversetFvMeshBase.H
View File

@ -257,13 +257,12 @@ public:
template<class GeoField>
static void checkCoupledBC(const GeoField& fld);
//- Correct boundary conditions of certain type (typeOnly = true)
//- or explicitly not of the type (typeOnly = false)
template<class GeoField, class PatchType>
//- Correct boundary conditions of certain type (TypeOnly = true)
//- or explicitly not of the type (TypeOnly = false)
template<class GeoField, class PatchType, bool TypeOnly>
static void correctBoundaryConditions
(
typename GeoField::Boundary& bfld,
const bool typeOnly
typename GeoField::Boundary& bfld
);
//- Determine normalisation for interpolation. This equals the

105
src/overset/oversetFvMesh/oversetFvMeshBaseTemplates.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2014-2022 OpenCFD Ltd.
Copyright (C) 2014-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -73,44 +73,31 @@ void Foam::oversetFvMeshBase::scaleConnection
}
}
template<class GeoField, class PatchType>
template<class GeoField, class PatchType, bool TypeOnly>
void Foam::oversetFvMeshBase::correctBoundaryConditions
(
typename GeoField::Boundary& bfld,
const bool typeOnly
typename GeoField::Boundary& bfld
)
{
// Alternative (C++14)
//
// bfld.evaluate_if
// (
// [typeOnly](const auto& pfld) -> bool
// {
// return (typeOnly == bool(isA<PatchType>(pfld)));
// },
// UPstream::defaultCommsType
// );
const UPstream::commsTypes commsType = UPstream::defaultCommsType;
const label startOfRequests = UPstream::nRequests();
for (auto& pfld : bfld)
if constexpr (TypeOnly)
{
if (typeOnly == bool(isA<PatchType>(pfld)))
{
pfld.initEvaluate(commsType);
}
}
// Wait for outstanding requests (non-blocking)
UPstream::waitRequests(startOfRequests);
for (auto& pfld : bfld)
bfld.evaluate_if
(
[](const auto& pfld)
{
return (bool(isA<PatchType>(pfld)));
}
);
}
else
{
if (typeOnly == bool(isA<PatchType>(pfld)))
{
pfld.evaluate(commsType);
}
bfld.evaluate_if
(
[](const auto& pfld)
{
return (!bool(isA<PatchType>(pfld)));
}
);
}
}
@ -766,11 +753,12 @@ Foam::SolverPerformance<Type> Foam::oversetFvMeshBase::solveOverset
dimensionedScalar(dimless, Zero)
);
scale.ref().field() = norm;
correctBoundaryConditions
oversetFvMeshBase::correctBoundaryConditions
<
volScalarField,
oversetFvPatchField<scalar>
>(scale.boundaryFieldRef(), false);
oversetFvPatchField<scalar>,
false
>(scale.boundaryFieldRef());
scale.write();
if (debug)
@ -802,11 +790,12 @@ Foam::SolverPerformance<Type> Foam::oversetFvMeshBase::solveOverset
m.boundaryManipulate(bpsi);
// Swap psi values so added patches have patchNeighbourField
correctBoundaryConditions<GeoField, calculatedProcessorFvPatchField<Type>>
(
bpsi,
oversetFvMeshBase::correctBoundaryConditions
<
GeoField,
calculatedProcessorFvPatchField<Type>,
true
);
>(bpsi);
// Use lower level solver
//SolverPerformance<Type> s(dynamicMotionSolverFvMesh::solve(m, dict));
@ -993,32 +982,8 @@ void Foam::oversetFvMeshBase::write
template<class GeoField>
void Foam::oversetFvMeshBase::correctCoupledBoundaryConditions(GeoField& fld)
{
auto& bfld = fld.boundaryFieldRef();
const UPstream::commsTypes commsType = UPstream::defaultCommsType;
const label startOfRequests = UPstream::nRequests();
for (auto& pfld : bfld)
{
if (pfld.coupled())
{
//Pout<< "initEval of " << pfld.patch().name() << endl;
pfld.initEvaluate(commsType);
}
}
// Wait for outstanding requests (non-blocking)
UPstream::waitRequests(startOfRequests);
for (auto& pfld : bfld)
{
if (pfld.coupled())
{
//Pout<< "eval of " << pfld.patch().name() << endl;
pfld.evaluate(commsType);
}
}
// Evaluate all coupled fields
fld.boundaryFieldRef().template evaluateCoupled<void>();
}
@ -1030,13 +995,13 @@ void Foam::oversetFvMeshBase::checkCoupledBC(const GeoField& fld)
GeoField fldCorr(fld.name()+"_correct", fld);
correctCoupledBoundaryConditions(fldCorr);
const typename GeoField::Boundary& bfld = fld.boundaryField();
const typename GeoField::Boundary& bfldCorr = fldCorr.boundaryField();
const auto& bfld = fld.boundaryField();
const auto& bfldCorr = fldCorr.boundaryField();
forAll(bfld, patchi)
{
const typename GeoField::Patch& pfld = bfld[patchi];
const typename GeoField::Patch& pfldCorr = bfldCorr[patchi];
const auto& pfld = bfld[patchi];
const auto& pfldCorr = bfldCorr[patchi];
Pout<< "Patch:" << pfld.patch().name() << endl;