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-field-functions-SIMD' into 'develop'

Browse Source 
Field functions for lerp and clamp. Add clamping as Field methods

See merge request Development/openfoam!593
This commit is contained in:
Andrew Heather
2023-02-21 09:17:57 +00:00
parent a7d77391fa f180740b03
commit 40bdab1c1a
195 changed files with 5254 additions and 3056 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
applications/solvers/combustion/XiFoam/bEqn.H
View File

@ -171,10 +171,7 @@ if (ign.ignited())
fvOptions.correct(Su); fvOptions.correct(Su);
// Limit the maximum Su Su.clamp_range(SuMin, SuMax);
// ~~~~~~~~~~~~~~~~~~~~
Su.min(SuMax);
Su.max(SuMin);
} }
else else
{ {
@ -218,7 +215,7 @@ if (ign.ignited())
+ ( + (
scalar(1) scalar(1)
+ (2*XiShapeCoef) + (2*XiShapeCoef)
*(scalar(0.5) - min(max(b, scalar(0)), scalar(1))) *(scalar(0.5) - clamp(b, zero_one{}))
)*(XiEqStar - scalar(1.001)) )*(XiEqStar - scalar(1.001))
); );

4
applications/solvers/combustion/fireFoam/YEEqn.H
View File

@ -39,13 +39,13 @@ tmp<fv::convectionScheme<scalar>> mvConvection
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
radiation->correct(); radiation->correct();

4
applications/solvers/combustion/reactingFoam/YEqn.H
View File

@ -38,11 +38,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
} }

4
applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/YEqn.H
View File

@ -48,7 +48,7 @@ if (Y.size())
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
@ -56,6 +56,6 @@ if (Y.size())
if (Y.size()) if (Y.size())
{ {
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
} }
} }

4
applications/solvers/lagrangian/coalChemistryFoam/YEqn.H
View File

@ -40,11 +40,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
} }

4
applications/solvers/lagrangian/reactingParcelFoam/YEqn.H
View File

@ -41,11 +41,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
} }

4
applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/YEqn.H
View File

@ -38,11 +38,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
} }

4
applications/solvers/lagrangian/simpleCoalParcelFoam/YEqn.H
View File

@ -38,11 +38,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
} }

4
applications/solvers/lagrangian/sprayFoam/YEqn.H
View File

@ -39,11 +39,11 @@ tmp<fv::convectionScheme<scalar>> mvConvection
fvOptions.correct(Yi); fvOptions.correct(Yi);
Yi.max(0.0); Yi.clamp_min(0);
Yt += Yi; Yt += Yi;
} }
} }
Y[inertIndex] = scalar(1) - Yt; Y[inertIndex] = scalar(1) - Yt;
Y[inertIndex].max(0.0); Y[inertIndex].clamp_min(0);
} }

11
applications/solvers/multiphase/cavitatingFoam/alphavPsi.H
View File

@ -1,14 +1,5 @@
{ {
alphav = alphav = clamp((rho - rholSat)/(rhovSat - rholSat), zero_one{});
max
(
min
(
(rho - rholSat)/(rhovSat - rholSat),
scalar(1)
),
scalar(0)
);
alphal = 1.0 - alphav; alphal = 1.0 - alphav;
Info<< "max-min alphav: " << max(alphav).value() Info<< "max-min alphav: " << max(alphav).value()

57
applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/constant/constant.C
View File

@ -99,17 +99,6 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDotAlphal() const
Foam::Pair<Foam::tmp<Foam::volScalarField>> Foam::Pair<Foam::tmp<Foam::volScalarField>>
Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDot() const Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDot() const
{ {
volScalarField limitedAlpha1
(
min(max(mixture_.alpha1(), scalar(0)), scalar(1))
);
volScalarField limitedAlpha2
(
min(max(mixture_.alpha2(), scalar(0)), scalar(1))
);
const volScalarField& T = mesh_.lookupObject<volScalarField>("T"); const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
const twoPhaseMixtureEThermo& thermo = const twoPhaseMixtureEThermo& thermo =
@ -124,11 +113,15 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDot() const
volScalarField mDotE volScalarField mDotE
( (
"mDotE", coeffE_*mixture_.rho1()*limitedAlpha1*max(T - TSat, T0) "mDotE",
coeffE_*mixture_.rho1()*clamp(mixture_.alpha1(), zero_one{})
* max(T - TSat, T0)
); );
volScalarField mDotC volScalarField mDotC
( (
"mDotC", coeffC_*mixture_.rho2()*limitedAlpha2*max(TSat - T, T0) "mDotC",
coeffC_*mixture_.rho2()*clamp(mixture_.alpha2(), zero_one{})
* max(TSat - T, T0)
); );
if (mesh_.time().outputTime()) if (mesh_.time().outputTime())
@ -148,16 +141,6 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDot() const
Foam::Pair<Foam::tmp<Foam::volScalarField>> Foam::Pair<Foam::tmp<Foam::volScalarField>>
Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDotDeltaT() const Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDotDeltaT() const
{ {
volScalarField limitedAlpha1
(
min(max(mixture_.alpha1(), scalar(0)), scalar(1))
);
volScalarField limitedAlpha2
(
min(max(mixture_.alpha2(), scalar(0)), scalar(1))
);
const volScalarField& T = mesh_.lookupObject<volScalarField>("T"); const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
const twoPhaseMixtureEThermo& thermo = const twoPhaseMixtureEThermo& thermo =
@ -170,8 +153,14 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::mDotDeltaT() const
return Pair<tmp<volScalarField>> return Pair<tmp<volScalarField>>
( (
coeffC_*mixture_.rho2()*limitedAlpha2*pos(TSat - T), (
coeffE_*mixture_.rho1()*limitedAlpha1*pos(T - TSat) coeffC_*mixture_.rho2()*clamp(mixture_.alpha2(), zero_one{})
* pos(TSat - T)
),
(
coeffE_*mixture_.rho1()*clamp(mixture_.alpha1(), zero_one{})
* pos(T - TSat)
)
); );
} }
@ -201,25 +190,17 @@ Foam::temperaturePhaseChangeTwoPhaseMixtures::constant::TSource() const
const dimensionedScalar& TSat = thermo.TSat(); const dimensionedScalar& TSat = thermo.TSat();
dimensionedScalar L = mixture_.Hf2() - mixture_.Hf1(); const dimensionedScalar L = mixture_.Hf2() - mixture_.Hf1();
volScalarField limitedAlpha1
(
min(max(mixture_.alpha1(), scalar(0)), scalar(1))
);
volScalarField limitedAlpha2
(
min(max(mixture_.alpha2(), scalar(0)), scalar(1))
);
const volScalarField Vcoeff const volScalarField Vcoeff
( (
coeffE_*mixture_.rho1()*limitedAlpha1*L*pos(T - TSat) coeffE_*mixture_.rho1()*clamp(mixture_.alpha1(), zero_one{})
* L*pos(T - TSat)
); );
const volScalarField Ccoeff const volScalarField Ccoeff
( (
coeffC_*mixture_.rho2()*limitedAlpha2*L*pos(TSat - T) coeffC_*mixture_.rho2()*clamp(mixture_.alpha2(), zero_one{})
* L*pos(TSat - T)
); );
TSource = TSource =

14
applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/interfaceHeatResistance/interfaceHeatResistance.C
View File

@ -167,20 +167,10 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
Foam::temperaturePhaseChangeTwoPhaseMixtures::interfaceHeatResistance:: Foam::temperaturePhaseChangeTwoPhaseMixtures::interfaceHeatResistance::
mDotAlphal() const mDotAlphal() const
{ {
volScalarField limitedAlpha1
(
min(max(mixture_.alpha1(), scalar(0)), scalar(1))
);
volScalarField limitedAlpha2
(
min(max(mixture_.alpha2(), scalar(0)), scalar(1))
);
return Pair<tmp<volScalarField>> return Pair<tmp<volScalarField>>
( (
(mDotc_/(limitedAlpha2 + SMALL)), (mDotc_/clamp(mixture_.alpha2(), scalarMinMax(SMALL, 1))),
-(mDote_/(limitedAlpha1 + SMALL)) -(mDote_/clamp(mixture_.alpha1(), scalarMinMax(SMALL, 1)))
); );
} }

44
applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/twoPhaseMixtureEThermo/twoPhaseMixtureEThermo.C
View File

@ -155,7 +155,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::Cp() const
{ {
const volScalarField limitedAlpha1 const volScalarField limitedAlpha1
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_, zero_one{})
); );
return tmp<volScalarField> return tmp<volScalarField>
@ -176,13 +176,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::Cp
const label patchi const label patchi
) const ) const
{ {
const volScalarField limitedAlpha1 const scalarField alpha1p
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_.boundaryField()[patchi], zero_one{})
); );
const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
return return
( (
alpha1p*Cp1().value() + (scalar(1) - alpha1p)*Cp2().value() alpha1p*Cp1().value() + (scalar(1) - alpha1p)*Cp2().value()
@ -194,7 +192,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::rho() const
{ {
const volScalarField limitedAlpha1 const volScalarField limitedAlpha1
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_, zero_one{})
); );
return tmp<volScalarField> return tmp<volScalarField>
@ -214,13 +212,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::rho
const label patchi const label patchi
) const ) const
{ {
const volScalarField limitedAlpha1 const scalarField alpha1p
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_.boundaryField()[patchi], zero_one{})
); );
const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
return return
( (
alpha1p*rho1().value() + (scalar(1) - alpha1p)*rho2().value() alpha1p*rho1().value() + (scalar(1) - alpha1p)*rho2().value()
@ -232,7 +228,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::Cv() const
{ {
const volScalarField limitedAlpha1 const volScalarField limitedAlpha1
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_, zero_one{})
); );
return tmp<volScalarField> return tmp<volScalarField>
@ -253,13 +249,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::Cv
const label patchi const label patchi
) const ) const
{ {
const volScalarField limitedAlpha1 const scalarField alpha1p
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_.boundaryField()[patchi], zero_one{})
); );
const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
return return
( (
alpha1p*Cv1().value() + (scalar(1) - alpha1p)*Cv2().value() alpha1p*Cv1().value() + (scalar(1) - alpha1p)*Cv2().value()
@ -339,7 +333,7 @@ Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureEThermo::kappa() const
{ {
const volScalarField limitedAlpha1 const volScalarField limitedAlpha1
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_, zero_one{})
); );
return tmp<volScalarField> return tmp<volScalarField>
@ -358,13 +352,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::kappa
const label patchi const label patchi
) const ) const
{ {
const volScalarField limitedAlpha1 const scalarField alpha1p
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_.boundaryField()[patchi], zero_one{})
); );
const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
return (alpha1p*kappa1().value() + (1 - alpha1p)*kappa2().value()); return (alpha1p*kappa1().value() + (1 - alpha1p)*kappa2().value());
} }
@ -402,13 +394,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::kappaEff
const label patchi const label patchi
) const ) const
{ {
const volScalarField limitedAlpha1 const scalarField alpha1p
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_.boundaryField()[patchi], zero_one{})
); );
const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
return return
(alpha1p*kappa1().value() + (1 - alpha1p)*kappa2().value()) + kappat; (alpha1p*kappa1().value() + (1 - alpha1p)*kappa2().value()) + kappat;
@ -435,13 +425,11 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureEThermo::alphaEff
const label patchi const label patchi
) const ) const
{ {
const volScalarField limitedAlpha1 const scalarField alpha1p
( (
min(max(alpha1_, scalar(0)), scalar(1)) clamp(alpha1_.boundaryField()[patchi], zero_one{})
); );
const scalarField& alpha1p = limitedAlpha1.boundaryField()[patchi];
const scalarField rho const scalarField rho
( (
alpha1p*rho1().value() + (1.0 - alpha1p)*rho2().value() alpha1p*rho1().value() + (1.0 - alpha1p)*rho2().value()

4
applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Kunz/Kunz.C
View File

@ -70,7 +70,7 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotAlphal() const Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotAlphal() const
{ {
const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p"); const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1))); volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
return Pair<tmp<volScalarField>> return Pair<tmp<volScalarField>>
( (
@ -85,7 +85,7 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotP() const Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotP() const
{ {
const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p"); const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1))); volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
return Pair<tmp<volScalarField>> return Pair<tmp<volScalarField>>
( (

2
applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/Merkle/Merkle.C
View File

@ -82,7 +82,7 @@ Foam::Pair<Foam::tmp<Foam::volScalarField>>
Foam::phaseChangeTwoPhaseMixtures::Merkle::mDotP() const Foam::phaseChangeTwoPhaseMixtures::Merkle::mDotP() const
{ {
const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p"); const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1))); volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
return Pair<tmp<volScalarField>> return Pair<tmp<volScalarField>>
( (

6
applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C
View File

@ -99,7 +99,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::pCoeff
const volScalarField& p const volScalarField& p
) const ) const
{ {
volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1))); volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
volScalarField rho volScalarField rho
( (
limitedAlpha1*rho1() + (scalar(1) - limitedAlpha1)*rho2() limitedAlpha1*rho1() + (scalar(1) - limitedAlpha1)*rho2()
@ -117,7 +117,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::mDotAlphal() const
const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p"); const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
volScalarField pCoeff(this->pCoeff(p)); volScalarField pCoeff(this->pCoeff(p));
volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1))); volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
return Pair<tmp<volScalarField>> return Pair<tmp<volScalarField>>
( (
@ -134,7 +134,7 @@ Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::mDotP() const
const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p"); const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
volScalarField pCoeff(this->pCoeff(p)); volScalarField pCoeff(this->pCoeff(p));
volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1))); volScalarField limitedAlpha1(clamp(alpha1_, zero_one{}));
volScalarField apCoeff(limitedAlpha1*pCoeff); volScalarField apCoeff(limitedAlpha1*pCoeff);
return Pair<tmp<volScalarField>> return Pair<tmp<volScalarField>>

17
applications/test/minMax2/Test-minMax2.C
View File

@ -152,19 +152,26 @@ int main(int argc, char *argv[])
Info<< nl Info<< nl
<< "field: " << flatOutput(someField) << nl; << "field: " << flatOutput(someField) << nl;
Info<< "clamp01: " Info<< "clamp01: "
<< flatOutput(clamp(someField, scalarMinMax(zero_one{}))()) << nl; << flatOutput(clamp(someField, zero_one{})()) << nl;
Info<< "clamp01: " Info<< "clamp01: "
<< clamp(tmp<scalarField>(someField), scalarMinMax(zero_one{}))<< nl; << clamp(tmp<scalarField>(someField), zero_one{})<< nl;
scalarField result(10); scalarField result(10);
clamp(result, someField, scalarMinMax(zero_one{})); clamp(result, someField, zero_one{});
Info<< "result: " << result << nl; Info<< "result: " << result << nl;
someField.clamp(zero_one{}); someField.clamp_range(zero_one{});
Info<< "inplace: " << someField << nl; Info<< "inplace: " << someField << nl;
scalar val(1.414);
Info<< "clamp " << val
// nope << " : " << clamp(val, zero_one{})
// nope << " : " << clamp(val, scalarMinMax(zero_one{}))
<< " : " << clamp(val, 0, 1)
<< nl;
} }
Info<< nl << "\nDone\n" << endl; Info<< nl << "\nDone\n" << endl;

200
applications/test/speed/vectorSpeed/Test-vectorSpeed.C
View File

@ -1,3 +1,38 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011 OpenFOAM Foundation
Copyright (C) 2023 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/>.
Application
Test-vectorSpeed
Description
Test speeds, usability of some field operations
\*---------------------------------------------------------------------------*/
#include "argList.H"
#include "primitiveFields.H" #include "primitiveFields.H"
#include "cpuTime.H" #include "cpuTime.H"
#include "IOstreams.H" #include "IOstreams.H"
@ -5,12 +40,22 @@
using namespace Foam; using namespace Foam;
int main() // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
{
const label nIter = 100;
const label size = 1000000;
Info<< "Initialising fields" << endl; int main(int argc, char *argv[])
{
argList::noParallel();
argList::addBoolOption("lerp");
argList args(argc, argv);
const label nIter = 1000;
const label size = (1000000);
Info<< "Initialising fields. size:" << size
<< " max:" << labelMax << endl;
scalarField onet(size);
vectorField vectorField
vf1(size, vector::one), vf1(size, vector::one),
@ -18,11 +63,14 @@ int main()
vf3(size, vector::one), vf3(size, vector::one),
vf4(size); vf4(size);
Info<< "Done\n" << endl; Info<< "Start loop: " << nIter << endl;
cpuTime timing;
// Timing is mostly malloc anyhow...
if (!args.found("lerp"))
{ {
cpuTime executionTime;
Info<< "vectorField algebra" << endl; Info<< "vectorField algebra" << endl;
for (int j=0; j<nIter; j++) for (int j=0; j<nIter; j++)
@ -30,12 +78,142 @@ int main()
vf4 = vf1 + vf2 - vf3; vf4 = vf1 + vf2 - vf3;
} }
Info<< "ExecutionTime = " Info<< "Timing = " << timing.cpuTimeIncrement() << " s" << endl;
<< executionTime.elapsedCpuTime()
<< " s\n" << endl;
Snull<< vf4[1] << endl << endl; Snull<< vf4[1] << endl << endl;
} }
if (args.found("lerp"))
{
Info<< nl
<< "testing timings with lerp 0.75" << nl
<< "Main bottlenecks: malloc and looping" << nl;
scalar t = 0.75;
scalarField fract(size, t);
// Basic compilation tests:
lerp(vf1, vf2, fract)().size(); // list list list
lerp(0.5*vf1, vf2, fract)().size(); // tmp list list
lerp(vf1, 0.5*vf2, fract)().size(); // list tmp list
lerp(vf1, vf2, 0.5*fract)().size(); // list list tmp
lerp(0.5*vf1, 0.5*vf2, fract)().size(); // tmp tmp list
lerp(0.5*vf1, vf2, 0.5*fract)().size(); // tmp list tmp
lerp(vf1, 1.0*vf2, 0.5*fract)().size(); // list tmp tmp
lerp(0.5*vf1, 0.5*vf2, 0.5*fract)().size(); // tmp tmp tmp
// Basic compilation tests:
lerp(vf1, vf2, t)().size(); // list list scalar
lerp(0.5*vf1, vf2, t)().size(); // tmp list scalar
lerp(vf1, 0.5*vf2, t)().size(); // list tmp scalar
lerp(0.5*vf1, 0.5*vf2, t)().size(); // tmp tmp scalar
lerp(vf1, 1.0*vf2, 0.5*t)().size(); // list tmp scalar
// Other combinations (not yet included)
// list scalar list...
// scalar list list...
// Probable base line of single instruction multiple data
for (int j=0; j<nIter; j++)
{
const label loopLen = (vf1).size();
for (label i = 0; i < loopLen; ++i)
{
vf4[i] = (1-fract[i])*vf1[i] + fract[i]*vf2[i];
}
}
Info<< "(1-t)*a + t*b : Timing (no malloc) = "
<< timing.cpuTimeIncrement() << " s" << endl;
Snull<< vf4[1] << endl << endl;
// With all loops written out
// - corresponds to what we would normally have
for (int j=0; j<nIter; j++)
{
const label loopLen = (vf1).size();
for (label i = 0; i < loopLen; ++i)
{
onet[i] = (1-fract[i]);
}
for (label i = 0; i < loopLen; ++i)
{
vf3[i] = (fract[i] * vf2[i]);
}
for (label i = 0; i < loopLen; ++i)
{
vf4[i] = onet[i] * vf1[i];
}
for (label i = 0; i < loopLen; ++i)
{
vf4[i] += vf3[i];
}
}
Info<< "(1-t)*a + t*b : Looping (no malloc) = "
<< timing.cpuTimeIncrement() << " s" << endl;
Snull<< vf4[1] << endl << endl;
for (int j=0; j<nIter; j++)
{
lerp(vf4, vf1, vf2, fract);
}
Info<< "lerp(a, b, t) : Timing (no malloc) = "
<< timing.cpuTimeIncrement() << " s" << endl;
Snull<< vf4[1] << endl << endl;
Info<< nl;
// Now with tmp fields
// ~~~~~~~~~~~~~~~~~~~
for (int j=0; j<nIter; j++)
{
vf4 = (1-fract)*vf1 + fract*vf2;
}
Info<< "(1-t)*a + t*b : Timing (with malloc) = "
<< timing.cpuTimeIncrement() << " s" << endl;
Snull<< vf4[1] << endl << endl;
for (int j=0; j<nIter; j++)
{
// With field 't'
vf4 = lerp(vf1, vf2, fract);
}
Info<< "lerp(a, b, t) : Timing (with malloc) = "
<< timing.cpuTimeIncrement() << " s" << endl;
Snull<< vf4[1] << endl << endl;
for (int j=0; j<nIter; j++)
{
// With scalar 't'
vf4 = lerp(vf1, vf2, t);
}
Info<< "lerp(a, b, t) : Timing (with malloc) scalar = "
<< timing.cpuTimeIncrement() << " s" << endl;
Snull<< vf4[1] << endl << endl;
}
Info<< nl << "Done" << nl << endl;
return 0; return 0;
} }
// ************************************************************************* //

4
applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/vectorTools/vectorTools.H
View File

@ -114,7 +114,7 @@ namespace vectorTools
scalar cosPhi = (a & b)/(mag(a)*mag(b) + tolerance); scalar cosPhi = (a & b)/(mag(a)*mag(b) + tolerance);
// Enforce bounding between -1 and 1 // Enforce bounding between -1 and 1
return min(max(cosPhi, -1), 1); return clamp(cosPhi, -1, 1);
} }
//- Calculate angle between a and b in radians //- Calculate angle between a and b in radians
@ -129,7 +129,7 @@ namespace vectorTools
scalar cosPhi = (a & b)/(mag(a)*mag(b) + tolerance); scalar cosPhi = (a & b)/(mag(a)*mag(b) + tolerance);
// Enforce bounding between -1 and 1 // Enforce bounding between -1 and 1
return acos( min(max(cosPhi, -1), 1) ); return acos(clamp(cosPhi, -1, 1));
} }
//- Calculate angle between a and b in degrees //- Calculate angle between a and b in degrees

4
applications/utilities/preProcessing/applyBoundaryLayer/applyBoundaryLayer.C
View File

@ -92,7 +92,7 @@ void blendField
volScalarField fld(fieldHeader, mesh); volScalarField fld(fieldHeader, mesh);
scalarField& pf = fld.primitiveFieldRef(); scalarField& pf = fld.primitiveFieldRef();
pf = (1 - mask)*pf + mask*boundaryLayerField; pf = (1 - mask)*pf + mask*boundaryLayerField;
fld.max(SMALL); fld.clamp_min(SMALL);
// Correct the processor patches only. // Correct the processor patches only.
// Do not correct BC // Do not correct BC
@ -131,7 +131,7 @@ void calcOmegaField
scalarField& pf = omega.primitiveFieldRef(); scalarField& pf = omega.primitiveFieldRef();
pf = (1 - mask)*pf + mask*epsilonBL/(Cmu*kBL + SMALL); pf = (1 - mask)*pf + mask*epsilonBL/(Cmu*kBL + SMALL);
omega.max(SMALL); omega.clamp_min(SMALL);
// Correct the processor patches only. // Correct the processor patches only.
// Do not correct BC // Do not correct BC

2
applications/utilities/preProcessing/setAlphaField/setAlphaField.C
View File

@ -108,7 +108,7 @@ void setAlpha
{ {
cutCell.calcSubCell(cellI, 0.0); cutCell.calcSubCell(cellI, 0.0);
alpha1[cellI] = max(min(cutCell.VolumeOfFluid(), 1), 0); alpha1[cellI] = clamp(cutCell.VolumeOfFluid(), 0, 1);
if (writeOBJ && (mag(cutCell.faceArea()) >= 1e-14)) if (writeOBJ && (mag(cutCell.faceArea()) >= 1e-14))
{ {

10
applications/utilities/preProcessing/setTurbulenceFields/setTurbulenceFields.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com \\ / A nd | www.openfoam.com
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2022 OpenCFD Ltd. Copyright (C) 2022-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -241,13 +241,7 @@ void calcF
solve(fEqn); solve(fEqn);
// (M:p. 2) // (M:p. 2)
const dimensioned<scalarMinMax> fMinMax f.clamp_range(0, scalar(1) - Foam::exp(-scalar(400)/scalar(50)));
(
dimless,
scalarMinMax(Zero, scalar(1) - Foam::exp(-scalar(400)/scalar(50)))
);
f.clip(fMinMax);
} }

2
etc/codeTemplates/BC/BC.C
View File

@ -207,7 +207,7 @@ void Foam::CLASS::updateCoeffs()
const scalarField& phip = const scalarField& phip =
this->patch().template lookupPatchField<surfaceScalarField>("phi"); this->patch().template lookupPatchField<surfaceScalarField>("phi");
this->valueFraction() = 1.0 - pos0(phip); this->valueFraction() = neg(phip);
PARENT::updateCoeffs(); PARENT::updateCoeffs();
} }

2
src/ODE/ODESolvers/adaptiveSolver/adaptiveSolver.C
View File

@ -101,7 +101,7 @@ void Foam::adaptiveSolver::solve
if (err > pow(maxScale_/safeScale_, -1.0/alphaInc_)) if (err > pow(maxScale_/safeScale_, -1.0/alphaInc_))
{ {
dxTry = dxTry =
min(max(safeScale_*pow(err, -alphaInc_), minScale_), maxScale_)*dx; clamp(safeScale_*pow(err, -alphaInc_), minScale_, maxScale_)*dx;
} }
else else
{ {

489
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd. Copyright (C) 2019-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -36,32 +36,27 @@ License
namespace Foam namespace Foam
{ {
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type, class GeoMesh, direction r> template<class Type, class GeoMesh, direction r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>> tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow pow
( (
const DimensionedField<Type, GeoMesh>& df, const DimensionedField<Type, GeoMesh>& f1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
) )
{ {
typedef typename powProduct<Type, r>::type powProductType; typedef typename powProduct<Type, r>::type resultType;
auto tres = auto tres =
tmp<DimensionedField<powProductType, GeoMesh>>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
IOobject f1,
( "pow(" + f1.name() + ',' + Foam::name(r) + ')',
"pow(" + df.name() + ',' + name(r) + ')', pow(f1.dimensions(), r)
df.instance(),
df.db()
),
df.mesh(),
pow(df.dimensions(), r)
); );
pow<Type, r, GeoMesh>(tres.ref().field(), df.field()); pow<Type, r, GeoMesh>(tres.ref().field(), f1.field());
return tres; return tres;
} }
@ -71,166 +66,151 @@ template<class Type, class GeoMesh, direction r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>> tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow pow
( (
const tmp<DimensionedField<Type, GeoMesh>>& tdf, const tmp<DimensionedField<Type, GeoMesh>>& tf1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
) )
{ {
typedef typename powProduct<Type, r>::type powProductType; typedef typename powProduct<Type, r>::type resultType;
const DimensionedField<Type, GeoMesh>& df = tdf(); const auto& f1 = tf1();
auto tres = auto tres =
reuseTmpDimensionedField<powProductType, Type, GeoMesh>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
tdf, tf1,
"pow(" + df.name() + ',' + name(r) + ')', "pow(" + f1.name() + ',' + Foam::name(r) + ')',
pow(df.dimensions(), r) pow(f1.dimensions(), r)
); );
pow<Type, r, GeoMesh>(tres.ref().field(), df.field()); pow<Type, r, GeoMesh>(tres.ref().field(), f1.field());
tdf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>> tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const DimensionedField<Type, GeoMesh>& df) sqr(const DimensionedField<Type, GeoMesh>& f1)
{ {
typedef typename outerProduct<Type, Type>::type outerProductType; typedef typename outerProduct<Type, Type>::type resultType;
auto tres = auto tres =
tmp<DimensionedField<outerProductType, GeoMesh>>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
IOobject f1,
( "sqr(" + f1.name() + ')',
"sqr(" + df.name() + ')', sqr(f1.dimensions())
df.instance(),
df.db()
),
df.mesh(),
sqr(df.dimensions())
); );
sqr(tres.ref().field(), df.field()); sqr(tres.ref().field(), f1.field());
return tres; return tres;
} }
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>> tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf) sqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
{ {
typedef typename outerProduct<Type, Type>::type outerProductType; typedef typename outerProduct<Type, Type>::type resultType;
const DimensionedField<Type, GeoMesh>& df = tdf(); const auto& f1 = tf1();
auto tres = auto tres =
reuseTmpDimensionedField<outerProductType, Type, GeoMesh>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
tdf, tf1,
"sqr(" + df.name() + ')', "sqr(" + f1.name() + ')',
sqr(df.dimensions()) sqr(f1.dimensions())
); );
sqr(tres.ref().field(), df.field()); sqr(tres.ref().field(), f1.field());
tdf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
magSqr(const DimensionedField<Type, GeoMesh>& df) magSqr(const DimensionedField<Type, GeoMesh>& f1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres = auto tres =
tmp<DimensionedField<magType, GeoMesh>>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
IOobject f1,
( "magSqr(" + f1.name() + ')',
"magSqr(" + df.name() + ')', sqr(f1.dimensions())
df.instance(),
df.db()
),
df.mesh(),
sqr(df.dimensions())
); );
magSqr(tres.ref().field(), df.field()); magSqr(tres.ref().field(), f1.field());
return tres; return tres;
} }
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf) magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
const DimensionedField<Type, GeoMesh>& df = tdf(); const auto& f1 = tf1();
auto tres = auto tres =
reuseTmpDimensionedField<magType, Type, GeoMesh>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
tdf, tf1,
"magSqr(" + df.name() + ')', "magSqr(" + f1.name() + ')',
sqr(df.dimensions()) sqr(f1.dimensions())
); );
magSqr(tres.ref().field(), df.field()); magSqr(tres.ref().field(), f1.field());
tdf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
mag(const DimensionedField<Type, GeoMesh>& df) mag(const DimensionedField<Type, GeoMesh>& f1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres = auto tres =
tmp<DimensionedField<magType, GeoMesh>>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
IOobject f1,
( "mag(" + f1.name() + ')',
"mag(" + df.name() + ')', f1.dimensions()
df.instance(),
df.db()
),
df.mesh(),
df.dimensions()
); );
mag(tres.ref().field(), df.field()); mag(tres.ref().field(), f1.field());
return tres; return tres;
} }
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
mag(const tmp<DimensionedField<Type, GeoMesh>>& tdf) mag(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
const DimensionedField<Type, GeoMesh>& df = tdf(); const auto& f1 = tf1();
auto tres = auto tres =
reuseTmpDimensionedField<magType, Type, GeoMesh>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
tdf, tf1,
"mag(" + df.name() + ')', "mag(" + f1.name() + ')',
df.dimensions() f1.dimensions()
); );
mag(tres.ref().field(), df.field()); mag(tres.ref().field(), f1.field());
tdf.clear(); tf1.clear();
return tres; return tres;
} }
@ -243,24 +223,19 @@ tmp
typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh
> >
> >
cmptAv(const DimensionedField<Type, GeoMesh>& df) cmptAv(const DimensionedField<Type, GeoMesh>& f1)
{ {
typedef typename DimensionedField<Type, GeoMesh>::cmptType cmptType; typedef typename DimensionedField<Type, GeoMesh>::cmptType resultType;
auto tres = auto tres =
tmp<DimensionedField<cmptType, GeoMesh>>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
IOobject f1,
( "cmptAv(" + f1.name() + ')',
"cmptAv(" + df.name() + ')', f1.dimensions()
df.instance(),
df.db()
),
df.mesh(),
df.dimensions()
); );
cmptAv(tres.ref().field(), df.field()); cmptAv(tres.ref().field(), f1.field());
return tres; return tres;
} }
@ -274,51 +249,51 @@ tmp
typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh
> >
> >
cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tdf) cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tf1)
{ {
typedef typename DimensionedField<Type, GeoMesh>::cmptType cmptType; typedef typename DimensionedField<Type, GeoMesh>::cmptType resultType;
const DimensionedField<Type, GeoMesh>& df = tdf(); const auto& f1 = tf1();
auto tres = auto tres =
reuseTmpDimensionedField<cmptType, Type, GeoMesh>::New reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
( (
tdf, tf1,
"cmptAv(" + df.name() + ')', "cmptAv(" + f1.name() + ')',
df.dimensions() f1.dimensions()
); );
cmptAv(tres.ref().field(), df.field()); cmptAv(tres.ref().field(), f1.field());
tdf.clear(); tf1.clear();
return tres; return tres;
} }
#define UNARY_REDUCTION_FUNCTION(returnType, func, dfunc) \ #define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc) \
\ \
template<class Type, class GeoMesh> \ template<class Type, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const DimensionedField<Type, GeoMesh>& df \ const DimensionedField<Type, GeoMesh>& f1 \
) \ ) \
{ \ { \
return dimensioned<returnType> \ return dimensioned<ReturnType> \
( \ ( \
#func "(" + df.name() + ')', \ #Func "(" + f1.name() + ')', \
df.dimensions(), \ f1.dimensions(), \
dfunc(df.field()) \ gFunc(f1.field()) \
); \ ); \
} \ } \
\ \
template<class Type, class GeoMesh> \ template<class Type, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \ const tmp<DimensionedField<Type, GeoMesh>>& tf1 \
) \ ) \
{ \ { \
dimensioned<returnType> res = func(tdf1()); \ dimensioned<ReturnType> res = Func(tf1()); \
tdf1.clear(); \ tf1.clear(); \
return res; \ return res; \
} }
@ -344,10 +319,81 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)
// ------------------------------------------------------------------------- //
// Clamp Methods
template<class Type, class GeoMesh>
void clamp
(
DimensionedField<Type, GeoMesh>& result,
const DimensionedField<Type, GeoMesh>& f1,
const Foam::zero_one
)
{
const MinMax<Type> range(Foam::zero_one{});
clamp(result.field(), f1.field(), range);
result.oriented() = f1.oriented();
}
template<class Type, class GeoMesh>
tmp<DimensionedField<Type, GeoMesh>>
clamp
(
const DimensionedField<Type, GeoMesh>& f1,
const Foam::zero_one
)
{
auto tres =
reuseTmpDimensionedField<Type, Type, GeoMesh>::New
(
f1,
"clamp01(" + f1.name() + ')',
f1.dimensions()
);
clamp(tres.ref(), f1, Foam::zero_one{});
return tres;
}
// * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * // template<class Type, class GeoMesh>
tmp<DimensionedField<Type, GeoMesh>>
clamp
(
const tmp<DimensionedField<Type, GeoMesh>>& tf1,
const Foam::zero_one
)
{
const auto& f1 = tf1();
auto tres =
reuseTmpDimensionedField<Type, Type, GeoMesh>::New
(
tf1,
"clamp01(" + f1.name() + ')',
f1.dimensions()
);
clamp(tres.field(), f1, Foam::zero_one{});
tf1.clear();
return tres;
}
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
UNARY_OPERATOR(Type, Type, -, negate, transform) UNARY_OPERATOR(Type, Type, -, negate, transform)
@ -363,32 +409,27 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \ #define PRODUCT_OPERATOR(product, Op, OpFunc) \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type2, GeoMesh>& f2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
\ \
auto tres = \ auto tres = \
tmp<DimensionedField<productType, GeoMesh>>::New \ reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New \
( \ ( \
IOobject \ f1, \
( \ '(' + f1.name() + #Op + f2.name() + ')', \
'(' + df1.name() + #op + df2.name() + ')', \ (f1.dimensions() Op f2.dimensions()) \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
df1.dimensions() op df2.dimensions() \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), df1.field(), df2.field()); \ Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
\ \
return tres; \ return tres; \
} \ } \
@ -396,113 +437,108 @@ operator op \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
\ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \ const auto& f2 = tf2(); \
\ \
auto tres = \ auto tres = \
reuseTmpDimensionedField<productType, Type2, GeoMesh>::New \ reuseTmpDimensionedField<resultType, Type2, GeoMesh>::New \
( \ ( \
tdf2, \ tf2, \
'(' + df1.name() + #op + df2.name() + ')', \ '(' + f1.name() + #Op + f2.name() + ')', \
df1.dimensions() op df2.dimensions() \ (f1.dimensions() Op f2.dimensions()) \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), df1.field(), df2.field()); \ Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
\ \
tdf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
} \ } \
\ \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type2, GeoMesh>& f2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
\ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \ const auto& f1 = tf1(); \
\ \
auto tres = \ auto tres = \
reuseTmpDimensionedField<productType, Type1, GeoMesh>::New \ reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New \
( \ ( \
tdf1, \ tf1, \
'(' + df1.name() + #op + df2.name() + ')', \ '(' + f1.name() + #Op + f2.name() + ')', \
df1.dimensions() op df2.dimensions() \ (f1.dimensions() Op f2.dimensions()) \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), df1.field(), df2.field()); \ Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
\ \
tdf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} \ } \
\ \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
\ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \ const auto& f1 = tf1(); \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \ const auto& f2 = tf2(); \
\ \
auto tres = \ auto tres = \
reuseTmpTmpDimensionedField \ reuseTmpTmpDimensionedField \
<productType, Type1, Type1, Type2, GeoMesh>::New \ <resultType, Type1, Type1, Type2, GeoMesh>::New \
( \ ( \
tdf1, \ tf1, \
tdf2, \ tf2, \
'(' + df1.name() + #op + df2.name() + ')', \ '(' + f1.name() + #Op + f2.name() + ')', \
df1.dimensions() op df2.dimensions() \ (f1.dimensions() Op f2.dimensions()) \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), df1.field(), df2.field()); \ Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
\ \
tdf1.clear(); \ tf1.clear(); \
tdf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
} \ } \
\ \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type, GeoMesh>& df1, \ const DimensionedField<Type, GeoMesh>& f1, \
const dimensioned<Form>& dvs \ const dimensioned<Form>& dvs \
) \ ) \
{ \ { \
typedef typename product<Type, Form>::type productType; \ typedef typename product<Type, Form>::type resultType; \
\ \
auto tres = \ auto tres = \
tmp<DimensionedField<productType, GeoMesh>>::New \ reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \ ( \
IOobject \ f1, \
( \ '(' + f1.name() + #Op + dvs.name() + ')', \
'(' + df1.name() + #op + dvs.name() + ')', \ (f1.dimensions() Op dvs.dimensions()) \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
df1.dimensions() op dvs.dimensions() \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), df1.field(), dvs.value()); \ Foam::OpFunc(tres.ref().field(), f1.field(), dvs.value()); \
\ \
return tres; \ return tres; \
} \ } \
@ -510,79 +546,74 @@ operator op \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type, GeoMesh>& df1, \ const DimensionedField<Type, GeoMesh>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \ ) \
{ \ { \
return df1 op dimensioned<Form>(static_cast<const Form&>(vs)); \ return f1 Op dimensioned<Form>(static_cast<const Form&>(vs)); \
} \ } \
\ \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type, GeoMesh>>& tf1, \
const dimensioned<Form>& dvs \ const dimensioned<Form>& dvs \
) \ ) \
{ \ { \
typedef typename product<Type, Form>::type productType; \ typedef typename product<Type, Form>::type resultType; \
\ \
const DimensionedField<Type, GeoMesh>& df1 = tdf1(); \ const auto& f1 = tf1(); \
\ \
auto tres = \ auto tres = \
reuseTmpDimensionedField<productType, Type, GeoMesh>::New \ reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \ ( \
tdf1, \ tf1, \
'(' + df1.name() + #op + dvs.name() + ')', \ '(' + f1.name() + #Op + dvs.name() + ')', \
df1.dimensions() op dvs.dimensions() \ (f1.dimensions() Op dvs.dimensions()) \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), df1.field(), dvs.value()); \ Foam::OpFunc(tres.ref().field(), f1.field(), dvs.value()); \
\ \
tdf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} \ } \
\ \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type, GeoMesh>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \ ) \
{ \ { \
return tdf1 op dimensioned<Form>(static_cast<const Form&>(vs)); \ return tf1 Op dimensioned<Form>(static_cast<const Form&>(vs)); \
} \ } \
\ \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
const DimensionedField<Type, GeoMesh>& df1 \ const DimensionedField<Type, GeoMesh>& f2 \
) \ ) \
{ \ { \
typedef typename product<Form, Type>::type productType; \ typedef typename product<Form, Type>::type resultType; \
\ \
auto tres = \ auto tres = \
tmp<DimensionedField<productType, GeoMesh>>::New \ reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \ ( \
IOobject \ f2, \
( \ '(' + dvs.name() + #Op + f2.name() + ')', \
'(' + dvs.name() + #op + df1.name() + ')', \ (dvs.dimensions() Op f2.dimensions()) \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
dvs.dimensions() op df1.dimensions() \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), dvs.value(), df1.field()); \ Foam::OpFunc(tres.ref().field(), dvs.value(), f2.field()); \
\ \
return tres; \ return tres; \
} \ } \
@ -590,52 +621,52 @@ operator op \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const DimensionedField<Type, GeoMesh>& df1 \ const DimensionedField<Type, GeoMesh>& f2 \
) \ ) \
{ \ { \
return dimensioned<Form>(static_cast<const Form&>(vs)) op df1; \ return dimensioned<Form>(static_cast<const Form&>(vs)) Op f2; \
} \ } \
\ \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \ const tmp<DimensionedField<Type, GeoMesh>>& tf2 \
) \ ) \
{ \ { \
typedef typename product<Form, Type>::type productType; \ typedef typename product<Form, Type>::type resultType; \
\ \
const DimensionedField<Type, GeoMesh>& df1 = tdf1(); \ const auto& f2 = tf2(); \
\ \
auto tres = \ auto tres = \
reuseTmpDimensionedField<productType, Type, GeoMesh>::New \ reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \ ( \
tdf1, \ tf2, \
'(' + dvs.name() + #op + df1.name() + ')', \ '(' + dvs.name() + #Op + f2.name() + ')', \
dvs.dimensions() op df1.dimensions() \ (dvs.dimensions() Op f2.dimensions()) \
); \ ); \
\ \
Foam::opFunc(tres.ref().field(), dvs.value(), df1.field()); \ Foam::OpFunc(tres.ref().field(), dvs.value(), f2.field()); \
\ \
tdf1.clear(); \ tf2.clear(); \
return tres; \ return tres; \
} \ } \
\ \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \ const tmp<DimensionedField<Type, GeoMesh>>& tf2 \
) \ ) \
{ \ { \
return dimensioned<Form>(static_cast<const Form&>(vs)) op tdf1; \ return dimensioned<Form>(static_cast<const Form&>(vs)) Op tf2; \
} }

133
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd. Copyright (C) 2019-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -36,13 +36,13 @@ License
namespace Foam namespace Foam
{ {
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type, class GeoMesh, direction r> template<class Type, class GeoMesh, direction r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>> tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow pow
( (
const DimensionedField<Type, GeoMesh>& df, const DimensionedField<Type, GeoMesh>& f1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
); );
@ -50,33 +50,33 @@ template<class Type, class GeoMesh, direction r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>> tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow pow
( (
const tmp<DimensionedField<Type, GeoMesh>>& tdf, const tmp<DimensionedField<Type, GeoMesh>>& tf1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
); );
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>> tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const DimensionedField<Type, GeoMesh>& df); sqr(const DimensionedField<Type, GeoMesh>& f1);
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>> tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf); sqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
magSqr(const DimensionedField<Type, GeoMesh>& df); magSqr(const DimensionedField<Type, GeoMesh>& f1);
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf); magSqr(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
mag(const DimensionedField<Type, GeoMesh>& df); mag(const DimensionedField<Type, GeoMesh>& f1);
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>> tmp<DimensionedField<typename typeOfMag<Type>::type, GeoMesh>>
mag(const tmp<DimensionedField<Type, GeoMesh>>& tdf); mag(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp tmp
@ -87,7 +87,7 @@ tmp
GeoMesh GeoMesh
> >
> >
cmptAv(const DimensionedField<Type, GeoMesh>& df); cmptAv(const DimensionedField<Type, GeoMesh>& f1);
template<class Type, class GeoMesh> template<class Type, class GeoMesh>
tmp tmp
@ -98,21 +98,21 @@ tmp
GeoMesh GeoMesh
> >
> >
cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tdf); cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tf1);
// Forward to FieldFunction via dfunc() // Forward to FieldFunction via gFunc()
#define UNARY_REDUCTION_FUNCTION(returnType, func, dfunc) \ #define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc) \
\ \
template<class Type, class GeoMesh> \ template<class Type, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const DimensionedField<Type, GeoMesh>& df \ const DimensionedField<Type, GeoMesh>& f1 \
); \ ); \
template<class Type, class GeoMesh> \ template<class Type, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \ const tmp<DimensionedField<Type, GeoMesh>>& tf1 \
); );
UNARY_REDUCTION_FUNCTION(Type, max, gMax) UNARY_REDUCTION_FUNCTION(Type, max, gMax)
@ -137,10 +137,45 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)
// ------------------------------------------------------------------------- //
// Clamp Methods
template<class Type, class GeoMesh>
void clamp
(
DimensionedField<Type, GeoMesh>& result,
const DimensionedField<Type, GeoMesh>& f1,
const Foam::zero_one
);
template<class Type, class GeoMesh>
tmp<DimensionedField<Type, GeoMesh>>
clamp
(
const DimensionedField<Type, GeoMesh>& f1,
const Foam::zero_one
);
template<class Type, class GeoMesh>
tmp<DimensionedField<Type, GeoMesh>>
clamp
(
const tmp<DimensionedField<Type, GeoMesh>>& tf1,
const Foam::zero_one
);
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
// * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
UNARY_OPERATOR(Type, Type, -, negate, transform) UNARY_OPERATOR(Type, Type, -, negate, transform)
@ -156,102 +191,102 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \ #define PRODUCT_OPERATOR(product, Op, OpFunc) \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \ ); \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
template<class Type1, class Type2, class GeoMesh> \ template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \ ); \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type, GeoMesh>& df1, \ const DimensionedField<Type, GeoMesh>& f1, \
const dimensioned<Form>& dvs \ const dimensioned<Form>& dvs \
); \ ); \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const DimensionedField<Type, GeoMesh>& df1, \ const DimensionedField<Type, GeoMesh>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \ ); \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type, GeoMesh>>& tf1, \
const dimensioned<Form>& dvs \ const dimensioned<Form>& dvs \
); \ ); \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type, GeoMesh>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \ ); \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
const DimensionedField<Type, GeoMesh>& df1 \ const DimensionedField<Type, GeoMesh>& f2 \
); \ ); \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const DimensionedField<Type, GeoMesh>& df1 \ const DimensionedField<Type, GeoMesh>& f2 \
); \ ); \
\ \
template<class Form, class Type, class GeoMesh> \ template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \ const tmp<DimensionedField<Type, GeoMesh>>& tf2 \
); \ ); \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \ template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \ tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \ const tmp<DimensionedField<Type, GeoMesh>>& tf2 \
); );
PRODUCT_OPERATOR(typeOfSum, +, add) PRODUCT_OPERATOR(typeOfSum, +, add)

908
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
View File

File diff suppressed because it is too large Load Diff

363
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -30,32 +31,46 @@ License
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \ #define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ void Func \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df \ DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \ const DimensionedField<Type1, GeoMesh>& f1 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1 \
); );
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_OPERATOR(ReturnType, Type1, Op, opFunc, Dfunc) \ #define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1 \ DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \ const DimensionedField<Type1, GeoMesh>& f1 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1 \
); );
@ -64,31 +79,39 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \ #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ void Func \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); );
@ -97,62 +120,78 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ void Func \
( \ ( \
DimensionedField<ReturnType, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const Type1& t1, \ const Type1& s1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& s1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); );
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ void Func \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf2, \ const DimensionedField<Type1, GeoMesh>& f1, \
const Type2& t2 \ const Type2& s2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const Type2& s2 \
); );
@ -166,31 +205,39 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \ #define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); );
@ -199,62 +246,78 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \ #define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
DimensionedField<ReturnType, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const Type1& t1, \ const Type1& s1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \ const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& s1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); );
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \ #define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const DimensionedField<Type1, GeoMesh>& df1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \ ( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \ const DimensionedField<Type1, GeoMesh>& f1, \
const Type2& t2 \ const Type2& s2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const Type2& s2 \
); );
@ -263,4 +326,158 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const DimensionedField<Type3, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const DimensionedField<Type3, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const DimensionedField<Type3, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const DimensionedField<Type3, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const DimensionedField<Type3, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const tmp<DimensionedField<Type3, GeoMesh>>& tf3 \
);
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2, \
const Type3& s3 \
);
// ************************************************************************* // // ************************************************************************* //

149
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2022 OpenCFD Ltd. Copyright (C) 2018-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -35,28 +35,51 @@ namespace Foam
{ {
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// One-parameter versions
template<class TypeR, class Type1, class GeoMesh> template<class TypeR, class Type1, class GeoMesh>
struct reuseTmpDimensionedField struct reuseTmpDimensionedField
{ {
//- Pass-through to New DimensionedField
static tmp<DimensionedField<TypeR, GeoMesh>> New static tmp<DimensionedField<TypeR, GeoMesh>> New
( (
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, const DimensionedField<Type1, GeoMesh>& f1,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const auto& df1 = tdf1(); return tmp<DimensionedField<TypeR, GeoMesh>>::New
(
IOobject
(
name,
f1.instance(),
f1.db()
),
f1.mesh(),
dimensions
);
}
//- Dissimilar types: return new field
static tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
const word& name,
const dimensionSet& dimensions
)
{
const auto& f1 = tf1();
return tmp<DimensionedField<TypeR, GeoMesh>>::New return tmp<DimensionedField<TypeR, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
df1.instance(), f1.instance(),
df1.db() f1.db()
), ),
df1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -70,38 +93,38 @@ struct reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>
//- for identical input and output types //- for identical input and output types
static tmp<DimensionedField<TypeR, GeoMesh>> New static tmp<DimensionedField<TypeR, GeoMesh>> New
( (
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1, const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
const word& name, const word& name,
const dimensionSet& dimensions, const dimensionSet& dimensions,
const bool initCopy = false const bool initCopy = false
) )
{ {
if (tdf1.movable()) if (tf1.movable())
{ {
auto& df1 = tdf1.constCast(); auto& f1 = tf1.constCast();
df1.rename(name); f1.rename(name);
df1.dimensions().reset(dimensions); f1.dimensions().reset(dimensions);
return tdf1; return tf1;
} }
const auto& df1 = tdf1(); const auto& f1 = tf1();
auto tresult = tmp<DimensionedField<TypeR, GeoMesh>>::New auto tresult = tmp<DimensionedField<TypeR, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
df1.instance(), f1.instance(),
df1.db() f1.db()
), ),
df1.mesh(), f1.mesh(),
dimensions dimensions
); );
if (initCopy) if (initCopy)
{ {
tresult.ref().field() = tdf1().field(); tresult.ref().field() = tf1().field();
} }
return tresult; return tresult;
@ -113,7 +136,7 @@ struct reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>
template<class TypeR, class GeoMesh> template<class TypeR, class GeoMesh>
tmp<DimensionedField<TypeR, GeoMesh>> New tmp<DimensionedField<TypeR, GeoMesh>> New
( (
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1, const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
const word& name, const word& name,
const dimensionSet& dimensions, const dimensionSet& dimensions,
const bool initCopy = false const bool initCopy = false
@ -121,7 +144,7 @@ tmp<DimensionedField<TypeR, GeoMesh>> New
{ {
return reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>::New return reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>::New
( (
tdf1, tf1,
name, name,
dimensions, dimensions,
initCopy initCopy
@ -134,23 +157,23 @@ struct reuseTmpTmpDimensionedField
{ {
static tmp<DimensionedField<TypeR, GeoMesh>> New static tmp<DimensionedField<TypeR, GeoMesh>> New
( (
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2, const tmp<DimensionedField<Type2, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const auto& df1 = tdf1(); const auto& f1 = tf1();
return tmp<DimensionedField<TypeR, GeoMesh>>::New return tmp<DimensionedField<TypeR, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
df1.instance(), f1.instance(),
df1.db() f1.db()
), ),
df1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -162,32 +185,32 @@ struct reuseTmpTmpDimensionedField<TypeR, Type1, Type12, TypeR, GeoMesh>
{ {
static tmp<DimensionedField<TypeR, GeoMesh>> New static tmp<DimensionedField<TypeR, GeoMesh>> New
( (
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, const tmp<DimensionedField<Type1, GeoMesh>>& tf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2, const tmp<DimensionedField<TypeR, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
if (tdf2.movable()) if (tf2.movable())
{ {
auto& df2 = tdf2.constCast(); auto& f2 = tf2.constCast();
df2.rename(name); f2.rename(name);
df2.dimensions().reset(dimensions); f2.dimensions().reset(dimensions);
return tdf2; return tf2;
} }
const auto& df1 = tdf1(); const auto& f1 = tf1();
return tmp<DimensionedField<TypeR, GeoMesh>>::New return tmp<DimensionedField<TypeR, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
df1.instance(), f1.instance(),
df1.db() f1.db()
), ),
df1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -199,32 +222,32 @@ struct reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, Type2, GeoMesh>
{ {
static tmp<DimensionedField<TypeR, GeoMesh>> New static tmp<DimensionedField<TypeR, GeoMesh>> New
( (
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1, const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2, const tmp<DimensionedField<Type2, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
if (tdf1.movable()) if (tf1.movable())
{ {
auto& df1 = tdf1.constCast(); auto& f1 = tf1.constCast();
df1.rename(name); f1.rename(name);
df1.dimensions().reset(dimensions); f1.dimensions().reset(dimensions);
return tdf1; return tf1;
} }
const auto& df1 = tdf1(); const auto& f1 = tf1();
return tmp<DimensionedField<TypeR, GeoMesh>>::New return tmp<DimensionedField<TypeR, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
df1.instance(), f1.instance(),
df1.db() f1.db()
), ),
df1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -236,40 +259,40 @@ struct reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, TypeR, GeoMesh>
{ {
static tmp<DimensionedField<TypeR, GeoMesh>> New static tmp<DimensionedField<TypeR, GeoMesh>> New
( (
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1, const tmp<DimensionedField<TypeR, GeoMesh>>& tf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2, const tmp<DimensionedField<TypeR, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
if (tdf1.movable()) if (tf1.movable())
{ {
auto& df1 = tdf1.constCast(); auto& f1 = tf1.constCast();
df1.rename(name); f1.rename(name);
df1.dimensions().reset(dimensions); f1.dimensions().reset(dimensions);
return tdf1; return tf1;
} }
if (tdf2.movable()) if (tf2.movable())
{ {
auto& df2 = tdf2.constCast(); auto& f2 = tf2.constCast();
df2.rename(name); f2.rename(name);
df2.dimensions().reset(dimensions); f2.dimensions().reset(dimensions);
return tdf2; return tf2;
} }
const auto& df1 = tdf1(); const auto& f1 = tf1();
return tmp<DimensionedField<TypeR, GeoMesh>>::New return tmp<DimensionedField<TypeR, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
df1.instance(), f1.instance(),
df1.db() f1.db()
), ),
df1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }

64
src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C
View File

@ -282,39 +282,6 @@ void FieldField<Field, Type>::replace
} }
template<template<class> class Field, class Type>
void FieldField<Field, Type>::clamp
(
const Type& lower,
const Type& upper
)
{
if (lower < upper)
{
for (auto& ff : *this)
{
ff.clamp(lower, upper);
}
}
}
template<template<class> class Field, class Type>
void FieldField<Field, Type>::clamp
(
const MinMax<Type>& range
)
{
if (range.min() < range.max())
{
for (auto& ff : *this)
{
ff.clamp(range.min(), range.max());
}
}
}
template<template<class> class Field, class Type> template<template<class> class Field, class Type>
void FieldField<Field, Type>::clamp_min void FieldField<Field, Type>::clamp_min
( (
@ -341,6 +308,37 @@ void FieldField<Field, Type>::clamp_max
} }
template<template<class> class Field, class Type>
void FieldField<Field, Type>::clamp_range
(
const Type& lower,
const Type& upper
)
{
// Note: no checks for bad/invalid clamping ranges
for (auto& ff : *this)
{
ff.clamp_range(lower, upper);
}
}
template<template<class> class Field, class Type>
void FieldField<Field, Type>::clamp_range
(
const MinMax<Type>& range
)
{
// Note: no checks for bad/invalid clamping ranges
for (auto& ff : *this)
{
ff.clamp_range(range.min(), range.max());
}
}
template<template<class> class Field, class Type> template<template<class> class Field, class Type>
tmp<FieldField<Field, Type>> FieldField<Field, Type>::T() const tmp<FieldField<Field, Type>> FieldField<Field, Type>::T() const
{ {

16
src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
View File

@ -149,20 +149,20 @@ public:
//- Replace a component field of the field //- Replace a component field of the field
void replace(const direction, const cmptType&); void replace(const direction, const cmptType&);
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range.
void clamp(const Type& lower, const Type& upper);
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range.
void clamp(const MinMax<Type>& range);
//- Impose lower (floor) clamp on the field values (in-place) //- Impose lower (floor) clamp on the field values (in-place)
void clamp_min(const Type& lower); void clamp_min(const Type& lower);
//- Impose upper (ceiling) clamp on the field values (in-place) //- Impose upper (ceiling) clamp on the field values (in-place)
void clamp_max(const Type& upper); void clamp_max(const Type& upper);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not.
void clamp_range(const Type& lower, const Type& upper);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not.
void clamp_range(const MinMax<Type>& range);
//- Return the field transpose (only defined for second rank tensors) //- Return the field transpose (only defined for second rank tensors)
tmp<FieldField<Field, Type>> T() const; tmp<FieldField<Field, Type>> T() const;

252
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019-2022 OpenCFD Ltd. Copyright (C) 2019-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -90,12 +90,9 @@ pow
const FieldField<Field, Type>& f, typename powProduct<Type, r>::type const FieldField<Field, Type>& f, typename powProduct<Type, r>::type
) )
{ {
typedef typename powProduct<Type, r>::type powProductType; typedef typename powProduct<Type, r>::type resultType;
auto tres auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
(
FieldField<Field, powProductType>::NewCalculatedType(f)
);
pow<Type, r>(tres.ref(), f); pow<Type, r>(tres.ref(), f);
return tres; return tres;
@ -108,12 +105,9 @@ pow
const tmp<FieldField<Field, Type>>& tf, typename powProduct<Type, r>::type const tmp<FieldField<Field, Type>>& tf, typename powProduct<Type, r>::type
) )
{ {
typedef typename powProduct<Type, r>::type powProductType; typedef typename powProduct<Type, r>::type resultType;
auto tres auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
(
reuseTmpFieldField<Field, powProductType, Type>::New(tf)
);
pow<Type, r>(tres.ref(), tf()); pow<Type, r>(tres.ref(), tf());
tf.clear(); tf.clear();
@ -140,11 +134,10 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>> tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const FieldField<Field, Type>& f) sqr(const FieldField<Field, Type>& f)
{ {
typedef typename outerProduct<Type, Type>::type outerProductType; typedef typename outerProduct<Type, Type>::type resultType;
tmp<FieldField<Field, outerProductType>> tres
( auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
FieldField<Field, outerProductType>::NewCalculatedType(f)
);
sqr(tres.ref(), f); sqr(tres.ref(), f);
return tres; return tres;
} }
@ -153,12 +146,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>> tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const tmp<FieldField<Field, Type>>& tf) sqr(const tmp<FieldField<Field, Type>>& tf)
{ {
typedef typename outerProduct<Type, Type>::type outerProductType; typedef typename outerProduct<Type, Type>::type resultType;
auto tres auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
(
reuseTmpFieldField<Field, outerProductType, Type>::New(tf)
);
sqr(tres.ref(), tf()); sqr(tres.ref(), tf());
tf.clear(); tf.clear();
@ -185,12 +175,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>> tmp<FieldField<Field, typename typeOfMag<Type>::type>>
magSqr(const FieldField<Field, Type>& f) magSqr(const FieldField<Field, Type>& f)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
(
FieldField<Field, magType>::NewCalculatedType(f)
);
magSqr(tres.ref(), f); magSqr(tres.ref(), f);
return tres; return tres;
@ -200,12 +187,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>> tmp<FieldField<Field, typename typeOfMag<Type>::type>>
magSqr(const tmp<FieldField<Field, Type>>& tf) magSqr(const tmp<FieldField<Field, Type>>& tf)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
(
reuseTmpFieldField<Field, magType, Type>::New(tf)
);
magSqr(tres.ref(), tf()); magSqr(tres.ref(), tf());
tf.clear(); tf.clear();
@ -232,12 +216,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>> tmp<FieldField<Field, typename typeOfMag<Type>::type>>
mag(const FieldField<Field, Type>& f) mag(const FieldField<Field, Type>& f)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
(
FieldField<Field, magType>::NewCalculatedType(f)
);
mag(tres.ref(), f); mag(tres.ref(), f);
return tres; return tres;
@ -247,12 +228,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>> tmp<FieldField<Field, typename typeOfMag<Type>::type>>
mag(const tmp<FieldField<Field, Type>>& tf) mag(const tmp<FieldField<Field, Type>>& tf)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
(
reuseTmpFieldField<Field, magType, Type>::New(tf)
);
mag(tres.ref(), tf()); mag(tres.ref(), tf());
tf.clear(); tf.clear();
@ -281,12 +259,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
const FieldField<Field, Type>& f const FieldField<Field, Type>& f
) )
{ {
typedef typename FieldField<Field, Type>::cmptType cmptType; typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
cmptMax(tres.ref(), f); cmptMax(tres.ref(), f);
return tres; return tres;
@ -298,12 +273,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
const tmp<FieldField<Field, Type>>& tf const tmp<FieldField<Field, Type>>& tf
) )
{ {
typedef typename FieldField<Field, Type>::cmptType cmptType; typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
cmptMax(tres.ref(), tf()); cmptMax(tres.ref(), tf());
tf.clear(); tf.clear();
@ -332,12 +304,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
const FieldField<Field, Type>& f const FieldField<Field, Type>& f
) )
{ {
typedef typename FieldField<Field, Type>::cmptType cmptType; typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
cmptMin(tres.ref(), f); cmptMin(tres.ref(), f);
return tres; return tres;
@ -349,12 +318,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
const tmp<FieldField<Field, Type>>& tf const tmp<FieldField<Field, Type>>& tf
) )
{ {
typedef typename FieldField<Field, Type>::cmptType cmptType; typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
cmptMin(tres.ref(), tf()); cmptMin(tres.ref(), tf());
tf.clear(); tf.clear();
@ -383,12 +349,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
const FieldField<Field, Type>& f const FieldField<Field, Type>& f
) )
{ {
typedef typename FieldField<Field, Type>::cmptType cmptType; typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
cmptAv(tres.ref(), f); cmptAv(tres.ref(), f);
return tres; return tres;
@ -400,12 +363,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
const tmp<FieldField<Field, Type>>& tf const tmp<FieldField<Field, Type>>& tf
) )
{ {
typedef typename FieldField<Field, Type>::cmptType cmptType; typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
cmptAv(tres.ref(), tf()); cmptAv(tres.ref(), tf());
tf.clear(); tf.clear();
@ -434,10 +394,7 @@ tmp<FieldField<Field, Type>> cmptMag
const FieldField<Field, Type>& f const FieldField<Field, Type>& f
) )
{ {
auto tres auto tres = FieldField<Field, Type>::NewCalculatedType(f);
(
FieldField<Field, Type>::NewCalculatedType(f)
);
cmptMag(tres.ref(), f); cmptMag(tres.ref(), f);
return tres; return tres;
@ -456,12 +413,12 @@ tmp<FieldField<Field, Type>> cmptMag
} }
#define TMP_UNARY_FUNCTION(returnType, func) \ #define TMP_UNARY_FUNCTION(ReturnType, Func) \
\ \
template<template<class> class Field, class Type> \ template<template<class> class Field, class Type> \
returnType func(const tmp<FieldField<Field, Type>>& tf1) \ ReturnType Func(const tmp<FieldField<Field, Type>>& tf1) \
{ \ { \
returnType res = func(tf1()); \ ReturnType res = Func(tf1()); \
tf1.clear(); \ tf1.clear(); \
return res; \ return res; \
} }
@ -529,9 +486,9 @@ TMP_UNARY_FUNCTION(Type, sum)
template<template<class> class Field, class Type> template<template<class> class Field, class Type>
typename typeOfMag<Type>::type sumMag(const FieldField<Field, Type>& f) typename typeOfMag<Type>::type sumMag(const FieldField<Field, Type>& f)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
magType result = Zero; resultType result = Zero;
const label loopLen = (f).size(); const label loopLen = (f).size();
@ -609,12 +566,12 @@ TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
// With reduction on ReturnType // With reduction on ReturnType
#define G_UNARY_FUNCTION(ReturnType, gFunc, func, rFunc) \ #define G_UNARY_FUNCTION(ReturnType, gFunc, Func, rFunc) \
\ \
template<template<class> class Field, class Type> \ template<template<class> class Field, class Type> \
ReturnType gFunc(const FieldField<Field, Type>& f) \ ReturnType gFunc(const FieldField<Field, Type>& f) \
{ \ { \
ReturnType res = func(f); \ ReturnType res = Func(f); \
reduce(res, rFunc##Op<ReturnType>()); \ reduce(res, rFunc##Op<ReturnType>()); \
return res; \ return res; \
} \ } \
@ -653,7 +610,7 @@ Type gAverage(const FieldField<Field, Type>& f)
} }
WarningInFunction WarningInFunction
<< "empty fieldField, returning zero" << endl; << "Empty FieldField, returning zero" << endl;
return Zero; return Zero;
} }
@ -673,10 +630,17 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
// Note: works with zero_one through implicit conversion to MinMax
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp) BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
/* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */ // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
/* * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * */
UNARY_OPERATOR(Type, Type, -, negate) UNARY_OPERATOR(Type, Type, -, negate)
@ -692,7 +656,7 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \ #define PRODUCT_OPERATOR(product, Op, OpFunc) \
\ \
template \ template \
< \ < \
@ -701,7 +665,7 @@ template \
class Type1, \ class Type1, \
class Type2 \ class Type2 \
> \ > \
void opFunc \ void OpFunc \
( \ ( \
FieldField<Field1, typename product<Type1, Type2>::type>& f, \ FieldField<Field1, typename product<Type1, Type2>::type>& f, \
const FieldField<Field1, Type1>& f1, \ const FieldField<Field1, Type1>& f1, \
@ -712,7 +676,7 @@ void opFunc \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
opFunc(f[i], f1[i], f2[i]); \ OpFunc(f[i], f1[i], f2[i]); \
} \ } \
} \ } \
\ \
@ -724,35 +688,29 @@ template \
class Type2 \ class Type2 \
> \ > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \ tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \ operator Op \
( \ ( \
const FieldField<Field1, Type1>& f1, \ const FieldField<Field1, Type1>& f1, \
const FieldField<Field2, Type2>& f2 \ const FieldField<Field2, Type2>& f2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
tmp<FieldField<Field1, productType>> tres \ auto tres = FieldField<Field1, resultType>::NewCalculatedType(f1); \
( \ OpFunc(tres.ref(), f1, f2); \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), f1, f2); \
return tres; \ return tres; \
} \ } \
\ \
template<template<class> class Field, class Type1, class Type2> \ template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type>> \ tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
operator op \ operator Op \
( \ ( \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
tmp<FieldField<Field, productType>> tres \ auto tres = reuseTmpFieldField<Field, resultType, Type2>::New(tf2); \
( \ OpFunc(tres.ref(), f1, tf2()); \
reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
); \
opFunc(tres.ref(), f1, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
} \ } \
@ -765,18 +723,15 @@ template \
class Type2 \ class Type2 \
> \ > \
tmp<FieldField<Field, typename product<Type1, Type2>::type>> \ tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
operator op \ operator Op \
( \ ( \
const FieldField<Field1, Type1>& f1, \ const FieldField<Field1, Type1>& f1, \
const tmp<FieldField<Field2, Type2>>& tf2 \ const tmp<FieldField<Field2, Type2>>& tf2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
tmp<FieldField<Field1, productType>> tres \ auto tres = FieldField<Field1, resultType>::NewCalculatedType(f1); \
( \ OpFunc(tres.ref(), f1, tf2()); \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), f1, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
} \ } \
@ -789,18 +744,15 @@ template \
class Type2 \ class Type2 \
> \ > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \ tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \ operator Op \
( \ ( \
const tmp<FieldField<Field1, Type1>>& tf1, \ const tmp<FieldField<Field1, Type1>>& tf1, \
const FieldField<Field2, Type2>& f2 \ const FieldField<Field2, Type2>& f2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
tmp<FieldField<Field1, productType>> tres \ auto tres = reuseTmpFieldField<Field1, resultType, Type1>::New(tf1); \
( \ OpFunc(tres.ref(), tf1(), f2); \
reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \
); \
opFunc(tres.ref(), tf1(), f2); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} \ } \
@ -813,19 +765,19 @@ template \
class Type2 \ class Type2 \
> \ > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \ tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \ operator Op \
( \ ( \
const tmp<FieldField<Field1, Type1>>& tf1, \ const tmp<FieldField<Field1, Type1>>& tf1, \
const tmp<FieldField<Field2, Type2>>& tf2 \ const tmp<FieldField<Field2, Type2>>& tf2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
tmp<FieldField<Field1, productType>> tres \ auto tres \
( \ ( \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New \ reuseTmpTmpFieldField<Field1, resultType, Type1, Type1, Type2>::New \
(tf1, tf2) \ (tf1, tf2) \
); \ ); \
opFunc(tres.ref(), tf1(), tf2()); \ OpFunc(tres.ref(), tf1(), tf2()); \
tf1.clear(); \ tf1.clear(); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
@ -839,18 +791,18 @@ template \
class Cmpt, \ class Cmpt, \
direction nCmpt \ direction nCmpt \
> \ > \
void opFunc \ void OpFunc \
( \ ( \
FieldField<Field, typename product<Type, Form>::type>& f, \ FieldField<Field, typename product<Type, Form>::type>& result, \
const FieldField<Field, Type>& f1, \ const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
opFunc(f[i], f1[i], vs); \ OpFunc(result[i], f1[i], vs); \
} \ } \
} \ } \
\ \
@ -863,18 +815,15 @@ template \
direction nCmpt \ direction nCmpt \
> \ > \
tmp<FieldField<Field, typename product<Type, Form>::type>> \ tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \ operator Op \
( \ ( \
const FieldField<Field, Type>& f1, \ const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \ ) \
{ \ { \
typedef typename product<Type, Form>::type productType; \ typedef typename product<Type, Form>::type resultType; \
tmp<FieldField<Field, productType>> tres \ auto tres = FieldField<Field, resultType>::NewCalculatedType(f1); \
( \ OpFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \
return tres; \ return tres; \
} \ } \
\ \
@ -887,18 +836,15 @@ template \
direction nCmpt \ direction nCmpt \
> \ > \
tmp<FieldField<Field, typename product<Type, Form>::type>> \ tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \ operator Op \
( \ ( \
const tmp<FieldField<Field, Type>>& tf1, \ const tmp<FieldField<Field, Type>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \ ) \
{ \ { \
typedef typename product<Type, Form>::type productType; \ typedef typename product<Type, Form>::type resultType; \
tmp<FieldField<Field, productType>> tres \ auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf1); \
( \ OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} \ } \
@ -911,18 +857,18 @@ template \
class Cmpt, \ class Cmpt, \
direction nCmpt \ direction nCmpt \
> \ > \
void opFunc \ void OpFunc \
( \ ( \
FieldField<Field, typename product<Form, Type>::type>& f, \ FieldField<Field, typename product<Form, Type>::type>& result, \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \ const FieldField<Field, Type>& f1 \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
opFunc(f[i], vs, f1[i]); \ OpFunc(result[i], vs, f1[i]); \
} \ } \
} \ } \
\ \
@ -935,18 +881,15 @@ template \
direction nCmpt \ direction nCmpt \
> \ > \
tmp<FieldField<Field, typename product<Form, Type>::type>> \ tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \ const FieldField<Field, Type>& f1 \
) \ ) \
{ \ { \
typedef typename product<Form, Type>::type productType; \ typedef typename product<Form, Type>::type resultType; \
tmp<FieldField<Field, productType>> tres \ auto tres = FieldField<Field, resultType>::NewCalculatedType(f1); \
( \ OpFunc(tres.ref(), static_cast<const Form&>(vs), f1); \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), static_cast<const Form&>(vs), f1); \
return tres; \ return tres; \
} \ } \
\ \
@ -959,18 +902,15 @@ template \
direction nCmpt \ direction nCmpt \
> \ > \
tmp<FieldField<Field, typename product<Form, Type>::type>> \ tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type>>& tf1 \ const tmp<FieldField<Field, Type>>& tf1 \
) \ ) \
{ \ { \
typedef typename product<Form, Type>::type productType; \ typedef typename product<Form, Type>::type resultType; \
tmp<FieldField<Field, productType>> tres \ auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf1); \
( \ OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} }

8
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
View File

@ -287,10 +287,16 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
// Note: works with zero_one through implicit conversion to MinMax
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp) BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
/* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */ TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
/* * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * */
UNARY_OPERATOR(Type, Type, -, negate) UNARY_OPERATOR(Type, Type, -, negate)

442
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2022 OpenCFD Ltd. Copyright (C) 2022-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -31,92 +31,86 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_FUNCTION(ReturnType, Type, Func) \ #define UNARY_FUNCTION(ReturnType, Type1, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& res, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type>& f \ const FieldField<Field, Type1>& f1 \
) \ ) \
{ \ { \
const label loopLen = (res).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
Func(res[i], f[i]); \ Func(result[i], f1[i]); \
} \ } \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const FieldField<Field, Type>& f \ const FieldField<Field, Type1>& f1 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
( \ Func(tres.ref(), f1); \
FieldField<Field, ReturnType>::NewCalculatedType(f) \
); \
Func(tres.ref(), f); \
return tres; \ return tres; \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const tmp<FieldField<Field, Type>>& tf \ const tmp<FieldField<Field, Type1>>& tf1 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres(New(tf)); \ auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
Func(tres.ref(), tf()); \ Func(tres.ref(), tf1()); \
tf.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_OPERATOR(ReturnType, Type, Op, OpFunc) \ #define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& res, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type>& f \ const FieldField<Field, Type1>& f1 \
) \ ) \
{ \ { \
const label loopLen = (res).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
OpFunc(res[i], f[i]); \ OpFunc(result[i], f1[i]); \
} \ } \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const FieldField<Field, Type>& f \ const FieldField<Field, Type1>& f1 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
( \ OpFunc(tres.ref(), f1); \
FieldField<Field, Type>::NewCalculatedType(f) \
); \
OpFunc(tres.ref(), f); \
return tres; \ return tres; \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const tmp<FieldField<Field, Type>>& tf \ const tmp<FieldField<Field, Type1>>& tf1 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres(New(tf)); \ auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
OpFunc(tres.ref(), tf()); \ OpFunc(tres.ref(), tf1()); \
tf.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} }
@ -128,16 +122,16 @@ tmp<FieldField<Field, ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
Func(f[i], f1[i], f2[i]); \ Func(result[i], f1[i], f2[i]); \
} \ } \
} \ } \
\ \
@ -148,10 +142,7 @@ tmp<FieldField<Field, ReturnType>> Func \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
( \
FieldField<Field, Type1>::NewCalculatedType(f1) \
); \
Func(tres.ref(), f1, f2); \ Func(tres.ref(), f1, f2); \
return tres; \ return tres; \
} \ } \
@ -163,10 +154,7 @@ tmp<FieldField<Field, ReturnType>> Func \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2); \
( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
Func(tres.ref(), f1, tf2()); \ Func(tres.ref(), f1, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
@ -179,10 +167,7 @@ tmp<FieldField<Field, ReturnType>> Func \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \
Func(tres.ref(), tf1(), f2); \ Func(tres.ref(), tf1(), f2); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
@ -195,7 +180,7 @@ tmp<FieldField<Field, ReturnType>> Func \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres \
( \ ( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \ New(tf1, tf2) \
@ -214,46 +199,40 @@ tmp<FieldField<Field, ReturnType>> Func \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const Type1& s, \ const Type1& s1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
Func(f[i], s, f2[i]); \ Func(result[i], s1, f2[i]); \
} \ } \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const Type1& s, \ const Type1& s1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f2); \
( \ Func(tres.ref(), s1, f2); \
FieldField<Field, Type2>::NewCalculatedType(f2) \
); \
Func(tres.ref(), s, f2); \
return tres; \ return tres; \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const Type1& s, \ const Type1& s1, \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2); \
( \ Func(tres.ref(), s1, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
Func(tres.ref(), s, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
} }
@ -264,16 +243,16 @@ tmp<FieldField<Field, ReturnType>> Func \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const Type2& s \ const Type2& s2 \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
Func(f[i], f1[i], s); \ Func(result[i], f1[i], s2); \
} \ } \
} \ } \
\ \
@ -281,14 +260,11 @@ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const Type2& s \ const Type2& s2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
( \ Func(tres.ref(), f1, s2); \
FieldField<Field, Type1>::NewCalculatedType(f1) \
); \
Func(tres.ref(), f1, s); \
return tres; \ return tres; \
} \ } \
\ \
@ -296,14 +272,11 @@ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const tmp<FieldField<Field, Type1>>& tf1, \ const tmp<FieldField<Field, Type1>>& tf1, \
const Type2& s \ const Type2& s2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
( \ Func(tres.ref(), tf1(), s2); \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \
Func(tres.ref(), tf1(), s); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} }
@ -321,16 +294,16 @@ tmp<FieldField<Field, ReturnType>> Func \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
OpFunc(f[i], f1[i], f2[i]); \ OpFunc(result[i], f1[i], f2[i]); \
} \ } \
} \ } \
\ \
@ -341,10 +314,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
( \
FieldField<Field, ReturnType>::NewCalculatedType(f1) \
); \
OpFunc(tres.ref(), f1, f2); \ OpFunc(tres.ref(), f1, f2); \
return tres; \ return tres; \
} \ } \
@ -356,10 +326,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2); \
( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
OpFunc(tres.ref(), f1, tf2()); \ OpFunc(tres.ref(), f1, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
@ -372,10 +339,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \
OpFunc(tres.ref(), tf1(), f2); \ OpFunc(tres.ref(), tf1(), f2); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
@ -388,7 +352,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres \
( \ ( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \ New(tf1, tf2) \
@ -407,46 +371,40 @@ tmp<FieldField<Field, ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const Type1& s, \ const Type1& s1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
OpFunc(f[i], s, f2[i]); \ OpFunc(result[i], s1, f2[i]); \
} \ } \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const Type1& s, \ const Type1& s1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f2); \
( \ OpFunc(tres.ref(), s1, f2); \
FieldField<Field, Type2>::NewCalculatedType(f2) \
); \
OpFunc(tres.ref(), s, f2); \
return tres; \ return tres; \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const Type1& s, \ const Type1& s1, \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2); \
( \ OpFunc(tres.ref(), s1, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
OpFunc(tres.ref(), s, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
} }
@ -457,16 +415,16 @@ tmp<FieldField<Field, ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const Type2& s \ const Type2& s2 \
) \ ) \
{ \ { \
const label loopLen = (f).size(); \ const label loopLen = (result).size(); \
\ \
for (label i = 0; i < loopLen; ++i) \ for (label i = 0; i < loopLen; ++i) \
{ \ { \
OpFunc(f[i], f1[i], s); \ OpFunc(result[i], f1[i], s2); \
} \ } \
} \ } \
\ \
@ -474,14 +432,11 @@ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const Type2& s \ const Type2& s2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
( \ OpFunc(tres.ref(), f1, s2); \
FieldField<Field, Type1>::NewCalculatedType(f1) \
); \
OpFunc(tres.ref(), f1, s); \
return tres; \ return tres; \
} \ } \
\ \
@ -489,14 +444,11 @@ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const tmp<FieldField<Field, Type1>>& tf1, \ const tmp<FieldField<Field, Type1>>& tf1, \
const Type2& s \ const Type2& s2 \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tres \ auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
( \ OpFunc(tres.ref(), tf1(), s2); \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \
OpFunc(tres.ref(), tf1(), s); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
} }
@ -506,4 +458,240 @@ tmp<FieldField<Field, ReturnType>> operator Op \
BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \ BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpFunc) \
BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc) BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const FieldField<Field, Type3>& f3 \
) \
{ \
const label loopLen = (result).size(); \
\
for (label i = 0; i < loopLen; ++i) \
{ \
Func(result[i], f1[i], f2[i], f3[i]); \
} \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const FieldField<Field, Type3>& f3 \
) \
{ \
auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
Func(tres.ref(), f1, f2, f3); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2, \
const FieldField<Field, Type3>& f3 \
) \
{ \
auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
Func(tres.ref(), tf1(), f2, f3); \
tf1.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const FieldField<Field, Type3>& f3 \
) \
{ \
auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2); \
Func(tres.ref(), f1, tf2(), f3); \
tf2.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const tmp<FieldField<Field, Type3>>& tf3 \
) \
{ \
auto tres = reuseTmpFieldField<Field, ReturnType, Type3>::New(tf3); \
Func(tres.ref(), f1, f2, tf3()); \
tf3.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const FieldField<Field, Type3>& f3 \
) \
{ \
tmp<FieldField<Field, ReturnType>> tres \
( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \
); \
Func(tres.ref(), tf1(), tf2(), f3); \
tf1.clear(); \
tf2.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2, \
const tmp<FieldField<Field, Type3>>& tf3 \
) \
{ \
tmp<FieldField<Field, ReturnType>> tres \
( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type3>:: \
New(tf1, tf3) \
); \
Func(tres.ref(), tf1(), f2, tf3()); \
tf1.clear(); \
tf3.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const tmp<FieldField<Field, Type3>>& tf3 \
) \
{ \
tmp<FieldField<Field, ReturnType>> tres \
( \
reuseTmpTmpFieldField<Field, ReturnType, Type2, Type2, Type3>:: \
New(tf2, tf3) \
); \
Func(tres.ref(), f1, tf2(), tf3()); \
tf2.clear(); \
tf3.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const tmp<FieldField<Field, Type3>>& tf3 \
) \
{ \
/* TBD: check all three types? */ \
tmp<FieldField<Field, ReturnType>> tres \
( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \
); \
Func(tres.ref(), tf1(), tf2(), tf3()); \
tf1.clear(); \
tf2.clear(); \
tf3.clear(); \
return tres; \
}
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const Type3& s3 \
) \
{ \
const label loopLen = (result).size(); \
\
for (label i = 0; i < loopLen; ++i) \
{ \
Func(result[i], f1[i], f2[i], s3); \
} \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const Type3& s3 \
) \
{ \
auto tres = FieldField<Field, ReturnType>::NewCalculatedType(f1); \
Func(tres.ref(), f1, f2, s3); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2, \
const Type3& s3 \
) \
{ \
auto tres = reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1); \
Func(tres.ref(), tf1(), f2, s3); \
tf1.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const Type3& s3 \
) \
{ \
auto tres = reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2); \
Func(tres.ref(), f1, tf2(), s3); \
tf2.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const Type3& s3 \
) \
{ \
tmp<FieldField<Field, ReturnType>> tres \
( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \
); \
Func(tres.ref(), tf1(), tf2(), s3); \
tf1.clear(); \
tf2.clear(); \
return tres; \
}
// ************************************************************************* // // ************************************************************************* //

183
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -24,9 +25,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description Description
High performance macro functions for Field\<Type\> algebra. Macro functions for FieldField\<Type\> algebra.
These expand using either array element access (for vector machines)
or pointer dereferencing for scalar machines as appropriate.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -37,20 +36,20 @@ Description
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& res, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f \ const FieldField<Field, Type1>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const FieldField<Field, Type1>& f \ const FieldField<Field, Type1>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const tmp<FieldField<Field, Type1>>& tf \ const tmp<FieldField<Field, Type1>>& tf1 \
); );
@ -61,20 +60,20 @@ tmp<FieldField<Field, ReturnType>> Func \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& res, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f \ const FieldField<Field, Type1>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const FieldField<Field, Type1>& f \ const FieldField<Field, Type1>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> operator Op \ tmp<FieldField<Field, ReturnType>> operator Op \
( \ ( \
const tmp<FieldField<Field, Type1>>& tf \ const tmp<FieldField<Field, Type1>>& tf1 \
); );
@ -83,36 +82,36 @@ tmp<FieldField<Field, ReturnType>> operator Op \
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \ #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const tmp<FieldField<Field, Type1>>& tf1, \ const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const tmp<FieldField<Field, Type1>>& tf1, \ const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2 \ const tmp<FieldField<Field, Type2>>& tf2 \
@ -124,22 +123,22 @@ tmp<FieldField<Field, ReturnType>> func \
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const Type1& s1, \ const Type1& s1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const Type1& s1, \ const Type1& s1, \
const FieldField<Field, Type1>& f2 \ const FieldField<Field, Type1>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const Type1& s1, \ const Type1& s1, \
const tmp<FieldField<Field, Type1>>& tf2 \ const tmp<FieldField<Field, Type1>>& tf2 \
@ -149,25 +148,25 @@ tmp<FieldField<Field, ReturnType>> func \
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void func \ void Func \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const Type2& s \ const Type2& s2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const Type2& s \ const Type2& s2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<FieldField<Field, ReturnType>> func \ tmp<FieldField<Field, ReturnType>> Func \
( \ ( \
const tmp<FieldField<Field, Type1>>& tf1, \ const tmp<FieldField<Field, Type1>>& tf1, \
const Type2& s \ const Type2& s2 \
); );
@ -183,7 +182,7 @@ tmp<FieldField<Field, ReturnType>> func \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
); \ ); \
@ -224,7 +223,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const Type1& s1, \ const Type1& s1, \
const FieldField<Field, Type2>& f2 \ const FieldField<Field, Type2>& f2 \
); \ ); \
@ -249,7 +248,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
FieldField<Field, ReturnType>& f, \ FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \ const FieldField<Field, Type1>& f1, \
const Type2& s2 \ const Type2& s2 \
); \ ); \
@ -274,4 +273,126 @@ tmp<FieldField<Field, ReturnType>> operator Op \
BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc) BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const FieldField<Field, Type3>& f3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const FieldField<Field, Type3>& f3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2, \
const FieldField<Field, Type3>& f3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const FieldField<Field, Type3>& f3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const tmp<FieldField<Field, Type3>>& tf3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const FieldField<Field, Type3>& f3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2, \
const tmp<FieldField<Field, Type3>>& tf3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const tmp<FieldField<Field, Type3>>& tf3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const tmp<FieldField<Field, Type3>>& tf3 \
);
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
FieldField<Field, ReturnType>& result, \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2, \
const Type3& s3 \
);
// ************************************************************************* // // ************************************************************************* //

30
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2022 OpenCFD Ltd. Copyright (C) 2018-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -35,10 +35,21 @@ namespace Foam
{ {
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// One-parameter versions
template<template<class> class Field, class TypeR, class Type1> template<template<class> class Field, class TypeR, class Type1>
struct reuseTmpFieldField struct reuseTmpFieldField
{ {
//- Pass-through to NewCalculatedType
static tmp<FieldField<Field, TypeR>> New
(
const FieldField<Field, Type1>& f1
)
{
return FieldField<Field, TypeR>::NewCalculatedType(f1);
}
//- Dissimilar types: just use size
static tmp<FieldField<Field, TypeR>> New static tmp<FieldField<Field, TypeR>> New
( (
const tmp<FieldField<Field, Type1>>& tf1 const tmp<FieldField<Field, Type1>>& tf1
@ -52,6 +63,8 @@ struct reuseTmpFieldField
template<template<class> class Field, class TypeR> template<template<class> class Field, class TypeR>
struct reuseTmpFieldField<Field, TypeR, TypeR> struct reuseTmpFieldField<Field, TypeR, TypeR>
{ {
//- Identical input and return types:
//- allow optional copy assignment of the initial content
static tmp<FieldField<Field, TypeR>> New static tmp<FieldField<Field, TypeR>> New
( (
const tmp<FieldField<Field, TypeR>>& tf1, const tmp<FieldField<Field, TypeR>>& tf1,
@ -63,19 +76,19 @@ struct reuseTmpFieldField<Field, TypeR, TypeR>
return tf1; return tf1;
} }
auto rtf = FieldField<Field, TypeR>::NewCalculatedType(tf1()); auto tresult = FieldField<Field, TypeR>::NewCalculatedType(tf1());
if (initCopy) if (initCopy)
{ {
rtf.ref() = tf1(); tresult.ref() = tf1();
} }
return rtf; return tresult;
} }
}; };
//- Global function forwards to reuseTmpFieldField::New //- This global function forwards to reuseTmpFieldField::New
template<template<class> class Field, class TypeR> template<template<class> class Field, class TypeR>
tmp<FieldField<Field, TypeR>> New tmp<FieldField<Field, TypeR>> New
( (
@ -87,6 +100,9 @@ tmp<FieldField<Field, TypeR>> New
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Two-parameter versions
template template
< <
template<class> class Field, template<class> class Field,
@ -97,6 +113,7 @@ template
> >
struct reuseTmpTmpFieldField struct reuseTmpTmpFieldField
{ {
//- Dissimilar types: just use size
static tmp<FieldField<Field, TypeR>> New static tmp<FieldField<Field, TypeR>> New
( (
const tmp<FieldField<Field, Type1>>& tf1, const tmp<FieldField<Field, Type1>>& tf1,
@ -111,6 +128,7 @@ struct reuseTmpTmpFieldField
template<template<class> class Field, class TypeR, class Type1, class Type12> template<template<class> class Field, class TypeR, class Type1, class Type12>
struct reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR> struct reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR>
{ {
//- Second input has return type
static tmp<FieldField<Field, TypeR>> New static tmp<FieldField<Field, TypeR>> New
( (
const tmp<FieldField<Field, Type1>>& tf1, const tmp<FieldField<Field, Type1>>& tf1,
@ -130,6 +148,7 @@ struct reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR>
template<template<class> class Field, class TypeR, class Type2> template<template<class> class Field, class TypeR, class Type2>
struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2> struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
{ {
//- First input has return type
static tmp<FieldField<Field, TypeR>> New static tmp<FieldField<Field, TypeR>> New
( (
const tmp<FieldField<Field, TypeR>>& tf1, const tmp<FieldField<Field, TypeR>>& tf1,
@ -149,6 +168,7 @@ struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
template<template<class> class Field, class TypeR> template<template<class> class Field, class TypeR>
struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, TypeR> struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, TypeR>
{ {
//- Both inputs have return type
static tmp<FieldField<Field, TypeR>> New static tmp<FieldField<Field, TypeR>> New
( (
const tmp<FieldField<Field, TypeR>>& tf1, const tmp<FieldField<Field, TypeR>>& tf1,

41
src/OpenFOAM/fields/Fields/Field/Field.C
View File

@ -658,27 +658,6 @@ void Foam::Field<Type>::replace
} }
template<class Type>
void Foam::Field<Type>::clamp(const Type& lower, const Type& upper)
{
// Use free functions min(), max() to impose component-wise clamping
if (lower < upper)
{
// std::for_each
for (auto& val : *this)
{
val = min(max(val, lower), upper);
}
}
}
template<class Type>
void Foam::Field<Type>::clamp(const MinMax<Type>& range)
{
clamp(range.min(), range.max());
}
template<class Type> template<class Type>
void Foam::Field<Type>::clamp_min(const Type& lower) void Foam::Field<Type>::clamp_min(const Type& lower)
{ {
@ -702,6 +681,26 @@ void Foam::Field<Type>::clamp_max(const Type& upper)
} }
template<class Type>
void Foam::Field<Type>::clamp_range(const Type& lower, const Type& upper)
{
// Note: no checks for bad/invalid clamping ranges
// Use free functions min(), max() to impose component-wise clamping
// std::for_each
for (auto& val : *this)
{
val = min(max(val, lower), upper);
}
}
template<class Type>
void Foam::Field<Type>::clamp_range(const MinMax<Type>& range)
{
Field<Type>::clamp_range(range.min(), range.max());
}
template<class Type> template<class Type>
template<class VSForm> template<class VSForm>
VSForm Foam::Field<Type>::block(const label start) const VSForm Foam::Field<Type>::block(const label start) const

16
src/OpenFOAM/fields/Fields/Field/Field.H
View File

@ -434,20 +434,20 @@ public:
//- Replace a component field of the field //- Replace a component field of the field
void replace(const direction, const cmptType&); void replace(const direction, const cmptType&);
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range.
void clamp(const Type& lower, const Type& upper);
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range.
void clamp(const MinMax<Type>& range);
//- Impose lower (floor) clamp on the field values (in-place) //- Impose lower (floor) clamp on the field values (in-place)
void clamp_min(const Type& lower); void clamp_min(const Type& lower);
//- Impose upper (ceiling) clamp on the field values (in-place) //- Impose upper (ceiling) clamp on the field values (in-place)
void clamp_max(const Type& upper); void clamp_max(const Type& upper);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not.
void clamp_range(const Type& lower, const Type& upper);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not.
void clamp_range(const MinMax<Type>& range);
template<class VSForm> template<class VSForm>
VSForm block(const label start) const; VSForm block(const label start) const;

503
src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
View File

@ -42,38 +42,40 @@ namespace Foam
template<class Type> template<class Type>
void component void component
( (
Field<typename Field<Type>::cmptType>& res, Field<typename Field<Type>::cmptType>& result,
const UList<Type>& f, const UList<Type>& f1,
const direction d const direction d
) )
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
TFOR_ALL_F_OP_F_FUNC_S TFOR_ALL_F_OP_F_FUNC_S
( (
cmptType, res, =, Type, f, .component, const direction, d resultType, result, =, Type, f1, .component, const direction, d
) )
} }
template<class Type> template<class Type>
void T(Field<Type>& res, const UList<Type>& f) void T(Field<Type>& result, const UList<Type>& f1)
{ {
TFOR_ALL_F_OP_F_FUNC(Type, res, =, Type, f, T) TFOR_ALL_F_OP_F_FUNC(Type, result, =, Type, f1, T)
} }
template<class Type, direction r> template<class Type, direction r>
void pow void pow
( (
Field<typename powProduct<Type, r>::type>& res, Field<typename powProduct<Type, r>::type>& result,
const UList<Type>& vf const UList<Type>& f1
) )
{ {
typedef typename powProduct<Type, r>::type powProductType; typedef typename powProduct<Type, r>::type resultType;
TFOR_ALL_F_OP_FUNC_F_S TFOR_ALL_F_OP_FUNC_F_S
( (
powProductType, res, =, pow, Type, vf, powProductType, resultType, result, =, pow, Type, f1, resultType,
pTraits<powProductType>::zero pTraits<resultType>::zero
) )
} }
@ -81,16 +83,13 @@ template<class Type, direction r>
tmp<Field<typename powProduct<Type, r>::type>> tmp<Field<typename powProduct<Type, r>::type>>
pow pow
( (
const UList<Type>& f, const UList<Type>& f1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
) )
{ {
typedef typename powProduct<Type, r>::type powProductType; typedef typename powProduct<Type, r>::type resultType;
auto tres auto tres = tmp<Field<resultType>>::New(f1.size());
( pow<Type, r>(tres.ref(), f1);
tmp<Field<powProductType>>::New(f.size())
);
pow<Type, r>(tres.ref(), f);
return tres; return tres;
} }
@ -98,14 +97,14 @@ template<class Type, direction r>
tmp<Field<typename powProduct<Type, r>::type>> tmp<Field<typename powProduct<Type, r>::type>>
pow pow
( (
const tmp<Field<Type>>& tf, const tmp<Field<Type>>& tf1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
) )
{ {
typedef typename powProduct<Type, r>::type powProductType; typedef typename powProduct<Type, r>::type resultType;
auto tres = reuseTmp<powProductType, Type>::New(tf); auto tres = reuseTmp<resultType, Type>::New(tf1);
pow<Type, r>(tres.ref(), tf()); pow<Type, r>(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
@ -113,35 +112,33 @@ pow
template<class Type> template<class Type>
void sqr void sqr
( (
Field<typename outerProduct<Type, Type>::type>& res, Field<typename outerProduct<Type, Type>::type>& result,
const UList<Type>& vf const UList<Type>& f1
) )
{ {
typedef typename outerProduct<Type, Type>::type outerProductType; typedef typename outerProduct<Type, Type>::type resultType;
TFOR_ALL_F_OP_FUNC_F(outerProductType, res, =, sqr, Type, vf)
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, sqr, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<typename outerProduct<Type, Type>::type>> tmp<Field<typename outerProduct<Type, Type>::type>>
sqr(const UList<Type>& f) sqr(const UList<Type>& f1)
{ {
typedef typename outerProduct<Type, Type>::type outerProductType; typedef typename outerProduct<Type, Type>::type resultType;
auto tres auto tres = tmp<Field<resultType>>::New(f1.size());
( sqr(tres.ref(), f1);
tmp<Field<outerProductType>>::New(f.size())
);
sqr(tres.ref(), f);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<typename outerProduct<Type, Type>::type>> tmp<Field<typename outerProduct<Type, Type>::type>>
sqr(const tmp<Field<Type>>& tf) sqr(const tmp<Field<Type>>& tf1)
{ {
typedef typename outerProduct<Type, Type>::type outerProductType; typedef typename outerProduct<Type, Type>::type resultType;
auto tres = reuseTmp<outerProductType, Type>::New(tf); auto tres = reuseTmp<resultType, Type>::New(tf1);
sqr(tres.ref(), tf()); sqr(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
@ -149,35 +146,35 @@ sqr(const tmp<Field<Type>>& tf)
template<class Type> template<class Type>
void magSqr void magSqr
( (
Field<typename typeOfMag<Type>::type>& res, Field<typename typeOfMag<Type>::type>& result,
const UList<Type>& f const UList<Type>& f1
) )
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
TFOR_ALL_F_OP_FUNC_F(magType, res, =, magSqr, Type, f) TFOR_ALL_F_OP_FUNC_F(resultType, result, =, magSqr, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<typename typeOfMag<Type>::type>> tmp<Field<typename typeOfMag<Type>::type>>
magSqr(const UList<Type>& f) magSqr(const UList<Type>& f1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres = tmp<Field<magType>>::New(f.size()); auto tres = tmp<Field<resultType>>::New(f1.size());
magSqr(tres.ref(), f); magSqr(tres.ref(), f1);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<typename typeOfMag<Type>::type>> tmp<Field<typename typeOfMag<Type>::type>>
magSqr(const tmp<Field<Type>>& tf) magSqr(const tmp<Field<Type>>& tf1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres = reuseTmp<magType, Type>::New(tf); auto tres = reuseTmp<resultType, Type>::New(tf1);
magSqr(tres.ref(), tf()); magSqr(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
@ -185,164 +182,179 @@ magSqr(const tmp<Field<Type>>& tf)
template<class Type> template<class Type>
void mag void mag
( (
Field<typename typeOfMag<Type>::type>& res, Field<typename typeOfMag<Type>::type>& result,
const UList<Type>& f const UList<Type>& f1
) )
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
TFOR_ALL_F_OP_FUNC_F(magType, res, =, mag, Type, f) TFOR_ALL_F_OP_FUNC_F(resultType, result, =, mag, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<typename typeOfMag<Type>::type>> tmp<Field<typename typeOfMag<Type>::type>>
mag(const UList<Type>& f) mag(const UList<Type>& f1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres = tmp<Field<magType>>::New(f.size()); auto tres = tmp<Field<resultType>>::New(f1.size());
mag(tres.ref(), f); mag(tres.ref(), f1);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<typename typeOfMag<Type>::type>> tmp<Field<typename typeOfMag<Type>::type>>
mag(const tmp<Field<Type>>& tf) mag(const tmp<Field<Type>>& tf1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
auto tres = reuseTmp<magType, Type>::New(tf); auto tres = reuseTmp<resultType, Type>::New(tf1);
mag(tres.ref(), tf()); mag(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type> template<class Type>
void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f) void cmptMax
(
Field<typename Field<Type>::cmptType>& result,
const UList<Type>& f1
)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMax, Type, f)
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMax, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f) tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f1)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
auto tres = tmp<Field<cmptType>>::New(f.size()); auto tres = tmp<Field<resultType>>::New(f1.size());
cmptMax(tres.ref(), f); cmptMax(tres.ref(), f1);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf) tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf1)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
auto tres = reuseTmp<cmptType, Type>::New(tf); auto tres = reuseTmp<resultType, Type>::New(tf1);
cmptMax(tres.ref(), tf()); cmptMax(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type> template<class Type>
void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f) void cmptMin
(
Field<typename Field<Type>::cmptType>& result,
const UList<Type>& f1
)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMin, Type, f)
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMin, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f) tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f1)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
auto tres = tmp<Field<cmptType>>::New(f.size()); auto tres = tmp<Field<resultType>>::New(f1.size());
cmptMin(tres.ref(), f); cmptMin(tres.ref(), f1);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf) tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf1)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
auto tres = reuseTmp<cmptType, Type>::New(tf); auto tres = reuseTmp<resultType, Type>::New(tf1);
cmptMin(tres.ref(), tf()); cmptMin(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type> template<class Type>
void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f) void cmptAv
(
Field<typename Field<Type>::cmptType>& result,
const UList<Type>& f1
)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptAv, Type, f)
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptAv, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f) tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f1)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
auto tres = tmp<Field<cmptType>>::New(f.size()); auto tres = tmp<Field<resultType>>::New(f1.size());
cmptAv(tres.ref(), f); cmptAv(tres.ref(), f1);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf) tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf1)
{ {
typedef typename Field<Type>::cmptType cmptType; typedef typename Field<Type>::cmptType resultType;
auto tres = reuseTmp<cmptType, Type>::New(tf); auto tres = reuseTmp<resultType, Type>::New(tf1);
cmptAv(tres.ref(), tf()); cmptAv(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type> template<class Type>
void cmptMag(Field<Type>& res, const UList<Type>& f) void cmptMag(Field<Type>& result, const UList<Type>& f1)
{ {
TFOR_ALL_F_OP_FUNC_F(Type, res, =, cmptMag, Type, f) TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMag, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<Type>> cmptMag(const UList<Type>& f) tmp<Field<Type>> cmptMag(const UList<Type>& f1)
{ {
auto tres = tmp<Field<Type>>::New(f.size()); auto tres = tmp<Field<Type>>::New(f1.size());
cmptMag(tres.ref(), f); cmptMag(tres.ref(), f1);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf) tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf1)
{ {
auto tres = New(tf); auto tres = New(tf1);
cmptMag(tres.ref(), tf()); cmptMag(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
template<class Type> template<class Type>
void cmptMagSqr(Field<Type>& res, const UList<Type>& f) void cmptMagSqr(Field<Type>& result, const UList<Type>& f1)
{ {
TFOR_ALL_F_OP_FUNC_F(Type, res, =, cmptMagSqr, Type, f) TFOR_ALL_F_OP_FUNC_F(Type, result, =, cmptMagSqr, Type, f1)
} }
template<class Type> template<class Type>
tmp<Field<Type>> cmptMagSqr(const UList<Type>& f) tmp<Field<Type>> cmptMagSqr(const UList<Type>& f1)
{ {
auto tres = tmp<Field<Type>>::New(f.size()); auto tres = tmp<Field<Type>>::New(f1.size());
cmptMagSqr(tres.ref(), f); cmptMagSqr(tres.ref(), f1);
return tres; return tres;
} }
template<class Type> template<class Type>
tmp<Field<Type>> cmptMagSqr(const tmp<Field<Type>>& tf) tmp<Field<Type>> cmptMagSqr(const tmp<Field<Type>>& tf1)
{ {
auto tres = New(tf); auto tres = New(tf1);
cmptMagSqr(tres.ref(), tf()); cmptMagSqr(tres.ref(), tf1());
tf.clear(); tf1.clear();
return tres; return tres;
} }
@ -358,13 +370,13 @@ ReturnType Func(const tmp<Field<Type>>& tf1) \
} }
template<class Type> template<class Type>
Type max(const UList<Type>& f) Type max(const UList<Type>& f1)
{ {
if (f.size()) if (f1.size())
{ {
Type Max(f[0]); Type result(f1[0]);
TFOR_ALL_S_OP_FUNC_F_S(Type, Max, =, max, Type, f, Type, Max) TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, max, Type, f1, Type, result)
return Max; return result;
} }
return pTraits<Type>::min; return pTraits<Type>::min;
@ -373,13 +385,13 @@ Type max(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, max) TMP_UNARY_FUNCTION(Type, max)
template<class Type> template<class Type>
Type min(const UList<Type>& f) Type min(const UList<Type>& f1)
{ {
if (f.size()) if (f1.size())
{ {
Type Min(f[0]); Type result(f1[0]);
TFOR_ALL_S_OP_FUNC_F_S(Type, Min, =, min, Type, f, Type, Min) TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, min, Type, f1, Type, result)
return Min; return result;
} }
return pTraits<Type>::max; return pTraits<Type>::max;
@ -388,18 +400,19 @@ Type min(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, min) TMP_UNARY_FUNCTION(Type, min)
template<class Type> template<class Type>
Type sum(const UList<Type>& f) Type sum(const UList<Type>& f1)
{ {
typedef typename Foam::typeOfSolve<Type>::type solveType; typedef typename Foam::typeOfSolve<Type>::type resultType;
solveType Sum = Zero; resultType result = Zero;
if (f.size()) if (f1.size())
{ {
TFOR_ALL_S_OP_FUNC_F(solveType, Sum, +=, solveType, Type, f) // Use resultType() as functional cast
TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, resultType, Type, f1)
} }
return Type(Sum); return Type(result);
} }
TMP_UNARY_FUNCTION(Type, sum) TMP_UNARY_FUNCTION(Type, sum)
@ -414,23 +427,23 @@ TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
template<class Type> template<class Type>
Type maxMagSqr(const UList<Type>& f) Type maxMagSqr(const UList<Type>& f1)
{ {
if (f.size()) if (f1.size())
{ {
Type Max(f[0]); Type result(f1[0]);
TFOR_ALL_S_OP_FUNC_F_S TFOR_ALL_S_OP_FUNC_F_S
( (
Type, Type,
Max, result,
=, =,
maxMagSqrOp<Type>(), maxMagSqrOp<Type>(),
Type, Type,
f, f1,
Type, Type,
Max result
) )
return Max; return result;
} }
return Zero; return Zero;
@ -439,23 +452,23 @@ Type maxMagSqr(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, maxMagSqr) TMP_UNARY_FUNCTION(Type, maxMagSqr)
template<class Type> template<class Type>
Type minMagSqr(const UList<Type>& f) Type minMagSqr(const UList<Type>& f1)
{ {
if (f.size()) if (f1.size())
{ {
Type Min(f[0]); Type result(f1[0]);
TFOR_ALL_S_OP_FUNC_F_S TFOR_ALL_S_OP_FUNC_F_S
( (
Type, Type,
Min, result,
=, =,
minMagSqrOp<Type>(), minMagSqrOp<Type>(),
Type, Type,
f, f1,
Type, Type,
Min result
) )
return Min; return result;
} }
return pTraits<Type>::rootMax; return pTraits<Type>::rootMax;
@ -467,12 +480,12 @@ template<class Type>
typename scalarProduct<Type, Type>::type typename scalarProduct<Type, Type>::type
sumProd(const UList<Type>& f1, const UList<Type>& f2) sumProd(const UList<Type>& f1, const UList<Type>& f2)
{ {
typedef typename scalarProduct<Type, Type>::type prodType; typedef typename scalarProduct<Type, Type>::type resultType;
prodType result = Zero; resultType result = Zero;
if (f1.size() && (f1.size() == f2.size())) if (f1.size() && (f1.size() == f2.size()))
{ {
TFOR_ALL_S_OP_F_OP_F(prodType, result, +=, Type, f1, &&, Type, f2) TFOR_ALL_S_OP_F_OP_F(resultType, result, +=, Type, f1, &&, Type, f2)
} }
return result; return result;
} }
@ -502,37 +515,39 @@ Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2)
template<class Type> template<class Type>
typename outerProduct1<Type>::type typename outerProduct1<Type>::type
sumSqr(const UList<Type>& f) sumSqr(const UList<Type>& f1)
{ {
typedef typename outerProduct1<Type>::type prodType; typedef typename outerProduct1<Type>::type resultType;
prodType result = Zero;
if (f.size()) resultType result = Zero;
if (f1.size())
{ {
TFOR_ALL_S_OP_FUNC_F(prodType, result, +=, sqr, Type, f) TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, sqr, Type, f1)
} }
return result; return result;
} }
template<class Type> template<class Type>
typename outerProduct1<Type>::type typename outerProduct1<Type>::type
sumSqr(const tmp<Field<Type>>& tf) sumSqr(const tmp<Field<Type>>& tf1)
{ {
typedef typename outerProduct1<Type>::type prodType; typedef typename outerProduct1<Type>::type resultType;
prodType result = sumSqr(tf()); resultType result = sumSqr(tf1());
tf.clear(); tf1.clear();
return result; return result;
} }
template<class Type> template<class Type>
typename typeOfMag<Type>::type typename typeOfMag<Type>::type
sumMag(const UList<Type>& f) sumMag(const UList<Type>& f1)
{ {
typedef typename typeOfMag<Type>::type magType; typedef typename typeOfMag<Type>::type resultType;
magType result = Zero;
if (f.size()) resultType result = Zero;
if (f1.size())
{ {
TFOR_ALL_S_OP_FUNC_F(magType, result, +=, mag, Type, f) TFOR_ALL_S_OP_FUNC_F(resultType, result, +=, mag, Type, f1)
} }
return result; return result;
} }
@ -541,12 +556,12 @@ TMP_UNARY_FUNCTION(typename typeOfMag<Type>::type, sumMag)
template<class Type> template<class Type>
Type sumCmptMag(const UList<Type>& f) Type sumCmptMag(const UList<Type>& f1)
{ {
Type result = Zero; Type result = Zero;
if (f.size()) if (f1.size())
{ {
TFOR_ALL_S_OP_FUNC_F(Type, result, +=, cmptMag, Type, f) TFOR_ALL_S_OP_FUNC_F(Type, result, +=, cmptMag, Type, f1)
} }
return result; return result;
} }
@ -554,13 +569,13 @@ Type sumCmptMag(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, sumCmptMag) TMP_UNARY_FUNCTION(Type, sumCmptMag)
template<class Type> template<class Type>
Type average(const UList<Type>& f) Type average(const UList<Type>& f1)
{ {
if (f.size()) if (f1.size())
{ {
Type avrg = sum(f)/f.size(); Type result = sum(f1)/f1.size();
return avrg; return result;
} }
WarningInFunction WarningInFunction
@ -608,10 +623,10 @@ typename scalarProduct<Type, Type>::type gSumProd
const label comm const label comm
) )
{ {
typedef typename scalarProduct<Type, Type>::type prodType; typedef typename scalarProduct<Type, Type>::type resultType;
prodType result = sumProd(f1, f2); resultType result = sumProd(f1, f2);
reduce(result, sumOp<prodType>(), UPstream::msgType(), comm); reduce(result, sumOp<resultType>(), UPstream::msgType(), comm);
return result; return result;
} }
@ -623,27 +638,27 @@ Type gSumCmptProd
const label comm const label comm
) )
{ {
Type SumProd = sumCmptProd(f1, f2); Type result = sumCmptProd(f1, f2);
reduce(SumProd, sumOp<Type>(), UPstream::msgType(), comm); reduce(result, sumOp<Type>(), UPstream::msgType(), comm);
return SumProd; return result;
} }
template<class Type> template<class Type>
Type gAverage Type gAverage
( (
const UList<Type>& f, const UList<Type>& f1,
const label comm const label comm
) )
{ {
label n = f.size(); label n = f1.size();
Type s = sum(f); Type s = sum(f1);
sumReduce(s, n, UPstream::msgType(), comm); sumReduce(s, n, UPstream::msgType(), comm);
if (n > 0) if (n > 0)
{ {
Type avrg = s/n; Type result = s/n;
return avrg; return result;
} }
WarningInFunction WarningInFunction
@ -656,6 +671,8 @@ TMP_UNARY_FUNCTION(Type, gAverage)
#undef TMP_UNARY_FUNCTION #undef TMP_UNARY_FUNCTION
// Implement BINARY_FUNCTION_TRANSFORM_FS for clamp
template<class Type> template<class Type>
void clamp void clamp
( (
@ -664,55 +681,52 @@ void clamp
const MinMax<Type>& range const MinMax<Type>& range
) )
{ {
// Note: no checks for bad/invalid clamping ranges
if (result.cdata() == f1.cdata()) if (result.cdata() == f1.cdata())
{ {
// Apply in-place // Apply in-place
result.clamp(range); result.clamp_range(range);
} }
else else
{ {
if (range.good()) std::transform
{ (
std::transform f1.cbegin(),
( f1.cbegin(result.size()),
f1.cbegin(), result.begin(),
f1.cbegin(result.size()), clampOp<Type>(range)
result.begin(), );
clampOp<Type>(range)
);
}
else
{
// No clamping
std::copy(f1.cbegin(), f1.cbegin(result.size()), result.begin());
}
} }
} }
template<class Type> template<class Type>
tmp<Field<Type>> clamp void clamp
( (
Field<Type>& result,
const UList<Type>& f1, const UList<Type>& f1,
const MinMax<Type>& range const Foam::zero_one& // Note: macros generate a const reference
) )
{ {
auto tres = tmp<Field<Type>>::New(f1.size()); if (result.cdata() == f1.cdata())
clamp(tres.ref(), f1, range); {
return tres; // Apply in-place
result.clamp_range(Foam::zero_one{});
}
else
{
std::transform
(
f1.cbegin(),
f1.cbegin(result.size()),
result.begin(),
clampOp<Type>(Foam::zero_one{})
);
}
} }
template<class Type> BINARY_FUNCTION_INTERFACE_FS(Type, Type, MinMax<Type>, clamp)
tmp<Field<Type>> clamp BINARY_FUNCTION_INTERFACE_FS(Type, Type, Foam::zero_one, clamp)
(
const tmp<Field<Type>>& tf1,
const MinMax<Type>& range
)
{
auto tres = reuseTmp<Type, Type>::New(tf1);
clamp(tres.ref(), tf1(), range);
tf1.clear();
return tres;
}
BINARY_FUNCTION(Type, Type, Type, max) BINARY_FUNCTION(Type, Type, Type, max)
@ -727,6 +741,11 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip) // Same as clamp BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip) // Same as clamp
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
/* * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * */
@ -749,21 +768,21 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
template<class Type1, class Type2> \ template<class Type1, class Type2> \
void OpFunc \ void OpFunc \
( \ ( \
Field<typename product<Type1, Type2>::type>& res, \ Field<typename product<Type1, Type2>::type>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
) \ ) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
TFOR_ALL_F_OP_F_OP_F(productType, res, =, Type1, f1, Op, Type2, f2) \ TFOR_ALL_F_OP_F_OP_F(resultType, result, =, Type1, f1, Op, Type2, f2) \
} \ } \
\ \
template<class Type1, class Type2> \ template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \ tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const UList<Type2>& f2) \ operator Op(const UList<Type1>& f1, const UList<Type2>& f2) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
auto tres = tmp<Field<productType>>::New(f1.size()); \ auto tres = tmp<Field<resultType>>::New(f1.size()); \
OpFunc(tres.ref(), f1, f2); \ OpFunc(tres.ref(), f1, f2); \
return tres; \ return tres; \
} \ } \
@ -772,8 +791,8 @@ template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \ tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2) \ operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmp<productType, Type2>::New(tf2); \ auto tres = reuseTmp<resultType, Type2>::New(tf2); \
OpFunc(tres.ref(), f1, tf2()); \ OpFunc(tres.ref(), f1, tf2()); \
tf2.clear(); \ tf2.clear(); \
return tres; \ return tres; \
@ -783,8 +802,8 @@ template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \ tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2) \ operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmp<productType, Type1>::New(tf1); \ auto tres = reuseTmp<resultType, Type1>::New(tf1); \
OpFunc(tres.ref(), tf1(), f2); \ OpFunc(tres.ref(), tf1(), f2); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
@ -794,8 +813,8 @@ template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \ tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \ operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \
{ \ { \
typedef typename product<Type1, Type2>::type productType; \ typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmpTmp<productType, Type1, Type1, Type2>::New(tf1, tf2); \ auto tres = reuseTmpTmp<resultType, Type1, Type1, Type2>::New(tf1, tf2); \
OpFunc(tres.ref(), tf1(), tf2()); \ OpFunc(tres.ref(), tf1(), tf2()); \
tf1.clear(); \ tf1.clear(); \
tf2.clear(); \ tf2.clear(); \
@ -805,22 +824,22 @@ operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \
template<class Type, class Form, class Cmpt, direction nCmpt> \ template<class Type, class Form, class Cmpt, direction nCmpt> \
void OpFunc \ void OpFunc \
( \ ( \
Field<typename product<Type, Form>::type>& res, \ Field<typename product<Type, Form>::type>& result, \
const UList<Type>& f1, \ const UList<Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \ ) \
{ \ { \
typedef typename product<Type, Form>::type productType; \ typedef typename product<Type, Form>::type resultType; \
TFOR_ALL_F_OP_F_OP_S \ TFOR_ALL_F_OP_F_OP_S \
(productType, res, =,Type, f1, Op, Form, static_cast<const Form&>(vs)) \ (resultType, result, =,Type, f1, Op, Form, static_cast<const Form&>(vs))\
} \ } \
\ \
template<class Type, class Form, class Cmpt, direction nCmpt> \ template<class Type, class Form, class Cmpt, direction nCmpt> \
tmp<Field<typename product<Type, Form>::type>> \ tmp<Field<typename product<Type, Form>::type>> \
operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs) \ operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs) \
{ \ { \
typedef typename product<Type, Form>::type productType; \ typedef typename product<Type, Form>::type resultType; \
auto tres = tmp<Field<productType>>::New(f1.size()); \ auto tres = tmp<Field<resultType>>::New(f1.size()); \
OpFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \ OpFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \
return tres; \ return tres; \
} \ } \
@ -833,8 +852,8 @@ operator Op \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \ ) \
{ \ { \
typedef typename product<Type, Form>::type productType; \ typedef typename product<Type, Form>::type resultType; \
auto tres = reuseTmp<productType, Type>::New(tf1); \ auto tres = reuseTmp<resultType, Type>::New(tf1); \
OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \ OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \
@ -843,22 +862,22 @@ operator Op \
template<class Form, class Cmpt, direction nCmpt, class Type> \ template<class Form, class Cmpt, direction nCmpt, class Type> \
void OpFunc \ void OpFunc \
( \ ( \
Field<typename product<Form, Type>::type>& res, \ Field<typename product<Form, Type>::type>& result, \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const UList<Type>& f1 \ const UList<Type>& f1 \
) \ ) \
{ \ { \
typedef typename product<Form, Type>::type productType; \ typedef typename product<Form, Type>::type resultType; \
TFOR_ALL_F_OP_S_OP_F \ TFOR_ALL_F_OP_S_OP_F \
(productType, res, =,Form,static_cast<const Form&>(vs), Op, Type, f1) \ (resultType, result, =,Form,static_cast<const Form&>(vs), Op, Type, f1)\
} \ } \
\ \
template<class Form, class Cmpt, direction nCmpt, class Type> \ template<class Form, class Cmpt, direction nCmpt, class Type> \
tmp<Field<typename product<Form, Type>::type>> \ tmp<Field<typename product<Form, Type>::type>> \
operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1) \ operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1) \
{ \ { \
typedef typename product<Form, Type>::type productType; \ typedef typename product<Form, Type>::type resultType; \
auto tres = tmp<Field<productType>>::New(f1.size()); \ auto tres = tmp<Field<resultType>>::New(f1.size()); \
OpFunc(tres.ref(), static_cast<const Form&>(vs), f1); \ OpFunc(tres.ref(), static_cast<const Form&>(vs), f1); \
return tres; \ return tres; \
} \ } \
@ -870,8 +889,8 @@ operator Op \
const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type>>& tf1 \ const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type>>& tf1 \
) \ ) \
{ \ { \
typedef typename product<Form, Type>::type productType; \ typedef typename product<Form, Type>::type resultType; \
auto tres = reuseTmp<productType, Type>::New(tf1); \ auto tres = reuseTmp<resultType, Type>::New(tf1); \
OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \ OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \
tf1.clear(); \ tf1.clear(); \
return tres; \ return tres; \

6
src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
View File

@ -314,8 +314,14 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp) BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
BINARY_TYPE_FUNCTION_FS(Type, Type, Foam::zero_one, clamp)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip) // Same as clamp BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip) // Same as clamp
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //

399
src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd. Copyright (C) 2019-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -31,77 +31,99 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_FUNCTION(ReturnType, Type, Func) \ #define UNARY_FUNCTION(ReturnType, Type1, Func) \
\
TEMPLATE \
void Func(Field<ReturnType>& res, const UList<Type>& f) \
{ \
TFOR_ALL_F_OP_FUNC_F(ReturnType, res, =, ::Foam::Func, Type, f) \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func(const UList<Type>& f) \
{ \
auto tres = tmp<Field<ReturnType>>::New(f.size()); \
Func(tres.ref(), f); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func(const tmp<Field<Type>>& tf) \
{ \
auto tres = reuseTmp<ReturnType, Type>::New(tf); \
Func(tres.ref(), tf()); \
tf.clear(); \
return tres; \
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_OPERATOR(ReturnType, Type, Op, OpFunc) \
\
TEMPLATE \
void OpFunc(Field<ReturnType>& res, const UList<Type>& f) \
{ \
TFOR_ALL_F_OP_OP_F(ReturnType, res, =, Op, Type, f) \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> operator Op(const UList<Type>& f) \
{ \
auto tres = tmp<Field<ReturnType>>::New(f.size()); \
OpFunc(tres.ref(), f); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> operator Op(const tmp<Field<Type>>& tf) \
{ \
auto tres = reuseTmp<ReturnType, Type>::New(tf); \
OpFunc(tres.ref(), tf()); \
tf.clear(); \
return tres; \
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
Field<ReturnType>& res, \ Field<ReturnType>& result, \
const UList<Type1>& f1 \
) \
{ \
TFOR_ALL_F_OP_FUNC_F(ReturnType, result, =, ::Foam::Func, Type1, f1) \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1 \
) \
{ \
auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
Func(tres.ref(), f1); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1 \
) \
{ \
auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
Func(tres.ref(), tf1()); \
tf1.clear(); \
return tres; \
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc) \
\
TEMPLATE \
void OpFunc \
( \
Field<ReturnType>& result, \
const UList<Type1>& f1 \
) \
{ \
TFOR_ALL_F_OP_OP_F(ReturnType, result, =, Op, Type1, f1) \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> operator Op \
( \
const UList<Type1>& f1 \
) \
{ \
auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
OpFunc(tres.ref(), f1); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> operator Op \
( \
const tmp<Field<Type1>>& tf1 \
) \
{ \
auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
OpFunc(tres.ref(), tf1()); \
tf1.clear(); \
return tres; \
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
void Func \
( \
Field<ReturnType>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
) \ ) \
{ \ { \
TFOR_ALL_F_OP_FUNC_F_F \ TFOR_ALL_F_OP_FUNC_F_F \
( \ ( \
ReturnType, res, =, ::Foam::Func, Type1, f1, Type2, f2 \ ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2 \
) \ ) \
} \ }
#define BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> Func \ tmp<Field<ReturnType>> Func \
@ -155,24 +177,30 @@ tmp<Field<ReturnType>> Func \
return tres; \ return tres; \
} }
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \ #define BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
Field<ReturnType>& res, \ Field<ReturnType>& result, \
const Type1& s1, \ const Type1& s1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
) \ ) \
{ \ { \
TFOR_ALL_F_OP_FUNC_S_F \ TFOR_ALL_F_OP_FUNC_S_F \
( \ ( \
ReturnType, res, =, ::Foam::Func, Type1, s1, Type2, f2 \ ReturnType, result, =, ::Foam::Func, Type1, s1, Type2, f2 \
) \ ) \
} \ }
#define BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> Func \ tmp<Field<ReturnType>> Func \
@ -199,22 +227,28 @@ tmp<Field<ReturnType>> Func \
return tres; \ return tres; \
} }
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
#define BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
Field<ReturnType>& res, \ Field<ReturnType>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const Type2& s2 \ const Type2& s2 \
) \ ) \
{ \ { \
TFOR_ALL_F_OP_FUNC_F_S \ TFOR_ALL_F_OP_FUNC_F_S \
( \ ( \
ReturnType, res, =, ::Foam::Func, Type1, f1, Type2, s2 \ ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, s2 \
) \ ) \
} \ }
#define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> Func \ tmp<Field<ReturnType>> Func \
@ -241,6 +275,10 @@ tmp<Field<ReturnType>> Func \
return tres; \ return tres; \
} }
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)
#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \ BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
@ -254,12 +292,12 @@ tmp<Field<ReturnType>> Func \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
Field<ReturnType>& res, \ Field<ReturnType>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
) \ ) \
{ \ { \
TFOR_ALL_F_OP_F_OP_F(ReturnType, res, =, Type1, f1, Op, Type2, f2) \ TFOR_ALL_F_OP_F_OP_F(ReturnType, result, =, Type1, f1, Op, Type2, f2) \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
@ -322,12 +360,12 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
Field<ReturnType>& res, \ Field<ReturnType>& result, \
const Type1& s1, \ const Type1& s1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
) \ ) \
{ \ { \
TFOR_ALL_F_OP_S_OP_F(ReturnType, res, =, Type1, s1, Op, Type2, f2) \ TFOR_ALL_F_OP_S_OP_F(ReturnType, result, =, Type1, s1, Op, Type2, f2) \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
@ -361,12 +399,12 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
Field<ReturnType>& res, \ Field<ReturnType>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const Type2& s2 \ const Type2& s2 \
) \ ) \
{ \ { \
TFOR_ALL_F_OP_F_OP_S(ReturnType, res, =, Type1, f1, Op, Type2, s2) \ TFOR_ALL_F_OP_F_OP_S(ReturnType, result, =, Type1, f1, Op, Type2, s2) \
} \ } \
\ \
TEMPLATE \ TEMPLATE \
@ -400,4 +438,215 @@ tmp<Field<ReturnType>> operator Op \
BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc) BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const UList<Type3>& f3 \
) \
{ \
TFOR_ALL_F_OP_FUNC_F_F_F \
( \
ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, f3 \
) \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const UList<Type3>& f3 \
) \
{ \
auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
Func(tres.ref(), f1, f2, f3); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2, \
const UList<Type3>& f3 \
) \
{ \
auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
Func(tres.ref(), tf1(), f2, f3); \
tf1.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2, \
const UList<Type3>& f3 \
) \
{ \
auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
Func(tres.ref(), f1, tf2(), f3); \
tf2.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const tmp<Field<Type3>>& tf3 \
) \
{ \
auto tres = reuseTmp<ReturnType, Type3>::New(tf3); \
Func(tres.ref(), f1, f2, tf3()); \
tf3.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2, \
const UList<Type3>& f3 \
) \
{ \
auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
Func(tres.ref(), tf1(), tf2(), f3); \
tf1.clear(); \
tf2.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2, \
const tmp<Field<Type3>>& tf3 \
) \
{ \
auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type3>::New(tf1, tf3); \
Func(tres.ref(), tf1(), f2, tf3()); \
tf1.clear(); \
tf3.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2, \
const tmp<Field<Type3>>& tf3 \
) \
{ \
auto tres = reuseTmpTmp<ReturnType, Type2, Type2, Type3>::New(tf2, tf3); \
Func(tres.ref(), f1, tf2(), tf3()); \
tf2.clear(); \
tf3.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2, \
const tmp<Field<Type3>>& tf3 \
) \
{ \
/* TBD: check all three types? */ \
auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
Func(tres.ref(), tf1(), tf2(), tf3()); \
tf1.clear(); \
tf2.clear(); \
tf3.clear(); \
return tres; \
}
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const Type3& s3 \
) \
{ \
TFOR_ALL_F_OP_FUNC_F_F_S \
( \
ReturnType, result, =, ::Foam::Func, Type1, f1, Type2, f2, Type3, s3 \
) \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const Type3& s3 \
) \
{ \
auto tres = tmp<Field<ReturnType>>::New(f1.size()); \
Func(tres.ref(), f1, f2, s3); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2, \
const Type3& s3 \
) \
{ \
auto tres = reuseTmp<ReturnType, Type1>::New(tf1); \
Func(tres.ref(), tf1(), f2, s3); \
tf1.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2, \
const Type3& s3 \
) \
{ \
auto tres = reuseTmp<ReturnType, Type2>::New(tf2); \
Func(tres.ref(), f1, tf2(), s3); \
tf2.clear(); \
return tres; \
} \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2, \
const Type3& s3 \
) \
{ \
auto tres = reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2); \
Func(tres.ref(), tf1(), tf2(), s3); \
tf1.clear(); \
tf2.clear(); \
return tres; \
}
// ************************************************************************* // // ************************************************************************* //

262
src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -24,9 +25,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description Description
High performance macro functions for Field\<Type\> algebra. These expand Macro functions for Field\<Type\> algebra.
using either array element access (for vector machines) or pointer
dereferencing for scalar machines as appropriate.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -35,11 +34,13 @@ Description
#define UNARY_FUNCTION(ReturnType, Type1, Func) \ #define UNARY_FUNCTION(ReturnType, Type1, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func(Field<ReturnType>& res, const UList<Type1>& f); \ void Func(Field<ReturnType>& result, const UList<Type1>& f1); \
\
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> Func(const UList<Type1>& f); \ tmp<Field<ReturnType>> Func(const UList<Type1>& f1); \
\
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> Func(const tmp<Field<Type1>>& tf); tmp<Field<ReturnType>> Func(const tmp<Field<Type1>>& tf1);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -47,65 +48,74 @@ tmp<Field<ReturnType>> Func(const tmp<Field<Type1>>& tf);
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc) \ #define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
void OpFunc(Field<ReturnType>& res, const UList<Type1>& f); \ void OpFunc(Field<ReturnType>& res, const UList<Type1>& f1); \
\
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> operator Op(const UList<Type1>& f); \ tmp<Field<ReturnType>> operator Op(const UList<Type1>& f1); \
\
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> operator Op(const tmp<Field<Type1>>& tf); tmp<Field<ReturnType>> operator Op(const tmp<Field<Type1>>& tf1);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
void Func \
( \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const UList<Type2>& f2 \
);
#define BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2 \
);
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \ #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\ BINARY_FUNCTION_TRANSFORM(ReturnType, Type1, Type2, Func) \
TEMPLATE \ BINARY_FUNCTION_INTERFACE(ReturnType, Type1, Type2, Func)
void Func \
( \
Field<ReturnType>& f, \
const UList<Type1>& f1, \
const UList<Type2>& f2 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2 \
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \ #define BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
Field<ReturnType>& f, \ Field<ReturnType>& result, \
const Type1& s1, \ const Type1& s1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
); \ );
#define BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> Func \ tmp<Field<ReturnType>> Func \
@ -121,16 +131,22 @@ tmp<Field<ReturnType>> Func \
const tmp<Field<Type2>>& tf2 \ const tmp<Field<Type2>>& tf2 \
); );
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_TRANSFORM_SF(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func)
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
#define BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func \ void Func \
( \ ( \
Field<ReturnType>& f, \ Field<ReturnType>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const Type2& s2 \ const Type2& s2 \
); \ );
#define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<Field<ReturnType>> Func \ tmp<Field<ReturnType>> Func \
@ -146,6 +162,10 @@ tmp<Field<ReturnType>> Func \
const Type2& s2 \ const Type2& s2 \
); );
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_TRANSFORM_FS(ReturnType, Type1, Type2, Func) \
BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func)
#define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION(ReturnType, Type1, Type2, Func) \
BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \ BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
@ -159,7 +179,7 @@ tmp<Field<ReturnType>> Func \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
Field<ReturnType>& f, \ Field<ReturnType>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
); \ ); \
@ -200,7 +220,7 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
Field<ReturnType>& f, \ Field<ReturnType>& result, \
const Type1& s1, \ const Type1& s1, \
const UList<Type2>& f2 \ const UList<Type2>& f2 \
); \ ); \
@ -225,7 +245,7 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \ TEMPLATE \
void OpFunc \ void OpFunc \
( \ ( \
Field<ReturnType>& f, \ Field<ReturnType>& result, \
const UList<Type1>& f1, \ const UList<Type1>& f1, \
const Type2& s2 \ const Type2& s2 \
); \ ); \
@ -250,4 +270,136 @@ tmp<Field<ReturnType>> operator Op \
BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc) BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpFunc)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const UList<Type3>& f3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const UList<Type3>& f3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2, \
const UList<Type3>& f3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2, \
const UList<Type3>& f3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const tmp<Field<Type3>>& tf3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2, \
const UList<Type3>& f3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2, \
const tmp<Field<Type3>>& tf3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2, \
const tmp<Field<Type3>>& tf3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2, \
const tmp<Field<Type3>>& tf3 \
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Permutations of ternary functions taking non-field argument(s)
//
// FFS (defined)
// FSF (not defined)
// SFF (not defined)
// SSF (not defined)
// SFS (not defined)
// FSS (not defined)
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const UList<Type2>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const UList<Type2>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const UList<Type1>& f1, \
const tmp<Field<Type2>>& tf2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
( \
const tmp<Field<Type1>>& tf1, \
const tmp<Field<Type2>>& tf2, \
const Type3& s3 \
);
// ************************************************************************* // // ************************************************************************* //

113
src/OpenFOAM/fields/Fields/Field/FieldM.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2022 OpenCFD Ltd. Copyright (C) 2022-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -25,9 +25,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description Description
High performance macro functions for Field\<Type\> algebra. These expand Declaration macros for Field\<Type\> algebra.
using either array element access (for vector machines) or pointer
dereferencing for scalar machines as appropriate.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -86,6 +84,34 @@ void checkFields
} }
} }
template<class Type1, class Type2, class Type3, class Type4>
void checkFields
(
const UList<Type1>& f1,
const UList<Type2>& f2,
const UList<Type3>& f3,
const UList<Type4>& f4,
const char* op
)
{
if
(
f1.size() != f2.size()
|| f1.size() != f3.size()
|| f1.size() != f4.size()
)
{
FatalErrorInFunction
<< " Field<"<<pTraits<Type1>::typeName<<"> f1("<<f1.size()<<')'
<< ", Field<"<<pTraits<Type2>::typeName<<"> f2("<<f2.size()<<')'
<< ", Field<"<<pTraits<Type3>::typeName<<"> f3("<<f3.size()<<')'
<< " and Field<"<<pTraits<Type4>::typeName<<"> f4("<<f4.size()<<')'
<< endl
<< " for operation " << op
<< abort(FatalError);
}
}
#else #else
template<class Type1, class Type2> template<class Type1, class Type2>
@ -107,12 +133,23 @@ void checkFields
) )
{} {}
template<class Type1, class Type2, class Type3, class Type4>
void checkFields
(
const UList<Type1>&,
const UList<Type2>&,
const UList<Type3>&,
const UList<Type4>&,
const char*
)
{}
#endif #endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Member function : f1 OP Func f2 // Unary Free Function : f1 OP Func f2
#define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2) \ #define TFOR_ALL_F_OP_FUNC_F(typeF1, f1, OP, FUNC, typeF2, f2) \
\ \
@ -133,7 +170,7 @@ void checkFields
} }
// Member function : this f1 OP f2.FUNC() // Nullary Member Function : f1 OP f2.FUNC()
#define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC) \ #define TFOR_ALL_F_OP_F_FUNC(typeF1, f1, OP, typeF2, f2, FUNC) \
\ \
@ -154,7 +191,7 @@ void checkFields
} }
// Member function : this field f1 OP FUNC(f2, f3) // Binary Free Function : f1 OP FUNC(f2, f3)
#define TFOR_ALL_F_OP_FUNC_F_F(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3) \ #define TFOR_ALL_F_OP_FUNC_F_F(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3) \
\ \
@ -176,7 +213,7 @@ void checkFields
} }
// Member function : s OP FUNC(f1, f2) // [reduction] Binary Free Function : s OP FUNC(f1, f2)
#define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2) \ #define TFOR_ALL_S_OP_FUNC_F_F(typeS, s, OP, FUNC, typeF1, f1, typeF2, f2) \
\ \
@ -197,7 +234,7 @@ void checkFields
} }
// Member function : this f1 OP FUNC(f2, s) // Binary Free Function : f1 OP FUNC(f2, s)
#define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s) \ #define TFOR_ALL_F_OP_FUNC_F_S(typeF1, f1, OP, FUNC, typeF2, f2, typeS, s) \
\ \
@ -218,7 +255,7 @@ void checkFields
} }
// Member function : s1 OP FUNC(f, s2) // [reduction] Binary Free Function : s1 OP FUNC(f, s2)
#define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2) \ #define TFOR_ALL_S_OP_FUNC_F_S(typeS1, s1, OP, FUNC, typeF, f, typeS2, s2) \
\ \
@ -235,7 +272,7 @@ void checkFields
} }
// Member function : this f1 OP FUNC(s, f2) // Binary Free Function : f1 OP FUNC(s, f2)
#define TFOR_ALL_F_OP_FUNC_S_F(typeF1, f1, OP, FUNC, typeS, s, typeF2, f2) \ #define TFOR_ALL_F_OP_FUNC_S_F(typeF1, f1, OP, FUNC, typeS, s, typeF2, f2) \
\ \
@ -256,7 +293,7 @@ void checkFields
} }
// Member function : this f1 OP FUNC(s1, s2) // Binary Free Function : f1 OP FUNC(s1, s2)
#define TFOR_ALL_F_OP_FUNC_S_S(typeF1, f1, OP, FUNC, typeS1, s1, typeS2, s2) \ #define TFOR_ALL_F_OP_FUNC_S_S(typeF1, f1, OP, FUNC, typeS1, s1, typeS2, s2) \
\ \
@ -273,7 +310,7 @@ void checkFields
} }
// Member function : this f1 OP f2 FUNC(s) // Unary Member Function : f1 OP f2 FUNC(s)
#define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s) \ #define TFOR_ALL_F_OP_F_FUNC_S(typeF1, f1, OP, typeF2, f2, FUNC, typeS, s) \
\ \
@ -294,6 +331,56 @@ void checkFields
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Ternary Free Function : f1 OP FUNC(f2, f3, f4)
#define TFOR_ALL_F_OP_FUNC_F_F_F\
(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3, typeF4, f4) \
\
/* Check fields have same size */ \
checkFields(f1, f2, f3, f4, "f1 " #OP " " #FUNC "(f2, f3, f4)"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
List_CONST_ACCESS(typeF3, f3, f3P); \
List_CONST_ACCESS(typeF4, f4, f4P); \
\
/* Loop: f1 OP FUNC(f2, f3, f4) */ \
const label loopLen = (f1).size(); \
\
/* pragmas... */ \
for (label i = 0; i < loopLen; ++i) \
{ \
(f1P[i]) OP FUNC((f2P[i]), (f3P[i]), (f4P[i])); \
}
// Ternary Free Function : f1 OP FUNC(f2, f3, s4)
#define TFOR_ALL_F_OP_FUNC_F_F_S\
(typeF1, f1, OP, FUNC, typeF2, f2, typeF3, f3, typeF4, s4) \
\
/* Check fields have same size */ \
checkFields(f1, f2, f3, "f1 " #OP " " #FUNC "(f2, f3, s)"); \
\
/* Field access */ \
List_ACCESS(typeF1, f1, f1P); \
List_CONST_ACCESS(typeF2, f2, f2P); \
List_CONST_ACCESS(typeF3, f3, f3P); \
\
/* Loop: f1 OP FUNC(f2, f3, s4) */ \
const label loopLen = (f1).size(); \
\
/* pragmas... */ \
for (label i = 0; i < loopLen; ++i) \
{ \
(f1P[i]) OP FUNC((f2P[i]), (f3P[i]), (s4)); \
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Member operator : this field f1 OP1 f2 OP2 f3 // Member operator : this field f1 OP1 f2 OP2 f3
#define TFOR_ALL_F_OP_F_OP_F(typeF1, f1, OP1, typeF2, f2, OP2, typeF3, f3) \ #define TFOR_ALL_F_OP_F_OP_F(typeF1, f1, OP1, typeF2, f2, OP2, typeF3, f3) \

21
src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019-2022 OpenCFD Ltd. Copyright (C) 2019-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -35,10 +35,18 @@ namespace Foam
{ {
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// One-parameter versions
template<class TypeR, class Type1> template<class TypeR, class Type1>
struct reuseTmp struct reuseTmp
{ {
//- Pass-through to tmp New
static tmp<Field<TypeR>> New(const Field<Type1>& f1)
{
return tmp<Field<TypeR>>::New(f1.size());
}
//- Dissimilar types: just use size
static tmp<Field<TypeR>> New(const tmp<Field<Type1>>& tf1) static tmp<Field<TypeR>> New(const tmp<Field<Type1>>& tf1)
{ {
return tmp<Field<TypeR>>::New(tf1().size()); return tmp<Field<TypeR>>::New(tf1().size());
@ -49,8 +57,8 @@ struct reuseTmp
template<class TypeR> template<class TypeR>
struct reuseTmp<TypeR, TypeR> struct reuseTmp<TypeR, TypeR>
{ {
//- Allow optional copy assignment of the initial content //- Identical input and return types:
//- for identical input and output types //- allow optional copy assignment of the initial content
static tmp<Field<TypeR>> New static tmp<Field<TypeR>> New
( (
const tmp<Field<TypeR>>& tf1, const tmp<Field<TypeR>>& tf1,
@ -85,9 +93,13 @@ template<class TypeR> tmp<Field<TypeR>> New
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Two-parameter versions
template<class TypeR, class Type1, class Type12, class Type2> template<class TypeR, class Type1, class Type12, class Type2>
struct reuseTmpTmp struct reuseTmpTmp
{ {
//- Dissimilar types: just use size
static tmp<Field<TypeR>> New static tmp<Field<TypeR>> New
( (
const tmp<Field<Type1>>& tf1, const tmp<Field<Type1>>& tf1,
@ -102,6 +114,7 @@ struct reuseTmpTmp
template<class TypeR, class Type1, class Type12> template<class TypeR, class Type1, class Type12>
struct reuseTmpTmp<TypeR, Type1, Type12, TypeR> struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
{ {
//- Second input has return type
static tmp<Field<TypeR>> New static tmp<Field<TypeR>> New
( (
const tmp<Field<Type1>>& tf1, const tmp<Field<Type1>>& tf1,
@ -121,6 +134,7 @@ struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
template<class TypeR, class Type2> template<class TypeR, class Type2>
struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2> struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
{ {
//- First input has return type
static tmp<Field<TypeR>> New static tmp<Field<TypeR>> New
( (
const tmp<Field<TypeR>>& tf1, const tmp<Field<TypeR>>& tf1,
@ -140,6 +154,7 @@ struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
template<class TypeR> template<class TypeR>
struct reuseTmpTmp<TypeR, TypeR, TypeR, TypeR> struct reuseTmpTmp<TypeR, TypeR, TypeR, TypeR>
{ {
//- Both inputs have return type
static tmp<Field<TypeR>> New static tmp<Field<TypeR>> New
( (
const tmp<Field<TypeR>>& tf1, const tmp<Field<TypeR>>& tf1,

27
src/OpenFOAM/fields/Fields/Field/undefFieldFunctionsM.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011 OpenFOAM Foundation Copyright (C) 2011 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -26,20 +27,40 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#undef UNARY_FUNCTION #undef UNARY_FUNCTION
#undef UNARY_FUNCTION_TRANSFORM
#undef UNARY_FUNCTION_INTERFACE
#undef UNARY_OPERATOR #undef UNARY_OPERATOR
#undef UNARY_OPERATOR_TRANSFORM
#undef UNARY_OPERATOR_INTERFACE
#undef BINARY_FUNCTION #undef BINARY_FUNCTION
#undef BINARY_FUNCTION_TRANSFORM
#undef BINARY_FUNCTION_INTERFACE
#undef BINARY_TYPE_FUNCTION
#undef BINARY_TYPE_FUNCTION_SF #undef BINARY_TYPE_FUNCTION_SF
#undef BINARY_TYPE_FUNCTION_FS #undef BINARY_TYPE_FUNCTION_FS
#undef BINARY_TYPE_FUNCTION #undef BINARY_FUNCTION_TRANSFORM_SF
#undef BINARY_FUNCTION_INTERFACE_SF
#undef BINARY_FUNCTION_TRANSFORM_FS
#undef BINARY_FUNCTION_INTERFACE_FS
#undef BINARY_OPERATOR #undef BINARY_OPERATOR
#undef BINARY_TYPE_OPERATOR
#undef BINARY_TYPE_OPERATOR_SF #undef BINARY_TYPE_OPERATOR_SF
#undef BINARY_TYPE_OPERATOR_FS #undef BINARY_TYPE_OPERATOR_FS
#undef BINARY_TYPE_OPERATOR
#undef TERNARY_FUNCTION
#undef TERNARY_FUNCTION_TRANSFORM
#undef TERNARY_FUNCTION_INTERFACE
#undef TERNARY_TYPE_FUNCTION
#undef TERNARY_TYPE_FUNCTION_FFS
#undef TERNARY_TYPE_FUNCTION_FSF
#undef TERNARY_TYPE_FUNCTION_SFF
#undef TERNARY_TYPE_FUNCTION_SSF
#undef TERNARY_TYPE_FUNCTION_SFS
#undef TERNARY_TYPE_FUNCTION_FSS
#undef TEMPLATE #undef TEMPLATE

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

@ -1249,50 +1249,6 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::replace
} }
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
(
const Type& lower,
const Type& upper
)
{
primitiveFieldRef().clamp(lower, upper);
boundaryFieldRef().clamp(lower, upper);
}
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
(
const MinMax<Type>& range
)
{
primitiveFieldRef().clamp(range.min(), range.max());
boundaryFieldRef().clamp(range.min(), range.max());
}
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
(
const dimensioned<Type>& lower,
const dimensioned<Type>& upper
)
{
this->clamp(lower.value(), upper.value());
}
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp
(
const dimensioned<MinMax<Type>>& range
)
{
this->clamp(range.value());
}
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_min void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_min
( (
@ -1335,6 +1291,50 @@ void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_max
} }
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
(
const Type& lower,
const Type& upper
)
{
primitiveFieldRef().clamp_range(lower, upper);
boundaryFieldRef().clamp_range(lower, upper);
}
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
(
const MinMax<Type>& range
)
{
primitiveFieldRef().clamp_range(range.min(), range.max());
boundaryFieldRef().clamp_range(range.min(), range.max());
}
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
(
const dimensioned<Type>& lower,
const dimensioned<Type>& upper
)
{
this->clamp_range(lower.value(), upper.value());
}
template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::clamp_range
(
const dimensioned<MinMax<Type>>& range
)
{
this->clamp_range(range.value());
}
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
void Foam::GeometricField<Type, PatchField, GeoMesh>::negate() void Foam::GeometricField<Type, PatchField, GeoMesh>::negate()
{ {

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

@ -629,26 +629,6 @@ public:
const dimensioned<cmptType>& ds const dimensioned<cmptType>& ds
); );
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range.
void clamp(const Type& lower, const Type& upper);
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range.
void clamp(const MinMax<Type>& range);
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range. No dimension checking.
void clamp
(
const dimensioned<Type>& lower,
const dimensioned<Type>& upper
);
//- Clamp field values (in-place) to the specified range.
// A no-op for an invalid range. No dimension checking.
void clamp(const dimensioned<MinMax<Type>>& range);
//- Impose lower (floor) clamp on the field values (in-place) //- Impose lower (floor) clamp on the field values (in-place)
void clamp_min(const Type& lower); void clamp_min(const Type& lower);
@ -663,6 +643,26 @@ public:
// No dimension checking // No dimension checking
void clamp_max(const dimensioned<Type>& upper); void clamp_max(const dimensioned<Type>& upper);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not. No dimension checking.
void clamp_range(const dimensioned<MinMax<Type>>& range);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not.
void clamp_range(const Type& lower, const Type& upper);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not.
void clamp_range(const MinMax<Type>& range);
//- Clamp field values (in-place) to the specified range.
// Does not check if range is valid or not. No dimension checking.
void clamp_range
(
const dimensioned<Type>& lower,
const dimensioned<Type>& upper
);
// Member Operators // Member Operators
@ -715,17 +715,17 @@ public:
// Housekeeping // Housekeeping
//- Clamp field values (in-place) to the specified range. //- Clamp field values (in-place) to the specified range.
// \deprecated(2023-01) prefer clamp() naming // \deprecated(2023-01) prefer clamp_range() naming
void clip(const dimensioned<MinMax<Type>>& range) void clip(const dimensioned<MinMax<Type>>& range)
{ {
this->clamp(range); this->clamp_range(range);
} }
//- Clamp field values (in-place) to the specified range. //- Clamp field values (in-place) to the specified range.
// \deprecated(2023-01) prefer clamp() naming // \deprecated(2023-01) prefer clamp_range() naming
void clip(const dimensioned<Type>& lo, const dimensioned<Type>& hi) void clip(const dimensioned<Type>& lo, const dimensioned<Type>& hi)
{ {
this->clamp(lo.value(), hi.value()); this->clamp_range(lo.value(), hi.value());
} }
//- Use minimum of the field and specified value. ie, clamp_max(). //- Use minimum of the field and specified value. ie, clamp_max().
@ -738,12 +738,12 @@ public:
// \deprecated(2023-01) prefer clamp_min() // \deprecated(2023-01) prefer clamp_min()
void max(const dimensioned<Type>& lower) { this->clamp_min(lower); } void max(const dimensioned<Type>& lower) { this->clamp_min(lower); }
//- Deprecated(2019-01) identical to clamp() //- Deprecated(2019-01) identical to clamp_range()
// \deprecated(2019-01) identical to clamp() // \deprecated(2019-01) identical to clamp_range()
FOAM_DEPRECATED_FOR(2019-01, "clamp() method") FOAM_DEPRECATED_FOR(2019-01, "clamp_range() method")
void maxMin(const dimensioned<Type>& lo, const dimensioned<Type>& hi) void maxMin(const dimensioned<Type>& lo, const dimensioned<Type>& hi)
{ {
return this->clamp(lo.value(), hi.value()); return this->clamp_range(lo.value(), hi.value());
} }
}; };

666
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.C
View File

File diff suppressed because it is too large Load Diff

187
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctions.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2019 OpenCFD Ltd. Copyright (C) 2018-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -37,7 +37,7 @@ License
namespace Foam namespace Foam
{ {
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
void component void component
@ -47,16 +47,16 @@ void component
typename GeometricField<Type, PatchField, GeoMesh>::cmptType, typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField, PatchField,
GeoMesh GeoMesh
>& gcf, >& result,
const GeometricField<Type, PatchField, GeoMesh>& gf, const GeometricField<Type, PatchField, GeoMesh>& f1,
const direction d const direction d
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
void T void T
( (
GeometricField<Type, PatchField, GeoMesh>& gf, GeometricField<Type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& gf1 const GeometricField<Type, PatchField, GeoMesh>& f1
); );
template template
@ -68,8 +68,9 @@ template
> >
void pow void pow
( (
GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>& gf, GeometricField
const GeometricField<Type, PatchField, GeoMesh>& gf1 <typename powProduct<Type, r>::type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& f1
); );
template template
@ -86,7 +87,7 @@ tmp
> >
pow pow
( (
const GeometricField<Type, PatchField, GeoMesh>& gf, const GeometricField<Type, PatchField, GeoMesh>& f1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
); );
@ -104,7 +105,7 @@ tmp
> >
pow pow
( (
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf, const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,
typename powProduct<Type, r>::type typename powProduct<Type, r>::type
); );
@ -112,7 +113,7 @@ template<class Type, template<class> class PatchField, class GeoMesh>
void sqr void sqr
( (
GeometricField GeometricField
<typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& gf, <typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& f1,
const GeometricField<Type, PatchField, GeoMesh>& gf1 const GeometricField<Type, PatchField, GeoMesh>& gf1
); );
@ -126,7 +127,7 @@ tmp
GeoMesh GeoMesh
> >
> >
sqr(const GeometricField<Type, PatchField, GeoMesh>& gf); sqr(const GeometricField<Type, PatchField, GeoMesh>& f1);
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
tmp tmp
@ -138,48 +139,48 @@ tmp
GeoMesh GeoMesh
> >
> >
sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf); sqr(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1);
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
void magSqr void magSqr
( (
GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf, GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& gf const GeometricField<Type, PatchField, GeoMesh>& f1
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>> tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
magSqr magSqr
( (
const GeometricField<Type, PatchField, GeoMesh>& gf const GeometricField<Type, PatchField, GeoMesh>& f1
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>> tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
magSqr magSqr
( (
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
void mag void mag
( (
GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf, GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& gf const GeometricField<Type, PatchField, GeoMesh>& tf1
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>> tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
mag mag
( (
const GeometricField<Type, PatchField, GeoMesh>& gf const GeometricField<Type, PatchField, GeoMesh>& f1
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>> tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
mag mag
( (
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
@ -190,8 +191,8 @@ void cmptAv
typename GeometricField<Type, PatchField, GeoMesh>::cmptType, typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField, PatchField,
GeoMesh GeoMesh
>& gcf, >& result,
const GeometricField<Type, PatchField, GeoMesh>& gf const GeometricField<Type, PatchField, GeoMesh>& f1
); );
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
@ -204,7 +205,7 @@ tmp
GeoMesh GeoMesh
> >
> >
cmptAv(const GeometricField<Type, PatchField, GeoMesh>& gf); cmptAv(const GeometricField<Type, PatchField, GeoMesh>& f1);
template<class Type, template<class> class PatchField, class GeoMesh> template<class Type, template<class> class PatchField, class GeoMesh>
tmp tmp
@ -216,21 +217,21 @@ tmp
GeoMesh GeoMesh
> >
> >
cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf); cmptAv(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1);
#define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(returnType, func, binaryOp) \ #define UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(ReturnType, Func, BinaryOp) \
\ \
template<class Type, template<class> class PatchField, class GeoMesh> \ template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const GeometricField<Type, PatchField, GeoMesh>& gf \ const GeometricField<Type, PatchField, GeoMesh>& f1 \
); \ ); \
\ \
template<class Type, template<class> class PatchField, class GeoMesh> \ template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \ const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1 \
); );
UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(Type, max, maxOp) UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(Type, max, maxOp)
@ -241,18 +242,18 @@ UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(scalarMinMax, minMaxMag, minMaxMagOp)
#undef UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY #undef UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY
#define UNARY_REDUCTION_FUNCTION(returnType, func, gFunc) \ #define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc) \
\ \
template<class Type, template<class> class PatchField, class GeoMesh> \ template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const GeometricField<Type, PatchField, GeoMesh>& gf \ const GeometricField<Type, PatchField, GeoMesh>& f1 \
); \ ); \
\ \
template<class Type, template<class> class PatchField, class GeoMesh> \ template<class Type, template<class> class PatchField, class GeoMesh> \
dimensioned<returnType> func \ dimensioned<ReturnType> Func \
( \ ( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \ const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1 \
); );
UNARY_REDUCTION_FUNCTION(Type, sum, gSum) UNARY_REDUCTION_FUNCTION(Type, sum, gSum)
@ -272,8 +273,44 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, min)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide) BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
// ------------------------------------------------------------------------- //
// * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * // // Clamp Methods
template<class Type, template<class> class PatchField, class GeoMesh>
void clamp
(
GeometricField<Type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& f1,
const Foam::zero_one
);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<Type, PatchField, GeoMesh>>
clamp
(
const GeometricField<Type, PatchField, GeoMesh>& f1,
const Foam::zero_one
);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<Type, PatchField, GeoMesh>>
clamp
(
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,
const Foam::zero_one
);
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
TERNARY_FUNCTION(Type, Type, Type, scalar, lerp)
TERNARY_TYPE_FUNCTION_FFS(Type, Type, Type, scalar, lerp)
// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
UNARY_OPERATOR(Type, Type, -, negate, transform) UNARY_OPERATOR(Type, Type, -, negate, transform)
@ -289,16 +326,16 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \ #define PRODUCT_OPERATOR(product, Op, OpFunc) \
\ \
template \ template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \ <class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
void opFunc \ void OpFunc \
( \ ( \
GeometricField \ GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh>& gf, \ <typename product<Type1, Type2>::type, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
template \ template \
@ -308,10 +345,10 @@ tmp \
GeometricField \ GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \ <typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
template \ template \
@ -321,10 +358,10 @@ tmp \
GeometricField \ GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \ <typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \ const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \ ); \
\ \
template \ template \
@ -334,10 +371,10 @@ tmp \
GeometricField \ GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \ <typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \ const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
template \ template \
@ -347,19 +384,19 @@ tmp \
GeometricField \ GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \ <typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \ const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \ const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \ ); \
\ \
template \ template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \ <class Form, class Type, template<class> class PatchField, class GeoMesh> \
void opFunc \ void OpFunc \
( \ ( \
GeometricField \ GeometricField \
<typename product<Type, Form>::type, PatchField, GeoMesh>& gf, \ <typename product<Type, Form>::type, PatchField, GeoMesh>& result, \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \ const GeometricField<Type, PatchField, GeoMesh>& f1, \
const dimensioned<Form>& dvs \ const dimensioned<Form>& dvs \
); \ ); \
\ \
@ -370,9 +407,9 @@ tmp \
GeometricField \ GeometricField \
<typename product<Type, Form>::type, PatchField, GeoMesh> \ <typename product<Type, Form>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \ const GeometricField<Type, PatchField, GeoMesh>& f1, \
const dimensioned<Form>& dvs \ const dimensioned<Form>& dvs \
); \ ); \
\ \
@ -389,9 +426,9 @@ tmp \
GeometricField \ GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \ <typename product<Form, Type>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \ const GeometricField<Type, PatchField, GeoMesh>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \ ); \
\ \
@ -402,9 +439,9 @@ tmp \
GeometricField \ GeometricField \
<typename product<Type, Form>::type, PatchField, GeoMesh> \ <typename product<Type, Form>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1, \ const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1, \
const dimensioned<Form>& dvs \ const dimensioned<Form>& dvs \
); \ ); \
\ \
@ -421,20 +458,20 @@ tmp \
GeometricField \ GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \ <typename product<Form, Type>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1, \ const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \ const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \ ); \
\ \
template \ template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \ <class Form, class Type, template<class> class PatchField, class GeoMesh> \
void opFunc \ void OpFunc \
( \ ( \
GeometricField \ GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh>& gf, \ <typename product<Form, Type>::type, PatchField, GeoMesh>& result, \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \ const GeometricField<Type, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
template \ template \
@ -444,10 +481,10 @@ tmp \
GeometricField \ GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \ <typename product<Form, Type>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \ const GeometricField<Type, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
template \ template \
@ -463,10 +500,10 @@ tmp \
GeometricField \ GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \ <typename product<Form, Type>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \ const GeometricField<Type, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
template \ template \
@ -476,10 +513,10 @@ tmp \
GeometricField \ GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \ <typename product<Form, Type>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \ const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2 \
); \ ); \
\ \
template \ template \
@ -495,10 +532,10 @@ tmp \
GeometricField \ GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \ <typename product<Form, Type>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator Op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \ const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2 \
); );
PRODUCT_OPERATOR(typeOfSum, +, add) PRODUCT_OPERATOR(typeOfSum, +, add)

934
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.C
View File

File diff suppressed because it is too large Load Diff

361
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldFunctionsM.H
View File

@ -6,6 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -30,32 +31,46 @@ License
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \ #define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ void Func \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df \ GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1 \ const GeometricField<Type1, PatchField, GeoMesh>& f1 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1 \
); );
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_OPERATOR(ReturnType, Type1, Op, opFunc, Dfunc) \ #define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1 \ GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1 \ const GeometricField<Type1, PatchField, GeoMesh>& f1 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1 \
); );
@ -64,6 +79,14 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \ #define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
void Func \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ const GeometricField<Type1, PatchField, GeoMesh>& df1, \
@ -73,22 +96,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \ const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \ const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); );
@ -97,62 +120,78 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ void Func \
( \ ( \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const Type1& t1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const Type1& t1, \ const Type1& s1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const Type1& s1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); );
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \ #define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ void Func \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf2, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const Type2& t2 \ const Type2& s2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const Type2& s2 \
); );
@ -166,95 +205,119 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \ #define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \ const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \ const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); );
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \ #define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const Type1& t1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const dimensioned<Type1>& dt1, \ const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const Type1& t1, \ const Type1& s1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \ const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const Type1& s1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); );
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \ #define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ void OpFunc \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \ const dimensioned<Type2>& dt2 \
); \ ); \
\ \
TEMPLATE \ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \ ( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \ const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const Type2& t2 \ const Type2& s2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const Type2& s2 \
); );
@ -263,4 +326,158 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define TERNARY_FUNCTION(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
GeometricField<Type1, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const GeometricField<Type3, PatchField, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const GeometricField<Type3, PatchField, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const GeometricField<Type3, PatchField, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const GeometricField<Type3, PatchField, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const GeometricField<Type3, PatchField, GeoMesh>& f3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const tmp<GeometricField<Type3, PatchField, GeoMesh>>& tf3 \
);
#define TERNARY_TYPE_FUNCTION_FFS(ReturnType, Type1, Type2, Type3, Func) \
\
TEMPLATE \
void Func \
( \
GeometricField<Type1, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const Type3& s3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const dimensioned<Type3>& dt3 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2, \
const Type3& s3 \
);
// ************************************************************************* // // ************************************************************************* //

154
src/OpenFOAM/fields/GeometricFields/GeometricField/GeometricFieldReuseFunctions.H
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2022 OpenCFD Ltd. Copyright (C) 2018-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -76,6 +76,7 @@ inline bool reusable
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// One-parameter versions
template template
< <
@ -86,24 +87,46 @@ template
> >
struct reuseTmpGeometricField struct reuseTmpGeometricField
{ {
//- Pass-through to New GeometricField
static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
( (
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, const GeometricField<Type1, PatchField, GeoMesh>& f1,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const auto& gf1 = tgf1(); return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
(
IOobject
(
name,
f1.instance(),
f1.db()
),
f1.mesh(),
dimensions
);
}
//- Dissimilar types: return new field
static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
(
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
const word& name,
const dimensionSet& dimensions
)
{
const auto& f1 = tf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
gf1.instance(), f1.instance(),
gf1.db() f1.db()
), ),
gf1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -117,41 +140,41 @@ struct reuseTmpGeometricField<TypeR, TypeR, PatchField, GeoMesh>
//- for identical input and output types //- for identical input and output types
static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
( (
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
const word& name, const word& name,
const dimensionSet& dimensions, const dimensionSet& dimensions,
const bool initCopy = false const bool initCopy = false
) )
{ {
if (Detail::reusable(tgf1)) if (Detail::reusable(tf1))
{ {
auto& gf1 = tgf1.constCast(); auto& f1 = tf1.constCast();
gf1.rename(name); f1.rename(name);
gf1.dimensions().reset(dimensions); f1.dimensions().reset(dimensions);
return tgf1; return tf1;
} }
const auto& gf1 = tgf1(); const auto& f1 = tf1();
auto rtgf = tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New auto tresult = tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
gf1.instance(), f1.instance(),
gf1.db() f1.db()
), ),
gf1.mesh(), f1.mesh(),
dimensions dimensions
); );
if (initCopy) if (initCopy)
{ {
rtgf.ref() == gf1; tresult.ref() == f1;
} }
return rtgf; return tresult;
} }
}; };
@ -163,7 +186,7 @@ tmp
GeometricField<TypeR, PatchField, GeoMesh> GeometricField<TypeR, PatchField, GeoMesh>
> New > New
( (
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
const word& name, const word& name,
const dimensionSet& dimensions, const dimensionSet& dimensions,
const bool initCopy = false const bool initCopy = false
@ -171,7 +194,7 @@ tmp
{ {
return reuseTmpGeometricField<TypeR, TypeR, PatchField, GeoMesh>::New return reuseTmpGeometricField<TypeR, TypeR, PatchField, GeoMesh>::New
( (
tgf1, tf1,
name, name,
dimensions, dimensions,
initCopy initCopy
@ -192,23 +215,23 @@ struct reuseTmpTmpGeometricField
{ {
static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
( (
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2, const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
const auto& gf1 = tgf1(); const auto& f1 = tf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
gf1.instance(), f1.instance(),
gf1.db() f1.db()
), ),
gf1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -230,32 +253,32 @@ struct reuseTmpTmpGeometricField
{ {
static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
( (
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1,
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
if (Detail::reusable(tgf2)) if (Detail::reusable(tf2))
{ {
auto& gf2 = tgf2.constCast(); auto& f2 = tf2.constCast();
gf2.rename(name); f2.rename(name);
gf2.dimensions().reset(dimensions); f2.dimensions().reset(dimensions);
return tgf2; return tf2;
} }
const auto& gf1 = tgf1(); const auto& f1 = tf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
gf1.instance(), f1.instance(),
gf1.db() f1.db()
), ),
gf1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -276,32 +299,32 @@ struct reuseTmpTmpGeometricField
{ {
static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
( (
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2, const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
if (Detail::reusable(tgf1)) if (Detail::reusable(tf1))
{ {
auto& gf1 = tgf1.constCast(); auto& f1 = tf1.constCast();
gf1.rename(name); f1.rename(name);
gf1.dimensions().reset(dimensions); f1.dimensions().reset(dimensions);
return tgf1; return tf1;
} }
const auto& gf1 = tgf1(); const auto& f1 = tf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
gf1.instance(), f1.instance(),
gf1.db() f1.db()
), ),
gf1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
@ -316,47 +339,46 @@ struct reuseTmpTmpGeometricField
{ {
static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New static tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
( (
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf1,
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tf2,
const word& name, const word& name,
const dimensionSet& dimensions const dimensionSet& dimensions
) )
{ {
if (Detail::reusable(tgf1)) if (Detail::reusable(tf1))
{ {
auto& gf1 = tgf1.constCast(); auto& f1 = tf1.constCast();
gf1.rename(name); f1.rename(name);
gf1.dimensions().reset(dimensions); f1.dimensions().reset(dimensions);
return tgf1; return tf1;
} }
if (Detail::reusable(tgf2)) if (Detail::reusable(tf2))
{ {
auto& gf2 = tgf2.constCast(); auto& f2 = tf2.constCast();
gf2.rename(name); f2.rename(name);
gf2.dimensions().reset(dimensions); f2.dimensions().reset(dimensions);
return tgf2; return tf2;
} }
const auto& gf1 = tgf1(); const auto& f1 = tf1();
return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New return tmp<GeometricField<TypeR, PatchField, GeoMesh>>::New
( (
IOobject IOobject
( (
name, name,
gf1.instance(), f1.instance(),
gf1.db() f1.db()
), ),
gf1.mesh(), f1.mesh(),
dimensions dimensions
); );
} }
}; };
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam } // End namespace Foam

2
src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C
View File

@ -149,7 +149,7 @@ Type Foam::uniformInterpolationTable<Type>::interpolate(scalar x) const
{ {
if (bound_) if (bound_)
{ {
x = max(min(xMax() - SMALL*dx_, x), x0_); x = clamp(x, x0_, (xMax() - SMALL*dx_));
} }
else else
{ {

4
src/OpenFOAM/meshes/meshShapes/face/face.C
View File

@ -76,7 +76,7 @@ Foam::label Foam::face::mostConcaveAngle
// NOTE: is -ve angle since left edge pointing in other direction // NOTE: is -ve angle since left edge pointing in other direction
scalar edgeCos = (leftEdge & rightEdge); scalar edgeCos = (leftEdge & rightEdge);
scalar edgeAngle = acos(max(-1.0, min(1.0, edgeCos))); scalar edgeAngle = acos(clamp(edgeCos, -1, 1));
scalar angle; scalar angle;
@ -205,7 +205,7 @@ Foam::label Foam::face::split
splitEdge.normalise(); splitEdge.normalise();
const scalar splitCos = splitEdge & rightEdge; const scalar splitCos = splitEdge & rightEdge;
const scalar splitAngle = acos(max(-1.0, min(1.0, splitCos))); const scalar splitAngle = acos(clamp(splitCos, -1, 1));
const scalar angleDiff = fabs(splitAngle - bisectAngle); const scalar angleDiff = fabs(splitAngle - bisectAngle);
if (angleDiff < minDiff) if (angleDiff < minDiff)

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

@ -101,7 +101,7 @@ bool Foam::polyMesh::checkFaceOrthogonality
<< " between cells " << own[facei] << " between cells " << own[facei]
<< " and " << nei[facei] << " and " << nei[facei]
<< ": Angle = " << ": Angle = "
<< radToDeg(::acos(min(1.0, max(-1.0, ortho[facei])))) << radToDeg(::acos(clamp(ortho[facei], -1, 1)))
<< " deg." << endl; << " deg." << endl;
} }
@ -130,9 +130,9 @@ bool Foam::polyMesh::checkFaceOrthogonality
if (debug || report) if (debug || report)
{ {
Info<< " Mesh non-orthogonality Max: " Info<< " Mesh non-orthogonality Max: "
<< radToDeg(::acos(min(1.0, max(-1.0, minDDotS)))) << radToDeg(::acos(clamp(minDDotS, -1, 1)))
<< " average: " << " average: "
<< radToDeg(::acos(min(1.0, max(-1.0, sumDDotS/nSummed)))) << radToDeg(::acos(clamp(sumDDotS/nSummed, -1, 1)))
<< endl; << endl;
} }
} }

2
src/OpenFOAM/meshes/primitiveShapes/triangle/triangleI.H
View File

@ -334,7 +334,7 @@ inline Foam::scalar Foam::triangle<Point, PointRef>::circumRadius() const
} }
const scalar a = (d1 + d2)*(d2 + d3)*(d3 + d1) / denom; const scalar a = (d1 + d2)*(d2 + d3)*(d3 + d1) / denom;
return 0.5*Foam::sqrt(min(GREAT, max(0, a))); return 0.5*Foam::sqrt(clamp(a, 0, GREAT));
} }

6
src/OpenFOAM/primitives/functions/Function1/InputValueMapper/InputValueMapperI.H
View File

@ -47,7 +47,7 @@ inline Type Foam::Function1Types::InputValueMapper<Type>::value
} }
case mappingMode::MINMAX: case mappingMode::MINMAX:
{ {
scalar tlim = min(max(t, min_), max_); scalar tlim = clamp(t, min_, max_);
return value_->value(tlim); return value_->value(tlim);
} }
@ -86,8 +86,8 @@ Type Foam::Function1Types::InputValueMapper<Type>::integrate
} }
case mappingMode::MINMAX: case mappingMode::MINMAX:
{ {
scalar xlim0 = min(max(x1, min_), max_); scalar xlim0 = clamp(x1, min_, max_);
scalar xlim1 = min(max(x2, min_), max_); scalar xlim1 = clamp(x2, min_, max_);
Type intValue = value_->integrate(xlim0, xlim1); Type intValue = value_->integrate(xlim0, xlim1);

2
src/OpenFOAM/primitives/functions/Function1/ramp/ramp.H
View File

@ -100,7 +100,7 @@ protected:
//- that forms the basis of many more complex ramp functions //- that forms the basis of many more complex ramp functions
inline scalar linearRamp(const scalar t) const inline scalar linearRamp(const scalar t) const
{ {
return max(min((t - start_)/duration_, 1), 0); return clamp((t - start_)/duration_, 0, 1);
} }

3
src/OpenFOAM/primitives/ranges/MinMax/MinMax.H
View File

@ -85,6 +85,7 @@ Description
#define Foam_MinMax_H #define Foam_MinMax_H
#include "scalar.H" #include "scalar.H"
#include "zero.H"
#include "Pair.H" #include "Pair.H"
#include "Tuple2.H" #include "Tuple2.H"
#include "VectorSpace.H" #include "VectorSpace.H"
@ -97,8 +98,6 @@ namespace Foam
// Forward Declarations // Forward Declarations
template<class T> class MinMax; template<class T> class MinMax;
class zero;
class zero_one;
// Common min/max types // Common min/max types
typedef MinMax<label> labelMinMax; //!< A label min/max range typedef MinMax<label> labelMinMax; //!< A label min/max range

2
src/OpenFOAM/primitives/triad/triad.C
View File

@ -395,7 +395,7 @@ Foam::scalar Foam::diff(const triad& A, const triad& B)
(tmpA[dir] & tmpB[dir]) (tmpA[dir] & tmpB[dir])
/(Foam::mag(tmpA[dir])*Foam::mag(tmpA[dir]) + SMALL); /(Foam::mag(tmpA[dir])*Foam::mag(tmpA[dir]) + SMALL);
cosPhi = min(max(cosPhi, -1), 1); cosPhi = clamp(cosPhi, -1, 1);
sumDifference += mag(cosPhi - 1); sumDifference += mag(cosPhi - 1);
} }

4
src/TurbulenceModels/turbulenceModels/DES/SpalartAllmarasIDDES/SpalartAllmarasIDDES.C
View File

@ -113,7 +113,7 @@ tmp<volScalarField> SpalartAllmarasIDDES<BasicTurbulenceModel>::dTilda
if (fe_) if (fe_)
{ {
tmp<volScalarField> fe1 = tmp<volScalarField> fe1 =
2*(pos0(alpha)*pow(expTerm, -11.09) + neg(alpha)*pow(expTerm, -9.)); 2*lerp(pow(expTerm, -9.), pow(expTerm, -11.09), pos0(alpha));
tmp<volScalarField> fe2 = 1 - max(ft(magGradU), fl(magGradU)); tmp<volScalarField> fe2 = 1 - max(ft(magGradU), fl(magGradU));
tmp<volScalarField> fe = max(fe1 - 1, scalar(0))*psi*fe2; tmp<volScalarField> fe = max(fe1 - 1, scalar(0))*psi*fe2;
@ -129,7 +129,7 @@ tmp<volScalarField> SpalartAllmarasIDDES<BasicTurbulenceModel>::dTilda
// Simplified formulation from Gritskevich et al. paper (2011) where fe = 0 // Simplified formulation from Gritskevich et al. paper (2011) where fe = 0
return max return max
( (
fdTilda*lRAS + (1 - fdTilda)*lLES, lerp(lLES, lRAS, fdTilda),
dimensionedScalar("SMALL", dimLength, SMALL) dimensionedScalar("SMALL", dimLength, SMALL)
); );
} }

4
src/TurbulenceModels/turbulenceModels/DES/kOmegaSSTIDDES/kOmegaSSTIDDES.C
View File

@ -109,7 +109,7 @@ tmp<volScalarField> kOmegaSSTIDDES<BasicTurbulenceModel>::dTilda
if (fe_) if (fe_)
{ {
tmp<volScalarField> fe1 = tmp<volScalarField> fe1 =
2*(pos0(alpha)*pow(expTerm, -11.09) + neg(alpha)*pow(expTerm, -9.)); 2*lerp(pow(expTerm, -9.), pow(expTerm, -11.09), pos0(alpha));
tmp<volScalarField> fe2 = 1 - max(ft(magGradU), fl(magGradU)); tmp<volScalarField> fe2 = 1 - max(ft(magGradU), fl(magGradU));
tmp<volScalarField> fe = max(fe1 - 1, scalar(0))*fe2; tmp<volScalarField> fe = max(fe1 - 1, scalar(0))*fe2;
@ -124,7 +124,7 @@ tmp<volScalarField> kOmegaSSTIDDES<BasicTurbulenceModel>::dTilda
// Simplified formulation from Gritskevich et al. paper (2011) where fe = 0 // Simplified formulation from Gritskevich et al. paper (2011) where fe = 0
return max return max
( (
fdTilda*lRAS + (1 - fdTilda)*lLES, lerp(lLES, lRAS, fdTilda),
dimensionedScalar(dimLength, SMALL) dimensionedScalar(dimLength, SMALL)
); );
} }

4
src/TurbulenceModels/turbulenceModels/LES/dynamicKEqn/dynamicKEqn.C
View File

@ -102,7 +102,7 @@ volScalarField dynamicKEqn<BasicTurbulenceModel>::Ce() const
( (
0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_))) 0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_)))
); );
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL)); KK.clamp_min(SMALL);
return Ce(D, KK); return Ce(D, KK);
} }
@ -245,7 +245,7 @@ void dynamicKEqn<BasicTurbulenceModel>::correct()
tgradU.clear(); tgradU.clear();
volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U)))); volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL)); KK.clamp_min(SMALL);
tmp<fvScalarMatrix> kEqn tmp<fvScalarMatrix> kEqn
( (

2
src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthDissipationRateInlet/turbulentMixingLengthDissipationRateInletFvPatchScalarField.C
View File

@ -157,7 +157,7 @@ void turbulentMixingLengthDissipationRateInletFvPatchScalarField::updateCoeffs()
patch().lookupPatchField<surfaceScalarField>(this->phiName_); patch().lookupPatchField<surfaceScalarField>(this->phiName_);
this->refValue() = (Cmu75/mixingLength_)*pow(kp, 1.5); this->refValue() = (Cmu75/mixingLength_)*pow(kp, 1.5);
this->valueFraction() = 1.0 - pos0(phip); this->valueFraction() = neg(phip);
inletOutletFvPatchScalarField::updateCoeffs(); inletOutletFvPatchScalarField::updateCoeffs();
} }

2
src/TurbulenceModels/turbulenceModels/RAS/derivedFvPatchFields/turbulentMixingLengthFrequencyInlet/turbulentMixingLengthFrequencyInletFvPatchScalarField.C
View File

@ -146,7 +146,7 @@ void turbulentMixingLengthFrequencyInletFvPatchScalarField::updateCoeffs()
patch().lookupPatchField<surfaceScalarField>(this->phiName_); patch().lookupPatchField<surfaceScalarField>(this->phiName_);
this->refValue() = sqrt(kp)/(Cmu25*mixingLength_); this->refValue() = sqrt(kp)/(Cmu25*mixingLength_);
this->valueFraction() = 1.0 - pos0(phip); this->valueFraction() = neg(phip);
inletOutletFvPatchScalarField::updateCoeffs(); inletOutletFvPatchScalarField::updateCoeffs();
} }

4
src/TurbulenceModels/turbulenceModels/RAS/kOmegaSSTLM/kOmegaSSTLM.C
View File

@ -70,7 +70,7 @@ tmp<volScalarField::Internal> kOmegaSSTLM<BasicTurbulenceModel>::epsilonByk
) const ) const
{ {
return return
min(max(gammaIntEff_, scalar(0.1)), scalar(1)) clamp(gammaIntEff_, scalarMinMax(0.1, 1))
*kOmegaSST<BasicTurbulenceModel>::epsilonByk(F1, gradU); *kOmegaSST<BasicTurbulenceModel>::epsilonByk(F1, gradU);
} }
@ -310,7 +310,7 @@ tmp<volScalarField::Internal> kOmegaSSTLM<BasicTurbulenceModel>::ReThetat0
} }
lambda = sqr(thetat)/nu[celli]*dUsds[celli]; lambda = sqr(thetat)/nu[celli]*dUsds[celli];
lambda = max(min(lambda, 0.1), -0.1); lambda = clamp(lambda, -0.1, 0.1);
lambdaErr = mag(lambda - lambda0); lambdaErr = mag(lambda - lambda0);

2
src/TurbulenceModels/turbulenceModels/RAS/realizableKE/realizableKE.C
View File

@ -63,7 +63,7 @@ tmp<volScalarField> realizableKE<BasicTurbulenceModel>::rCmu
volScalarField phis volScalarField phis
( (
(1.0/3.0)*acos(min(max(sqrt(6.0)*W, -scalar(1)), scalar(1))) (1.0/3.0)*acos(clamp(sqrt(6.0)*W, scalarMinMax(-1, 1)))
); );
volScalarField As(sqrt(6.0)*cos(phis)); volScalarField As(sqrt(6.0)*cos(phis));
volScalarField Us(sqrt(S2/2.0 + magSqr(skew(gradU)))); volScalarField Us(sqrt(S2/2.0 + magSqr(skew(gradU))));

17
src/TurbulenceModels/turbulenceModels/ReynoldsStress/ReynoldsStress.C
View File

@ -39,20 +39,15 @@ void Foam::ReynoldsStress<BasicTurbulenceModel>::boundNormalStress
volSymmTensorField& R volSymmTensorField& R
) const ) const
{ {
scalar kMin = this->kMin_.value(); const scalar kMin = this->kMin_.value();
R.max R.clamp_min
( (
dimensionedSymmTensor symmTensor
( (
"zero", kMin, -GREAT, -GREAT,
R.dimensions(), kMin, -GREAT,
symmTensor kMin
(
kMin, -GREAT, -GREAT,
kMin, -GREAT,
kMin
)
) )
); );
} }

4
src/combustionModels/EDC/EDC.C
View File

@ -109,13 +109,13 @@ void Foam::combustionModels::EDC<ReactionThermo>::correct()
const scalar nu = mu[i]/(rho[i] + SMALL); const scalar nu = mu[i]/(rho[i] + SMALL);
const scalar Da = const scalar Da =
max(min(sqrt(nu/(epsilon[i] + SMALL))/tc[i], 10), 1e-10); clamp(sqrt(nu/(epsilon[i] + SMALL))/tc[i], 1e-10, 10);
const scalar ReT = sqr(k[i])/(nu*epsilon[i] + SMALL); const scalar ReT = sqr(k[i])/(nu*epsilon[i] + SMALL);
const scalar CtauI = min(C1_/(Da*sqrt(ReT + 1)), 2.1377); const scalar CtauI = min(C1_/(Da*sqrt(ReT + 1)), 2.1377);
const scalar CgammaI = const scalar CgammaI =
max(min(C2_*sqrt(Da*(ReT + 1)), 5), 0.4082); clamp(C2_*sqrt(Da*(ReT + 1)), 0.4082, 5);
const scalar gammaL = const scalar gammaL =
CgammaI*pow025(nu*epsilon[i]/(sqr(k[i]) + SMALL)); CgammaI*pow025(nu*epsilon[i]/(sqr(k[i]) + SMALL));

3
src/combustionModels/FSD/reactionRateFlameAreaModels/relaxation/relaxation.C
View File

@ -136,8 +136,7 @@ void Foam::reactionRateFlameAreaModels::relaxation::correct
- fvm::SuSp(rho*(tau + Rc), omega_) - fvm::SuSp(rho*(tau + Rc), omega_)
); );
omega_.min(omega0); omega_.clamp_range(0, omega0.value());
omega_.max(0.0);
} }

2
src/engine/include/StCorr.H
View File

@ -80,7 +80,7 @@
); );
dimensionedScalar AkEst = gSum(mgb*mesh.V().field()); dimensionedScalar AkEst = gSum(mgb*mesh.V().field());
StCorr.value() = max(min((Ak/AkEst).value(), 10.0), 1.0); StCorr.value() = clamp((Ak/AkEst).value(), 1, 10);
Info<< "StCorr = " << StCorr.value() << endl; Info<< "StCorr = " << StCorr.value() << endl;
} }

8
src/finiteArea/fields/faPatchFields/basic/coupled/coupledFaPatchField.C
View File

@ -130,8 +130,12 @@ void Foam::coupledFaPatchField<Type>::evaluate(const Pstream::commsTypes)
{ {
Field<Type>::operator= Field<Type>::operator=
( (
this->patch().weights()*this->patchInternalField() lerp
+ (1.0 - this->patch().weights())*patchNeighbourField() (
this->patchNeighbourField(),
this->patchInternalField(),
this->patch().weights()
)
); );
} }

36
src/finiteArea/fields/faPatchFields/basic/mixed/mixedFaPatchField.C
View File

@ -198,12 +198,11 @@ void Foam::mixedFaPatchField<Type>::evaluate(const Pstream::commsTypes)
Field<Type>::operator= Field<Type>::operator=
( (
valueFraction_*refValue_ lerp
+
(1.0 - valueFraction_)*
( (
this->patchInternalField() this->patchInternalField() + refGrad_/this->patch().deltaCoeffs(),
+ refGrad_/this->patch().deltaCoeffs() refValue_,
valueFraction_
) )
); );
@ -214,11 +213,12 @@ void Foam::mixedFaPatchField<Type>::evaluate(const Pstream::commsTypes)
template<class Type> template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::mixedFaPatchField<Type>::snGrad() const Foam::tmp<Foam::Field<Type>> Foam::mixedFaPatchField<Type>::snGrad() const
{ {
return return lerp
(
refGrad_,
(refValue_ - this->patchInternalField())*this->patch().deltaCoeffs(),
valueFraction_ valueFraction_
*(refValue_ - this->patchInternalField()) );
*this->patch().deltaCoeffs()
+ (1.0 - valueFraction_)*refGrad_;
} }
@ -238,9 +238,12 @@ Foam::tmp<Foam::Field<Type>> Foam::mixedFaPatchField<Type>::valueBoundaryCoeffs
const tmp<scalarField>& const tmp<scalarField>&
) const ) const
{ {
return return lerp
valueFraction_*refValue_ (
+ (1.0 - valueFraction_)*refGrad_/this->patch().deltaCoeffs(); refGrad_/this->patch().deltaCoeffs(),
refValue_,
valueFraction_
);
} }
@ -256,9 +259,12 @@ template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::tmp<Foam::Field<Type>>
Foam::mixedFaPatchField<Type>::gradientBoundaryCoeffs() const Foam::mixedFaPatchField<Type>::gradientBoundaryCoeffs() const
{ {
return return lerp
valueFraction_*this->patch().deltaCoeffs()*refValue_ (
+ (1.0 - valueFraction_)*refGrad_; refGrad_,
this->patch().deltaCoeffs()*refValue_,
valueFraction_
);
} }

2
src/finiteArea/fields/faPatchFields/derived/inletOutlet/inletOutletFaPatchField.C
View File

@ -126,7 +126,7 @@ void Foam::inletOutletFaPatchField<Type>::updateCoeffs()
const Field<scalar>& phip = const Field<scalar>& phip =
this->patch().template lookupPatchField<edgeScalarField>(phiName_); this->patch().template lookupPatchField<edgeScalarField>(phiName_);
this->valueFraction() = 1.0 - pos(phip); this->valueFraction() = neg(phip);
mixedFaPatchField<Type>::updateCoeffs(); mixedFaPatchField<Type>::updateCoeffs();
} }

6
src/finiteArea/interpolation/edgeInterpolation/edgeInterpolation.C
View File

@ -529,11 +529,7 @@ void Foam::edgeInterpolation::makeCorrectionVectors() const
if (owner.size() > 0) if (owner.size() > 0)
{ {
scalarField sinAlpha(deltaCoeffs*mag(CorrVecs.internalField())); scalarField sinAlpha(deltaCoeffs*mag(CorrVecs.internalField()));
sinAlpha.clamp_range(-1, 1);
forAll(sinAlpha, edgeI)
{
sinAlpha[edgeI] = max(-1, min(sinAlpha[edgeI], 1));
}
NonOrthogCoeff = max(Foam::asin(sinAlpha)*180.0/M_PI); NonOrthogCoeff = max(Foam::asin(sinAlpha)*180.0/M_PI);
} }

4
src/finiteArea/interpolation/edgeInterpolation/schemes/Gamma/Gamma.H
View File

@ -110,9 +110,9 @@ public:
gradcf = stabilise(gradcf, SMALL); gradcf = stabilise(gradcf, SMALL);
scalar phict = 1 - 0.5*gradf/gradcf; scalar phict = 1 - 0.5*gradf/gradcf;
scalar limiter = min(max(phict/k_, 0), 1); scalar limiter = clamp(phict/k_, 0, 1);
return limiter*cdWeight + (1 - limiter)*udWeight; return lerp(udWeight, cdWeight, limiter);
} }
}; };

2
src/finiteVolume/cfdTools/general/SRF/derivedFvPatchFields/SRFFreestreamVelocityFvPatchVectorField/SRFFreestreamVelocityFvPatchVectorField.C
View File

@ -152,7 +152,7 @@ void Foam::SRFFreestreamVelocityFvPatchVectorField::updateCoeffs()
} }
// Set the inlet-outlet choice based on the direction of the freestream // Set the inlet-outlet choice based on the direction of the freestream
valueFraction() = 1.0 - pos0(refValue() & patch().Sf()); valueFraction() = neg(refValue() & patch().Sf());
mixedFvPatchField<vector>::updateCoeffs(); mixedFvPatchField<vector>::updateCoeffs();
} }

17
src/finiteVolume/expressions/fields/fvPatchFields/exprMixedFvPatchField.C
View File

@ -234,25 +234,14 @@ Foam::exprMixedFvPatchField<Type>::exprMixedFvPatchField
} }
else else
{ {
// Emulate mixedFvPatchField<Type>::evaluate, // Like mixedFvPatchField<Type>::evaluate()
// but avoid our own updateCoeffs // but avoid our own updateCoeffs
if (!this->updated()) if (!this->updated())
{ {
this->parent_bctype::updateCoeffs(); mixedFvPatchField<Type>::updateCoeffs();
} }
Field<Type>::operator= mixedFvPatchField<Type>::evaluate();
(
this->valueFraction()*this->refValue()
+
(1.0 - this->valueFraction())*
(
this->patchInternalField()
+ this->refGrad()/this->patch().deltaCoeffs()
)
);
fvPatchField<Type>::evaluate();
} }
} }

8
src/finiteVolume/fields/fvPatchFields/basic/coupled/coupledFvPatchField.C
View File

@ -139,8 +139,12 @@ void Foam::coupledFvPatchField<Type>::evaluate(const Pstream::commsTypes)
Field<Type>::operator= Field<Type>::operator=
( (
this->patch().weights()*this->patchInternalField() lerp
+ (1.0 - this->patch().weights())*this->patchNeighbourField() (
this->patchNeighbourField(),
this->patchInternalField(),
this->patch().weights()
)
); );
fvPatchField<Type>::evaluate(); fvPatchField<Type>::evaluate();

38
src/finiteVolume/fields/fvPatchFields/basic/mixed/mixedFvPatchField.C
View File

@ -209,7 +209,6 @@ void Foam::mixedFvPatchField<Type>::rmap
template<class Type> template<class Type>
void Foam::mixedFvPatchField<Type>::evaluate(const Pstream::commsTypes) void Foam::mixedFvPatchField<Type>::evaluate(const Pstream::commsTypes)
{ {
if (!this->updated()) if (!this->updated())
{ {
this->updateCoeffs(); this->updateCoeffs();
@ -217,11 +216,11 @@ void Foam::mixedFvPatchField<Type>::evaluate(const Pstream::commsTypes)
Field<Type>::operator= Field<Type>::operator=
( (
valueFraction_*refValue_ lerp
+ (1.0 - valueFraction_) (
*( this->patchInternalField() + refGrad_/this->patch().deltaCoeffs(),
this->patchInternalField() refValue_,
+ refGrad_/this->patch().deltaCoeffs() valueFraction_
) )
); );
@ -233,11 +232,12 @@ template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::tmp<Foam::Field<Type>>
Foam::mixedFvPatchField<Type>::snGrad() const Foam::mixedFvPatchField<Type>::snGrad() const
{ {
return return lerp
(
refGrad_,
(refValue_ - this->patchInternalField())*this->patch().deltaCoeffs(),
valueFraction_ valueFraction_
*(refValue_ - this->patchInternalField()) );
*this->patch().deltaCoeffs()
+ (1.0 - valueFraction_)*refGrad_;
} }
@ -259,9 +259,12 @@ Foam::mixedFvPatchField<Type>::valueBoundaryCoeffs
const tmp<scalarField>& const tmp<scalarField>&
) const ) const
{ {
return return lerp
valueFraction_*refValue_ (
+ (1.0 - valueFraction_)*refGrad_/this->patch().deltaCoeffs(); refGrad_/this->patch().deltaCoeffs(),
refValue_,
valueFraction_
);
} }
@ -277,9 +280,12 @@ template<class Type>
Foam::tmp<Foam::Field<Type>> Foam::tmp<Foam::Field<Type>>
Foam::mixedFvPatchField<Type>::gradientBoundaryCoeffs() const Foam::mixedFvPatchField<Type>::gradientBoundaryCoeffs() const
{ {
return return lerp
valueFraction_*this->patch().deltaCoeffs()*refValue_ (
+ (1.0 - valueFraction_)*refGrad_; refGrad_,
this->patch().deltaCoeffs()*refValue_,
valueFraction_
);
} }

20
src/finiteVolume/fields/fvPatchFields/derived/activeBaffleVelocity/activeBaffleVelocityFvPatchVectorField.C
View File

@ -249,22 +249,18 @@ void Foam::activeBaffleVelocityFvPatchVectorField::updateCoeffs()
} }
openFraction_ = openFraction_ =
max
( (
min openFraction_
+ min
( (
openFraction_ this->db().time().deltaTValue()/openingTime_,
+ min maxOpenFractionDelta_
( )
this->db().time().deltaTValue()/openingTime_, *(orientation_*sign(forceDiff))
maxOpenFractionDelta_
)
*(orientation_*sign(forceDiff)),
1 - 1e-6
),
1e-6
); );
openFraction_ = clamp(openFraction_, 1e-6, 1 - 1e-6);
Info<< "openFraction = " << openFraction_ << endl; Info<< "openFraction = " << openFraction_ << endl;
vectorField::subField Sfw = this->patch().patch().faceAreas(); vectorField::subField Sfw = this->patch().patch().faceAreas();

27
src/finiteVolume/fields/fvPatchFields/derived/activePressureForceBaffleVelocity/activePressureForceBaffleVelocityFvPatchVectorField.C
View File

@ -299,27 +299,18 @@ void Foam::activePressureForceBaffleVelocityFvPatchVectorField::updateCoeffs()
if (mag(valueDiff) > mag(minThresholdValue_) || baffleActivated_) if (mag(valueDiff) > mag(minThresholdValue_) || baffleActivated_)
{ {
openFraction_ = openFraction_ =
max (
openFraction_
+ min
( (
min this->db().time().deltaT().value()/openingTime_,
( maxOpenFractionDelta_
openFraction_ )
+ min );
(
this->db().time().deltaT().value()/openingTime_,
maxOpenFractionDelta_
),
1 - 1e-6
),
1e-6
);
baffleActivated_ = true; baffleActivated_ = true;
}
else
{
openFraction_ = max(min(1 - 1e-6, openFraction_), 1e-6);
} }
openFraction_ = clamp(openFraction_, 1e-6, 1 - 1e-6);
if (Pstream::master()) if (Pstream::master())
{ {

2
src/finiteVolume/fields/fvPatchFields/derived/fixedJump/fixedJumpFvPatchField.C
View File

@ -212,7 +212,7 @@ void Foam::fixedJumpFvPatchField<Type>::relax()
return; return;
} }
jump_ = relaxFactor_*jump_ + (1 - relaxFactor_)*jump0_; jump_ = lerp(jump0_, jump_, relaxFactor_);
if (timeIndex_ != this->db().time().timeIndex()) if (timeIndex_ != this->db().time().timeIndex())
{ {

2
src/finiteVolume/fields/fvPatchFields/derived/inletOutlet/inletOutletFvPatchField.C
View File

@ -128,7 +128,7 @@ void Foam::inletOutletFvPatchField<Type>::updateCoeffs()
const Field<scalar>& phip = const Field<scalar>& phip =
this->patch().template lookupPatchField<surfaceScalarField>(phiName_); this->patch().template lookupPatchField<surfaceScalarField>(phiName_);
this->valueFraction() = 1.0 - pos0(phip); this->valueFraction() = neg(phip);
mixedFvPatchField<Type>::updateCoeffs(); mixedFvPatchField<Type>::updateCoeffs();
} }

4
src/finiteVolume/fields/fvPatchFields/derived/inletOutletTotalTemperature/inletOutletTotalTemperatureFvPatchScalarField.C
View File

@ -181,8 +181,8 @@ void Foam::inletOutletTotalTemperatureFvPatchScalarField::updateCoeffs()
scalar gM1ByG = (gamma_ - 1.0)/gamma_; scalar gM1ByG = (gamma_ - 1.0)/gamma_;
this->refValue() = this->refValue() =
T0_/(1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up)); T0_/(1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up));
this->valueFraction() = 1.0 - pos0(phip); this->valueFraction() = neg(phip);
inletOutletFvPatchScalarField::updateCoeffs(); inletOutletFvPatchScalarField::updateCoeffs();
} }

18
src/finiteVolume/fields/fvPatchFields/derived/partialSlip/partialSlipFvPatchField.C
View File

@ -153,8 +153,12 @@ Foam::partialSlipFvPatchField<Type>::snGrad() const
return return
( (
valueFraction_*refValue_ lerp
+ (1.0 - valueFraction_)*transform(I - sqr(nHat), pif) - pif (
transform(I - sqr(nHat), pif),
refValue_,
valueFraction_
) - pif
)*this->patch().deltaCoeffs(); )*this->patch().deltaCoeffs();
} }
@ -174,10 +178,12 @@ void Foam::partialSlipFvPatchField<Type>::evaluate
Field<Type>::operator= Field<Type>::operator=
( (
valueFraction_*refValue_ lerp
+ (
(1.0 - valueFraction_) transform(I - sqr(nHat), this->patchInternalField()),
*transform(I - sqr(nHat), this->patchInternalField()) refValue_,
valueFraction_
)
); );
parent_bctype::evaluate(); parent_bctype::evaluate();

6
src/finiteVolume/fields/fvPatchFields/derived/phaseHydrostaticPressure/phaseHydrostaticPressureFvPatchScalarField.C
View File

@ -148,9 +148,9 @@ void Foam::phaseHydrostaticPressureFvPatchScalarField::updateCoeffs()
meshObjects::gravity::New(db().time()); meshObjects::gravity::New(db().time());
// scalar rhor = 1000; // scalar rhor = 1000;
// scalarField alphap1 = max(min(alphap, scalar(1)), scalar(0)); // scalarField alphap1 = clamp(alphap, zero_one{});
// valueFraction() = alphap1/(alphap1 + rhor*(1.0 - alphap1)); // valueFraction() = alphap1/(alphap1 + rhor*(1.0 - alphap1));
valueFraction() = max(min(alphap, scalar(1)), scalar(0)); valueFraction() = clamp(alphap, zero_one{});
refValue() = refValue() =
pRefValue_ pRefValue_
@ -180,7 +180,7 @@ void Foam::phaseHydrostaticPressureFvPatchScalarField::operator=
{ {
fvPatchScalarField::operator= fvPatchScalarField::operator=
( (
valueFraction()*refValue() + (1 - valueFraction())*ptf lerp(ptf, refValue(), valueFraction())
); );
} }

9
src/finiteVolume/fields/fvPatchFields/derived/plenumPressure/plenumPressureFvPatchScalarField.C
View File

@ -272,7 +272,12 @@ void Foam::plenumPressureFvPatchScalarField::updateCoeffs()
// Limit to prevent outflow // Limit to prevent outflow
const scalarField p_new const scalarField p_new
( (
(1.0 - pos0(phi))*t*plenumPressure + pos0(phi)*max(p, plenumPressure) lerp
(
t*plenumPressure, // Negative phi
max(p, plenumPressure), // Positive phi
pos0(phi) // 0-1 selector
)
); );
// Relaxation fraction // Relaxation fraction
@ -280,7 +285,7 @@ void Foam::plenumPressureFvPatchScalarField::updateCoeffs()
const scalar fraction = oneByFraction < 1.0 ? 1.0 : 1.0/oneByFraction; const scalar fraction = oneByFraction < 1.0 ? 1.0 : 1.0/oneByFraction;
// Set the new value // Set the new value
operator==((1.0 - fraction)*p_old + fraction*p_new); operator==(lerp(p_old, p_new, fraction));
fixedValueFvPatchScalarField::updateCoeffs(); fixedValueFvPatchScalarField::updateCoeffs();
} }

7
src/finiteVolume/fields/fvPatchFields/derived/pressureDirectedInletOutletVelocity/pressureDirectedInletOutletVelocityFvPatchVectorField.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2017-2020 OpenCFD Ltd. Copyright (C) 2017-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -176,7 +176,7 @@ void Foam::pressureDirectedInletOutletVelocityFvPatchVectorField::updateCoeffs()
<< exit(FatalError); << exit(FatalError);
} }
valueFraction() = 1.0 - pos0(phip); valueFraction() = neg(phip);
mixedFvPatchVectorField::updateCoeffs(); mixedFvPatchVectorField::updateCoeffs();
} }
@ -204,8 +204,7 @@ void Foam::pressureDirectedInletOutletVelocityFvPatchVectorField::operator=
{ {
fvPatchField<vector>::operator= fvPatchField<vector>::operator=
( (
valueFraction()*(inletDir_*(inletDir_ & pvf)) lerp(pvf, inletDir_*(inletDir_ & pvf), valueFraction())
+ (1 - valueFraction())*pvf
); );
} }

2
src/finiteVolume/fields/fvPatchFields/derived/pressureInletOutletParSlipVelocity/pressureInletOutletParSlipVelocityFvPatchVectorField.C
View File

@ -150,7 +150,7 @@ void Foam::pressureInletOutletParSlipVelocityFvPatchVectorField::updateCoeffs()
<< exit(FatalError); << exit(FatalError);
} }
valueFraction() = 1.0 - pos0(phip); valueFraction() = neg(phip);
mixedFvPatchVectorField::updateCoeffs(); mixedFvPatchVectorField::updateCoeffs();
} }

9
src/finiteVolume/fields/fvPatchFields/derived/pressureNormalInletOutletVelocity/pressureNormalInletOutletVelocityFvPatchVectorField.C
View File

@ -6,7 +6,7 @@
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2011-2017 OpenFOAM Foundation Copyright (C) 2011-2017 OpenFOAM Foundation
Copyright (C) 2017-2020 OpenCFD Ltd. Copyright (C) 2017-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -146,7 +146,7 @@ void Foam::pressureNormalInletOutletVelocityFvPatchVectorField::updateCoeffs()
<< exit(FatalError); << exit(FatalError);
} }
valueFraction() = 1.0 - pos0(phip); valueFraction() = neg(phip);
mixedFvPatchVectorField::updateCoeffs(); mixedFvPatchVectorField::updateCoeffs();
} }
@ -171,10 +171,11 @@ void Foam::pressureNormalInletOutletVelocityFvPatchVectorField::operator=
const fvPatchField<vector>& pvf const fvPatchField<vector>& pvf
) )
{ {
tmp<vectorField> n = patch().nf();
fvPatchField<vector>::operator= fvPatchField<vector>::operator=
( (
valueFraction()*(patch().nf()*(patch().nf() & pvf)) lerp(pvf, n()*(n() & pvf), valueFraction())
+ (1 - valueFraction())*pvf
); );
} }

7
src/finiteVolume/fields/fvPatchFields/derived/pressurePermeableAlphaInletOutletVelocity/pressurePermeableAlphaInletOutletVelocityFvPatchVectorField.C
View File

@ -5,7 +5,7 @@
\\ / A nd | www.openfoam.com \\ / A nd | www.openfoam.com
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
Copyright (C) 2021 OpenCFD Ltd. Copyright (C) 2021-2023 OpenCFD Ltd.
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
This file is part of OpenFOAM. This file is part of OpenFOAM.
@ -155,7 +155,7 @@ updateCoeffs()
<< exit(FatalError); << exit(FatalError);
} }
valueFraction() = 1.0 - pos0(phip); valueFraction() = neg(phip);
if (alphaName_ != "none") if (alphaName_ != "none")
{ {
@ -202,8 +202,7 @@ void Foam::pressurePermeableAlphaInletOutletVelocityFvPatchVectorField
fvPatchField<vector>::operator= fvPatchField<vector>::operator=
( (
valueFraction()*(n()*(n() & pvf)) lerp(pvf, n()*(n() & pvf), valueFraction())
+ (1 - valueFraction())*pvf
); );
} }

2
src/finiteVolume/fields/fvPatchFields/derived/prghPermeableAlphaTotalPressure/prghPermeableAlphaTotalPressureFvPatchScalarField.C
View File

@ -215,7 +215,7 @@ void Foam::prghPermeableAlphaTotalPressureFvPatchScalarField::updateSnGrad
tmp<scalarField> p tmp<scalarField> p
( (
p0_->value(t) p0_->value(t)
- 0.5*rhop*(1.0 - pos0(phip))*magSqr(Up) - 0.5*rhop*(neg(phip))*magSqr(Up)
- rhop*((g.value() & patch().Cf()) - ghRef.value()) - rhop*((g.value() & patch().Cf()) - ghRef.value())
); );

2
src/finiteVolume/fields/fvPatchFields/derived/prghTotalHydrostaticPressure/prghTotalHydrostaticPressureFvPatchScalarField.C
View File

@ -136,7 +136,7 @@ void Foam::prghTotalHydrostaticPressureFvPatchScalarField::updateCoeffs()
operator== operator==
( (
ph_rghp ph_rghp
- 0.5*rhop*(1.0 - pos0(phip))*magSqr(Up) - 0.5*rhop*(neg(phip))*magSqr(Up)
); );
fixedValueFvPatchScalarField::updateCoeffs(); fixedValueFvPatchScalarField::updateCoeffs();

2
src/finiteVolume/fields/fvPatchFields/derived/prghTotalPressure/prghTotalPressureFvPatchScalarField.C
View File

@ -178,7 +178,7 @@ void Foam::prghTotalPressureFvPatchScalarField::updateCoeffs()
operator== operator==
( (
p0_ p0_
- 0.5*rhop*(1.0 - pos0(phip))*magSqr(Up) - 0.5*rhop*(neg(phip))*magSqr(Up)
- rhop*((g.value() & patch().Cf()) - ghRef.value()) - rhop*((g.value() & patch().Cf()) - ghRef.value())
); );

8
src/finiteVolume/fields/fvPatchFields/derived/totalPressure/totalPressureFvPatchScalarField.C
View File

@ -178,7 +178,7 @@ void Foam::totalPressureFvPatchScalarField::updateCoeffs
const auto& rho = const auto& rho =
patch().lookupPatchField<volScalarField>(rhoName_); patch().lookupPatchField<volScalarField>(rhoName_);
operator==(p0p - 0.5*rho*(1.0 - pos0(phip))*magSqr(Up)); operator==(p0p - 0.5*rho*(neg(phip))*magSqr(Up));
} }
else else
{ {
@ -196,14 +196,14 @@ void Foam::totalPressureFvPatchScalarField::updateCoeffs
p0p p0p
/pow /pow
( (
(1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up)), (1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up)),
1.0/gM1ByG 1.0/gM1ByG
) )
); );
} }
else else
{ {
operator==(p0p/(1.0 + 0.5*psip*(1.0 - pos0(phip))*magSqr(Up))); operator==(p0p/(1.0 + 0.5*psip*(neg(phip))*magSqr(Up)));
} }
} }
@ -211,7 +211,7 @@ void Foam::totalPressureFvPatchScalarField::updateCoeffs
else if (internalField().dimensions() == dimPressure/dimDensity) else if (internalField().dimensions() == dimPressure/dimDensity)
{ {
// Incompressible flow // Incompressible flow
operator==(p0p - 0.5*(1.0 - pos0(phip))*magSqr(Up)); operator==(p0p - 0.5*(neg(phip))*magSqr(Up));
} }
else else
{ {

2
src/finiteVolume/fields/fvPatchFields/derived/totalTemperature/totalTemperatureFvPatchScalarField.C
View File

@ -170,7 +170,7 @@ void Foam::totalTemperatureFvPatchScalarField::updateCoeffs()
operator== operator==
( (
T0_/(1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up)) T0_/(1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up))
); );
fixedValueFvPatchScalarField::updateCoeffs(); fixedValueFvPatchScalarField::updateCoeffs();

2
src/finiteVolume/fields/fvPatchFields/derived/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C
View File

@ -140,7 +140,7 @@ updateCoeffs()
patch().lookupPatchField<surfaceScalarField>(this->phiName_); patch().lookupPatchField<surfaceScalarField>(this->phiName_);
this->refValue() = 1.5*sqr(intensity_)*magSqr(Up); this->refValue() = 1.5*sqr(intensity_)*magSqr(Up);
this->valueFraction() = 1.0 - pos0(phip); this->valueFraction() = neg(phip);
inletOutletFvPatchScalarField::updateCoeffs(); inletOutletFvPatchScalarField::updateCoeffs();
} }

2
src/finiteVolume/fields/fvPatchFields/derived/uniformInletOutlet/uniformInletOutletFvPatchField.C
View File

@ -157,7 +157,7 @@ void Foam::uniformInletOutletFvPatchField<Type>::updateCoeffs()
phiName_ phiName_
); );
this->valueFraction() = 1.0 - pos0(phip); this->valueFraction() = neg(phip);
mixedFvPatchField<Type>::updateCoeffs(); mixedFvPatchField<Type>::updateCoeffs();
} }

8
src/finiteVolume/fields/fvPatchFields/derived/uniformTotalPressure/uniformTotalPressureFvPatchScalarField.C
View File

@ -166,7 +166,7 @@ void Foam::uniformTotalPressureFvPatchScalarField::updateCoeffs
const auto& rho = const auto& rho =
patch().lookupPatchField<volScalarField>(rhoName_); patch().lookupPatchField<volScalarField>(rhoName_);
operator==(p0 - 0.5*rho*(1.0 - pos0(phip))*magSqr(Up)); operator==(p0 - 0.5*rho*(neg(phip))*magSqr(Up));
} }
else else
{ {
@ -184,14 +184,14 @@ void Foam::uniformTotalPressureFvPatchScalarField::updateCoeffs
p0 p0
/pow /pow
( (
(1.0 + 0.5*psip*gM1ByG*(1.0 - pos0(phip))*magSqr(Up)), (1.0 + 0.5*psip*gM1ByG*(neg(phip))*magSqr(Up)),
1.0/gM1ByG 1.0/gM1ByG
) )
); );
} }
else else
{ {
operator==(p0/(1.0 + 0.5*psip*(1.0 - pos0(phip))*magSqr(Up))); operator==(p0/(1.0 + 0.5*psip*(neg(phip))*magSqr(Up)));
} }
} }
@ -199,7 +199,7 @@ void Foam::uniformTotalPressureFvPatchScalarField::updateCoeffs
else if (internalField().dimensions() == dimPressure/dimDensity) else if (internalField().dimensions() == dimPressure/dimDensity)
{ {
// Incompressible flow // Incompressible flow
operator==(p0 - 0.5*(1.0 - pos0(phip))*magSqr(Up)); operator==(p0 - 0.5*(neg(phip))*magSqr(Up));
} }
else else
{ {

Some files were not shown because too many files have changed in this diff Show More