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

ENH: update field function macros and 'reuse' field handling

Browse Source 
- clearer, more consistent parameter naming, which helps when
  maintaining different field function types (eg, DimensionedFields,
  GeometricFields)

- provide reuseTmpGeometricField::New taking a reference (not a tmp),
  with forwarding. This helps centralise naming and acquisition etc

- split binary function macros into transform/interface
  for easier support of different transform loops.

- initial field macros for looping over ternaries
This commit is contained in:
Mark Olesen
2023-01-19 09:40:26 +01:00
parent 3d8a6a5433
commit 6f68ce5239
21 changed files with 2292 additions and 2233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -36,32 +36,27 @@ License
namespace Foam
{
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type, class GeoMesh, direction r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow
(
const DimensionedField<Type, GeoMesh>& df,
const DimensionedField<Type, GeoMesh>& f1,
typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
typedef typename powProduct<Type, r>::type resultType;
auto tres =
tmp<DimensionedField<powProductType, GeoMesh>>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
IOobject
(
"pow(" + df.name() + ',' + name(r) + ')',
df.instance(),
df.db()
),
df.mesh(),
pow(df.dimensions(), r)
f1,
"pow(" + f1.name() + ',' + Foam::name(r) + ')',
pow(f1.dimensions(), r)
);
pow<Type, r, GeoMesh>(tres.ref().field(), df.field());
pow<Type, r, GeoMesh>(tres.ref().field(), f1.field());
return tres;
}
@ -71,166 +66,151 @@ template<class Type, class GeoMesh, direction r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow
(
const tmp<DimensionedField<Type, GeoMesh>>& tdf,
const tmp<DimensionedField<Type, GeoMesh>>& tf1,
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 =
reuseTmpDimensionedField<powProductType, Type, GeoMesh>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
tdf,
"pow(" + df.name() + ',' + name(r) + ')',
pow(df.dimensions(), r)
tf1,
"pow(" + f1.name() + ',' + Foam::name(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;
}
template<class Type, class 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 =
tmp<DimensionedField<outerProductType, GeoMesh>>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
IOobject
(
"sqr(" + df.name() + ')',
df.instance(),
df.db()
),
df.mesh(),
sqr(df.dimensions())
f1,
"sqr(" + f1.name() + ')',
sqr(f1.dimensions())
);
sqr(tres.ref().field(), df.field());
sqr(tres.ref().field(), f1.field());
return tres;
}
template<class Type, class 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 =
reuseTmpDimensionedField<outerProductType, Type, GeoMesh>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
tdf,
"sqr(" + df.name() + ')',
sqr(df.dimensions())
tf1,
"sqr(" + f1.name() + ')',
sqr(f1.dimensions())
);
sqr(tres.ref().field(), df.field());
sqr(tres.ref().field(), f1.field());
tdf.clear();
tf1.clear();
return tres;
}
template<class Type, class 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 =
tmp<DimensionedField<magType, GeoMesh>>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
IOobject
(
"magSqr(" + df.name() + ')',
df.instance(),
df.db()
),
df.mesh(),
sqr(df.dimensions())
f1,
"magSqr(" + f1.name() + ')',
sqr(f1.dimensions())
);
magSqr(tres.ref().field(), df.field());
magSqr(tres.ref().field(), f1.field());
return tres;
}
template<class Type, class 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 =
reuseTmpDimensionedField<magType, Type, GeoMesh>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
tdf,
"magSqr(" + df.name() + ')',
sqr(df.dimensions())
tf1,
"magSqr(" + f1.name() + ')',
sqr(f1.dimensions())
);
magSqr(tres.ref().field(), df.field());
magSqr(tres.ref().field(), f1.field());
tdf.clear();
tf1.clear();
return tres;
}
template<class Type, class 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 =
tmp<DimensionedField<magType, GeoMesh>>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
IOobject
(
"mag(" + df.name() + ')',
df.instance(),
df.db()
),
df.mesh(),
df.dimensions()
f1,
"mag(" + f1.name() + ')',
f1.dimensions()
);
mag(tres.ref().field(), df.field());
mag(tres.ref().field(), f1.field());
return tres;
}
template<class Type, class 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 =
reuseTmpDimensionedField<magType, Type, GeoMesh>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
tdf,
"mag(" + df.name() + ')',
df.dimensions()
tf1,
"mag(" + f1.name() + ')',
f1.dimensions()
);
mag(tres.ref().field(), df.field());
mag(tres.ref().field(), f1.field());
tdf.clear();
tf1.clear();
return tres;
}
@ -243,24 +223,19 @@ tmp
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 =
tmp<DimensionedField<cmptType, GeoMesh>>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
IOobject
(
"cmptAv(" + df.name() + ')',
df.instance(),
df.db()
),
df.mesh(),
df.dimensions()
f1,
"cmptAv(" + f1.name() + ')',
f1.dimensions()
);
cmptAv(tres.ref().field(), df.field());
cmptAv(tres.ref().field(), f1.field());
return tres;
}
@ -274,51 +249,51 @@ tmp
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 =
reuseTmpDimensionedField<cmptType, Type, GeoMesh>::New
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New
(
tdf,
"cmptAv(" + df.name() + ')',
df.dimensions()
tf1,
"cmptAv(" + f1.name() + ')',
f1.dimensions()
);
cmptAv(tres.ref().field(), df.field());
cmptAv(tres.ref().field(), f1.field());
tdf.clear();
tf1.clear();
return tres;
}
#define UNARY_REDUCTION_FUNCTION(returnType, func, dfunc) \
#define UNARY_REDUCTION_FUNCTION(ReturnType, Func, gFunc) \
\
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() + ')', \
df.dimensions(), \
dfunc(df.field()) \
#Func "(" + f1.name() + ')', \
f1.dimensions(), \
gFunc(f1.field()) \
); \
} \
\
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()); \
tdf1.clear(); \
dimensioned<ReturnType> res = Func(tf1()); \
tf1.clear(); \
return res; \
}
@ -347,7 +322,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clip)
// * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
UNARY_OPERATOR(Type, Type, -, negate, transform)
@ -363,32 +338,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> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
typedef typename product<Type1, Type2>::type resultType; \
\
auto tres = \
tmp<DimensionedField<productType, GeoMesh>>::New \
reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New \
( \
IOobject \
( \
'(' + df1.name() + #op + df2.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
df1.dimensions() op df2.dimensions() \
f1, \
'(' + f1.name() + #Op + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::opFunc(tres.ref().field(), df1.field(), df2.field()); \
Foam::OpFunc(tres.ref().field(), f1.field(), f2.field()); \
\
return tres; \
} \
@ -396,113 +366,108 @@ operator op \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const DimensionedField<Type1, GeoMesh>& f1, \
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 = \
reuseTmpDimensionedField<productType, Type2, GeoMesh>::New \
reuseTmpDimensionedField<resultType, Type2, GeoMesh>::New \
( \
tdf2, \
'(' + df1.name() + #op + df2.name() + ')', \
df1.dimensions() op df2.dimensions() \
tf2, \
'(' + f1.name() + #Op + f2.name() + ')', \
(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; \
} \
\
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
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 = \
reuseTmpDimensionedField<productType, Type1, GeoMesh>::New \
reuseTmpDimensionedField<resultType, Type1, GeoMesh>::New \
( \
tdf1, \
'(' + df1.name() + #op + df2.name() + ')', \
df1.dimensions() op df2.dimensions() \
tf1, \
'(' + f1.name() + #Op + f2.name() + ')', \
(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; \
} \
\
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
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 DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
const auto& f1 = tf1(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpTmpDimensionedField \
<productType, Type1, Type1, Type2, GeoMesh>::New \
<resultType, Type1, Type1, Type2, GeoMesh>::New \
( \
tdf1, \
tdf2, \
'(' + df1.name() + #op + df2.name() + ')', \
df1.dimensions() op df2.dimensions() \
tf1, \
tf2, \
'(' + f1.name() + #Op + f2.name() + ')', \
(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(); \
tdf2.clear(); \
tf1.clear(); \
tf2.clear(); \
return tres; \
} \
\
\
template<class Form, class Type, class 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 \
) \
{ \
typedef typename product<Type, Form>::type productType; \
typedef typename product<Type, Form>::type resultType; \
\
auto tres = \
tmp<DimensionedField<productType, GeoMesh>>::New \
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \
IOobject \
( \
'(' + df1.name() + #op + dvs.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
df1.dimensions() op dvs.dimensions() \
f1, \
'(' + f1.name() + #Op + dvs.name() + ')', \
(f1.dimensions() Op dvs.dimensions()) \
); \
\
Foam::opFunc(tres.ref().field(), df1.field(), dvs.value()); \
Foam::OpFunc(tres.ref().field(), f1.field(), dvs.value()); \
\
return tres; \
} \
@ -510,79 +475,74 @@ operator op \
\
template<class Form, class Cmpt, direction nCmpt, class Type, class 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 \
) \
{ \
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> \
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 \
) \
{ \
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 = \
reuseTmpDimensionedField<productType, Type, GeoMesh>::New \
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \
tdf1, \
'(' + df1.name() + #op + dvs.name() + ')', \
df1.dimensions() op dvs.dimensions() \
tf1, \
'(' + f1.name() + #Op + dvs.name() + ')', \
(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; \
} \
\
\
template<class Form, class Cmpt, direction nCmpt, class Type, class 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 \
) \
{ \
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> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
operator Op \
( \
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 = \
tmp<DimensionedField<productType, GeoMesh>>::New \
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \
IOobject \
( \
'(' + dvs.name() + #op + df1.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
dvs.dimensions() op df1.dimensions() \
f2, \
'(' + dvs.name() + #Op + f2.name() + ')', \
(dvs.dimensions() Op f2.dimensions()) \
); \
\
Foam::opFunc(tres.ref().field(), dvs.value(), df1.field()); \
Foam::OpFunc(tres.ref().field(), dvs.value(), f2.field()); \
\
return tres; \
} \
@ -590,52 +550,52 @@ operator op \
\
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
operator Op \
( \
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> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
operator Op \
( \
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 = \
reuseTmpDimensionedField<productType, Type, GeoMesh>::New \
reuseTmpDimensionedField<resultType, Type, GeoMesh>::New \
( \
tdf1, \
'(' + dvs.name() + #op + df1.name() + ')', \
dvs.dimensions() op df1.dimensions() \
tf2, \
'(' + dvs.name() + #Op + f2.name() + ')', \
(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; \
} \
\
\
template<class Form, class Cmpt, direction nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
operator Op \
( \
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; \
}

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

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

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -33,27 +33,32 @@ License
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
\
TEMPLATE \
void Func \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1 \
) \
{ \
/* TBD: reset dimensions? */ \
Func(result.field(), f1.field()); \
result.oriented() = Dfunc(f1.oriented()); \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1 \
const DimensionedField<Type1, GeoMesh>& f1 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + df1.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
Dfunc(df1.dimensions()) \
f1, \
#Func "(" + f1.name() + ')', \
Dfunc(f1.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field()); \
tres.ref().oriented() = Dfunc(df1.oriented()); \
\
Foam::Func(tres.ref(), f1); \
return tres; \
} \
\
@ -61,23 +66,21 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
tdf1, \
#Func "(" + df1.name() + ')', \
Dfunc(df1.dimensions()) \
tf1, \
#Func "(" + f1.name() + ')', \
Dfunc(f1.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field()); \
tres.ref().oriented() = Dfunc(df1.oriented()); \
\
tdf1.clear(); \
Foam::Func(tres.ref(), f1); \
tf1.clear(); \
return tres; \
}
@ -87,27 +90,32 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc) \
\
TEMPLATE \
void OpFunc \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1 \
) \
{ \
/* TBD: reset dimensions? */ \
Foam::OpFunc(result.field(), f1.field()); \
result.oriented() = Dfunc(f1.oriented()); \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1 \
const DimensionedField<Type1, GeoMesh>& f1 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
IOobject \
( \
#Op + df1.name(), \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
Dfunc(df1.dimensions()) \
f1, \
#Op + f1.name(), \
Dfunc(f1.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), df1.field()); \
tres.ref().oriented() = Dfunc(df1.oriented()); \
\
Foam::OpFunc(tres.ref(), f1); \
return tres; \
} \
\
@ -115,23 +123,21 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
tdf1, \
#Op + df1.name(), \
Dfunc(df1.dimensions()) \
tf1, \
#Op + f1.name(), \
Dfunc(f1.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), df1.field()); \
tres.ref().oriented() = Dfunc(df1.oriented()); \
\
tdf1.clear(); \
Foam::OpFunc(tres.ref(), f1); \
tf1.clear(); \
return tres; \
}
@ -141,28 +147,34 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
void Func \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
/* TBD: reset dimensions? */ \
Foam::Func(result.field(), f1.field(), f2.field()); \
result.oriented() = Func(f1.oriented(), f2.oriented()); \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + df1.name() + ',' + df2.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
Func(df1.dimensions(), df2.dimensions()) \
f1, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
\
Foam::Func(tres.ref(), f1, f2); \
return tres; \
} \
\
@ -170,24 +182,22 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
tdf2, \
#Func "(" + df1.name() + ',' + df2.name() + ')', \
Func(df1.dimensions(), df2.dimensions()) \
tf2, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
\
tdf2.clear(); \
Foam::Func(tres.ref(), f1, f2); \
tf2.clear(); \
return tres; \
} \
\
@ -195,26 +205,22 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const auto& f1 = tf1(); \
\
tmp<DimensionedField<ReturnType, GeoMesh>> tres \
( \
auto tres = \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
tdf1, \
#Func "(" + df1.name() + ',' + df2.name() + ')', \
Func(df1.dimensions(), df2.dimensions()) \
) \
); \
tf1, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
\
tdf1.clear(); \
Foam::Func(tres.ref(), f1, f2); \
tf1.clear(); \
return tres; \
} \
\
@ -222,28 +228,26 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
const auto& f1 = tf1(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpTmpDimensionedField \
<ReturnType, Type1, Type1, Type2, GeoMesh>::New \
( \
tdf1, \
tdf2, \
#Func "(" + df1.name() + ',' + df2.name() + ')', \
Func(df1.dimensions(), df2.dimensions()) \
tf1, \
tf2, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = Func(df1.oriented(), df2.oriented()); \
\
tdf1.clear(); \
tdf2.clear(); \
Foam::Func(tres.ref(), f1, f2); \
tf1.clear(); \
tf2.clear(); \
return tres; \
}
@ -253,28 +257,34 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
void Func \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
/* TBD: reset dimensions? */ \
Func(result.field(), dt1.value(), f2.field()); \
result.oriented() = f2.oriented(); \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + dt1.name() + ',' + df2.name() + ')', \
df2.instance(), \
df2.db() \
), \
df2.mesh(), \
Func(dt1.dimensions(), df2.dimensions()) \
f2, \
#Func "(" + dt1.name() + ',' + f2.name() + ')', \
Func(dt1.dimensions(), f2.dimensions()) \
); \
\
Func(tres.ref().field(), dt1.value(), df2.field()); \
tres.ref().oriented() = df2.oriented(); \
\
Foam::Func(tres.ref(), dt1, f2); \
return tres; \
} \
\
@ -282,11 +292,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const Type1& s1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
return Func(dimensioned<Type1>(t1), df2); \
return Foam::Func(dimensioned<Type1>(s1), f2); \
} \
\
\
@ -294,63 +304,66 @@ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
tdf2, \
#Func "(" + dt1.name() + ',' + df2.name() + ')', \
Func(dt1.dimensions(), df2.dimensions()) \
tf2, \
#Func "(" + dt1.name() + ',' + f2.name() + ')', \
Func(dt1.dimensions(), f2.dimensions()) \
); \
\
Func(tres.ref().field(), dt1.value(), df2.field()); \
tres.ref().oriented() = df2.oriented(); \
\
tdf2.clear(); \
Foam::Func(tres.ref(), dt1, f2); \
tf2.clear(); \
return tres; \
} \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const Type1& s1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
return Func(dimensioned<Type2>(t1), tdf2); \
return Foam::Func(dimensioned<Type2>(s1), tf2); \
}
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
void Func \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
/* TBD: reset dimensions? */ \
Func(result.field(), f1.field(), dt2.value()); \
result.oriented() = f1.oriented(); \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + df1.name() + ',' + dt2.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
Func(df1.dimensions(), dt2.dimensions()) \
f1, \
#Func "(" + f1.name() + ',' + dt2.name() + ')', \
Func(f1.dimensions(), dt2.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field(), dt2.value()); \
tres.ref().oriented() = df1.oriented(); \
\
Foam::Func(tres.ref(), f1, dt2); \
return tres; \
} \
\
@ -358,35 +371,33 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const Type2& s2 \
) \
{ \
return Func(df1, dimensioned<Type2>(t2)); \
return Foam::Func(f1, dimensioned<Type2>(s2)); \
} \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
tdf1, \
#Func "(" + df1.name() + ',' + dt2.name() + ')', \
Func(df1.dimensions(), dt2.dimensions()) \
tf1, \
#Func "(" + f1.name() + ',' + dt2.name() + ')', \
Func(f1.dimensions(), dt2.dimensions()) \
); \
\
Func(tres.ref().field(), df1.field(), dt2.value()); \
tres.ref().oriented() = df1.oriented(); \
\
tdf1.clear(); \
Foam::Func(tres.ref(), f1, dt2); \
tf1.clear(); \
return tres; \
} \
\
@ -394,11 +405,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const Type2& t2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const Type2& s2 \
) \
{ \
return Func(tdf1, dimensioned<Type2>(t2)); \
return Foam::Func(tf1, dimensioned<Type2>(s2)); \
}
@ -412,28 +423,35 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
void OpFunc \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
/* TBD: reset dimensions? */ \
Foam::OpFunc(result.field(), f1.field(), f2.field()); \
result.oriented() = f1.oriented() Op f2.oriented(); \
} \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
IOobject \
( \
'(' + df1.name() + OpName + df2.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
df1.dimensions() Op df2.dimensions() \
f1, \
'(' + f1.name() + OpName + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
\
Foam::OpFunc(tres.ref(), f1, f2); \
return tres; \
} \
\
@ -441,24 +459,22 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
tdf2, \
'(' + df1.name() + OpName + df2.name() + ')', \
df1.dimensions() Op df2.dimensions() \
tf2, \
'(' + f1.name() + OpName + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
\
tdf2.clear(); \
Foam::OpFunc(tres.ref(), f1, f2); \
tf2.clear(); \
return tres; \
} \
\
@ -466,53 +482,48 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
tdf1, \
'(' + df1.name() + OpName + df2.name() + ')', \
df1.dimensions() Op df2.dimensions() \
tf1, \
'(' + f1.name() + OpName + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
\
tdf1.clear(); \
Foam::OpFunc(tres.ref(), f1, f2); \
tf1.clear(); \
return tres; \
} \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
const auto& f1 = tf1(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpTmpDimensionedField \
<ReturnType, Type1, Type1, Type2, GeoMesh>::New \
( \
tdf1, \
tdf2, \
'(' + df1.name() + OpName + df2.name() + ')', \
df1.dimensions() Op df2.dimensions() \
tf1, \
tf2, \
'(' + f1.name() + OpName + f2.name() + ')', \
f1.dimensions() Op f2.dimensions() \
); \
\
Foam::OpFunc(tres.ref().field(), df1.field(), df2.field()); \
tres.ref().oriented() = df1.oriented() Op df2.oriented(); \
\
tdf1.clear(); \
tdf2.clear(); \
Foam::OpFunc(tres.ref(), f1, f2); \
tf1.clear(); \
tf2.clear(); \
return tres; \
}
@ -522,29 +533,34 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
void OpFunc \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
/* TBD: reset dimensions? */ \
Foam::OpFunc(result.field(), dt1.value(), f2.field()); \
result.oriented() = f2.oriented(); \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
IOobject \
( \
'(' + dt1.name() + OpName + df2.name() + ')', \
df2.instance(), \
df2.db() \
), \
df2.mesh(), \
dt1.dimensions() Op df2.dimensions() \
f2, \
'(' + dt1.name() + OpName + f2.name() + ')', \
(dt1.dimensions() Op f2.dimensions()) \
); \
\
tres.ref().oriented() = df2.oriented(); \
\
Foam::OpFunc(tres.ref().field(), dt1.value(), df2.field()); \
\
Foam::OpFunc(tres.ref(), dt1, f2); \
return tres; \
} \
\
@ -552,11 +568,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const Type1& s1, \
const DimensionedField<Type2, GeoMesh>& f2 \
) \
{ \
return dimensioned<Type1>(t1) Op df2; \
return dimensioned<Type1>(s1) Op f2; \
} \
\
\
@ -564,23 +580,21 @@ TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
tdf2, \
'(' + dt1.name() + OpName + df2.name() + ')', \
dt1.dimensions() Op df2.dimensions() \
tf2, \
'(' + dt1.name() + OpName + f2.name() + ')', \
(dt1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), dt1.value(), tdf2().field()); \
tres.ref().oriented() = df2.oriented(); \
\
tdf2.clear(); \
Foam::OpFunc(tres.ref(), dt1, f2); \
tf2.clear(); \
return tres; \
} \
\
@ -588,39 +602,45 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const Type1& s1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
) \
{ \
return dimensioned<Type1>(t1) Op tdf2; \
return dimensioned<Type1>(s1) Op tf2; \
}
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
void OpFunc \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
/* TBD: reset dimensions? */ \
Foam::OpFunc(result.field(), f1.field(), dt2.value()); \
result.oriented() = f1.oriented(); \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
auto tres = \
tmp<DimensionedField<ReturnType, GeoMesh>>::New \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
IOobject \
( \
'(' + df1.name() + OpName + dt2.name() + ')', \
df1.instance(), \
df1.db() \
), \
df1.mesh(), \
df1.dimensions() Op dt2.dimensions() \
f1, \
'(' + f1.name() + OpName + dt2.name() + ')', \
(f1.dimensions() Op dt2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), df1.field(), dt2.value()); \
tres.ref().oriented() = df1.oriented(); \
\
Foam::OpFunc(tres.ref(), f1, dt2); \
return tres; \
} \
\
@ -628,35 +648,33 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const Type2& s2 \
) \
{ \
return df1 Op dimensioned<Type2>(t2); \
return f1 Op dimensioned<Type2>(s2); \
} \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
tdf1, \
'(' + df1.name() + OpName + dt2.name() + ')', \
df1.dimensions() Op dt2.dimensions() \
tf1, \
'(' + f1.name() + OpName + dt2.name() + ')', \
(f1.dimensions() Op dt2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref().field(), tdf1().field(), dt2.value()); \
tres.ref().oriented() = df1.oriented(); \
\
tdf1.clear(); \
Foam::OpFunc(tres.ref(), f1, dt2); \
tf1.clear(); \
return tres; \
} \
\
@ -664,11 +682,11 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const Type2& t2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
const Type2& s2 \
) \
{ \
return tdf1 Op dimensioned<Type2>(t2); \
return tf1 Op dimensioned<Type2>(s2); \
}
#define BINARY_TYPE_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \

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

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -30,32 +31,46 @@ License
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
void Func \
( \
const DimensionedField<Type1, GeoMesh>& df \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1 \
); \
\
TEMPLATE \
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 \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
void OpFunc \
( \
const DimensionedField<Type1, GeoMesh>& df1 \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1 \
); \
\
TEMPLATE \
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) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
void Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
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) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
void Func \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const Type1& s1, \
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) \
\
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 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf2, \
const Type2& t2 \
const DimensionedField<Type1, GeoMesh>& f1, \
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) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
void OpFunc \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
DimensionedField<ReturnType, GeoMesh>& result, \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type1, GeoMesh>& f1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tf1, \
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) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
void OpFunc \
( \
DimensionedField<ReturnType, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const DimensionedField<Type2, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
const Type1& s1, \
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) \
\
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 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type1, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const Type2& t2 \
const DimensionedField<Type1, GeoMesh>& f1, \
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 \
);

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

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

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019-2022 OpenCFD Ltd.
Copyright (C) 2019-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -90,12 +90,9 @@ pow
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
(
FieldField<Field, powProductType>::NewCalculatedType(f)
);
auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
pow<Type, r>(tres.ref(), f);
return tres;
@ -108,12 +105,9 @@ pow
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
(
reuseTmpFieldField<Field, powProductType, Type>::New(tf)
);
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
pow<Type, r>(tres.ref(), tf());
tf.clear();
@ -140,11 +134,10 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const FieldField<Field, Type>& f)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
tmp<FieldField<Field, outerProductType>> tres
(
FieldField<Field, outerProductType>::NewCalculatedType(f)
);
typedef typename outerProduct<Type, Type>::type resultType;
auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
sqr(tres.ref(), f);
return tres;
}
@ -153,12 +146,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const tmp<FieldField<Field, Type>>& tf)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
typedef typename outerProduct<Type, Type>::type resultType;
auto tres
(
reuseTmpFieldField<Field, outerProductType, Type>::New(tf)
);
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
sqr(tres.ref(), tf());
tf.clear();
@ -185,12 +175,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>>
magSqr(const FieldField<Field, Type>& f)
{
typedef typename typeOfMag<Type>::type magType;
typedef typename typeOfMag<Type>::type resultType;
auto tres
(
FieldField<Field, magType>::NewCalculatedType(f)
);
auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
magSqr(tres.ref(), f);
return tres;
@ -200,12 +187,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>>
magSqr(const tmp<FieldField<Field, Type>>& tf)
{
typedef typename typeOfMag<Type>::type magType;
typedef typename typeOfMag<Type>::type resultType;
auto tres
(
reuseTmpFieldField<Field, magType, Type>::New(tf)
);
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
magSqr(tres.ref(), tf());
tf.clear();
@ -232,12 +216,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>>
mag(const FieldField<Field, Type>& f)
{
typedef typename typeOfMag<Type>::type magType;
typedef typename typeOfMag<Type>::type resultType;
auto tres
(
FieldField<Field, magType>::NewCalculatedType(f)
);
auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
mag(tres.ref(), f);
return tres;
@ -247,12 +228,9 @@ template<template<class> class Field, class Type>
tmp<FieldField<Field, typename typeOfMag<Type>::type>>
mag(const tmp<FieldField<Field, Type>>& tf)
{
typedef typename typeOfMag<Type>::type magType;
typedef typename typeOfMag<Type>::type resultType;
auto tres
(
reuseTmpFieldField<Field, magType, Type>::New(tf)
);
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
mag(tres.ref(), tf());
tf.clear();
@ -281,12 +259,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
const FieldField<Field, Type>& f
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
cmptMax(tres.ref(), f);
return tres;
@ -298,12 +273,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
const tmp<FieldField<Field, Type>>& tf
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
cmptMax(tres.ref(), tf());
tf.clear();
@ -332,12 +304,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
const FieldField<Field, Type>& f
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
cmptMin(tres.ref(), f);
return tres;
@ -349,12 +318,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
const tmp<FieldField<Field, Type>>& tf
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
cmptMin(tres.ref(), tf());
tf.clear();
@ -383,12 +349,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
const FieldField<Field, Type>& f
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
auto tres = FieldField<Field, resultType>::NewCalculatedType(f);
cmptAv(tres.ref(), f);
return tres;
@ -400,12 +363,9 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
const tmp<FieldField<Field, Type>>& tf
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
typedef typename FieldField<Field, Type>::cmptType resultType;
auto tres
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf);
cmptAv(tres.ref(), tf());
tf.clear();
@ -434,10 +394,7 @@ tmp<FieldField<Field, Type>> cmptMag
const FieldField<Field, Type>& f
)
{
auto tres
(
FieldField<Field, Type>::NewCalculatedType(f)
);
auto tres = FieldField<Field, Type>::NewCalculatedType(f);
cmptMag(tres.ref(), f);
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> \
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(); \
return res; \
}
@ -529,9 +486,9 @@ TMP_UNARY_FUNCTION(Type, sum)
template<template<class> class Field, class Type>
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();
@ -609,12 +566,12 @@ TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
// 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> \
ReturnType gFunc(const FieldField<Field, Type>& f) \
{ \
ReturnType res = func(f); \
ReturnType res = Func(f); \
reduce(res, rFunc##Op<ReturnType>()); \
return res; \
} \
@ -653,7 +610,7 @@ Type gAverage(const FieldField<Field, Type>& f)
}
WarningInFunction
<< "empty fieldField, returning zero" << endl;
<< "Empty FieldField, returning zero" << endl;
return Zero;
}
@ -676,7 +633,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
/* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * */
UNARY_OPERATOR(Type, Type, -, negate)
@ -692,7 +649,7 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define PRODUCT_OPERATOR(product, op, opFunc) \
#define PRODUCT_OPERATOR(product, Op, OpFunc) \
\
template \
< \
@ -701,7 +658,7 @@ template \
class Type1, \
class Type2 \
> \
void opFunc \
void OpFunc \
( \
FieldField<Field1, typename product<Type1, Type2>::type>& f, \
const FieldField<Field1, Type1>& f1, \
@ -712,7 +669,7 @@ void opFunc \
\
for (label i = 0; i < loopLen; ++i) \
{ \
opFunc(f[i], f1[i], f2[i]); \
OpFunc(f[i], f1[i], f2[i]); \
} \
} \
\
@ -724,35 +681,29 @@ template \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
operator Op \
( \
const FieldField<Field1, Type1>& f1, \
const FieldField<Field2, Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType>> tres \
( \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), f1, f2); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = FieldField<Field1, resultType>::NewCalculatedType(f1); \
OpFunc(tres.ref(), f1, f2); \
return tres; \
} \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
operator op \
operator Op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field, productType>> tres \
( \
reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
); \
opFunc(tres.ref(), f1, tf2()); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmpFieldField<Field, resultType, Type2>::New(tf2); \
OpFunc(tres.ref(), f1, tf2()); \
tf2.clear(); \
return tres; \
} \
@ -765,18 +716,15 @@ template \
class Type2 \
> \
tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
operator op \
operator Op \
( \
const FieldField<Field1, Type1>& f1, \
const tmp<FieldField<Field2, Type2>>& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType>> tres \
( \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), f1, tf2()); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = FieldField<Field1, resultType>::NewCalculatedType(f1); \
OpFunc(tres.ref(), f1, tf2()); \
tf2.clear(); \
return tres; \
} \
@ -789,18 +737,15 @@ template \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
operator Op \
( \
const tmp<FieldField<Field1, Type1>>& tf1, \
const FieldField<Field2, Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType>> tres \
( \
reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \
); \
opFunc(tres.ref(), tf1(), f2); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmpFieldField<Field1, resultType, Type1>::New(tf1); \
OpFunc(tres.ref(), tf1(), f2); \
tf1.clear(); \
return tres; \
} \
@ -813,19 +758,19 @@ template \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
operator Op \
( \
const tmp<FieldField<Field1, Type1>>& tf1, \
const tmp<FieldField<Field2, Type2>>& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType>> tres \
typedef typename product<Type1, Type2>::type resultType; \
auto tres \
( \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New \
reuseTmpTmpFieldField<Field1, resultType, Type1, Type1, Type2>::New \
(tf1, tf2) \
); \
opFunc(tres.ref(), tf1(), tf2()); \
OpFunc(tres.ref(), tf1(), tf2()); \
tf1.clear(); \
tf2.clear(); \
return tres; \
@ -839,18 +784,18 @@ template \
class Cmpt, \
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 VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
const label loopLen = (f).size(); \
const label loopLen = (result).size(); \
\
for (label i = 0; i < loopLen; ++i) \
{ \
opFunc(f[i], f1[i], vs); \
OpFunc(result[i], f1[i], vs); \
} \
} \
\
@ -863,18 +808,15 @@ template \
direction nCmpt \
> \
tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \
operator Op \
( \
const FieldField<Field, Type>& f1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType>> tres \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \
typedef typename product<Type, Form>::type resultType; \
auto tres = FieldField<Field, resultType>::NewCalculatedType(f1); \
OpFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \
return tres; \
} \
\
@ -887,18 +829,15 @@ template \
direction nCmpt \
> \
tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \
operator Op \
( \
const tmp<FieldField<Field, Type>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType>> tres \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \
typedef typename product<Type, Form>::type resultType; \
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf1); \
OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \
tf1.clear(); \
return tres; \
} \
@ -911,18 +850,18 @@ template \
class Cmpt, \
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 FieldField<Field, Type>& f1 \
) \
{ \
const label loopLen = (f).size(); \
const label loopLen = (result).size(); \
\
for (label i = 0; i < loopLen; ++i) \
{ \
opFunc(f[i], vs, f1[i]); \
OpFunc(result[i], vs, f1[i]); \
} \
} \
\
@ -935,18 +874,15 @@ template \
direction nCmpt \
> \
tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \
operator Op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const FieldField<Field, Type>& f1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType>> tres \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
opFunc(tres.ref(), static_cast<const Form&>(vs), f1); \
typedef typename product<Form, Type>::type resultType; \
auto tres = FieldField<Field, resultType>::NewCalculatedType(f1); \
OpFunc(tres.ref(), static_cast<const Form&>(vs), f1); \
return tres; \
} \
\
@ -959,18 +895,15 @@ template \
direction nCmpt \
> \
tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \
operator Op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type>>& tf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType>> tres \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
opFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \
typedef typename product<Form, Type>::type resultType; \
auto tres = reuseTmpFieldField<Field, resultType, Type>::New(tf1); \
OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \
tf1.clear(); \
return tres; \
}

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

@ -290,7 +290,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
BINARY_TYPE_FUNCTION_FS(Type, Type, MinMax<Type>, clamp)
/* * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * */
UNARY_OPERATOR(Type, Type, -, negate)

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

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

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

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

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2022 OpenCFD Ltd.
Copyright (C) 2018-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -35,10 +35,21 @@ namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// One-parameter versions
template<template<class> class Field, class TypeR, class Type1>
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
(
const tmp<FieldField<Field, Type1>>& tf1
@ -52,6 +63,8 @@ struct reuseTmpFieldField
template<template<class> class Field, class 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
(
const tmp<FieldField<Field, TypeR>>& tf1,
@ -63,19 +76,19 @@ struct reuseTmpFieldField<Field, TypeR, TypeR>
return tf1;
}
auto rtf = FieldField<Field, TypeR>::NewCalculatedType(tf1());
auto tresult = FieldField<Field, TypeR>::NewCalculatedType(tf1());
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>
tmp<FieldField<Field, TypeR>> New
(
@ -87,6 +100,9 @@ tmp<FieldField<Field, TypeR>> New
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Two-parameter versions
template
<
template<class> class Field,
@ -97,6 +113,7 @@ template
>
struct reuseTmpTmpFieldField
{
//- Dissimilar types: just use size
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, Type1>>& tf1,
@ -111,6 +128,7 @@ struct reuseTmpTmpFieldField
template<template<class> class Field, class TypeR, class Type1, class Type12>
struct reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR>
{
//- Second input has return type
static tmp<FieldField<Field, TypeR>> New
(
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>
struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
{
//- First input has return type
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, TypeR>>& tf1,
@ -149,6 +168,7 @@ struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
template<template<class> class Field, class TypeR>
struct reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, TypeR>
{
//- Both inputs have return type
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, TypeR>>& tf1,

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

@ -42,38 +42,40 @@ namespace Foam
template<class Type>
void component
(
Field<typename Field<Type>::cmptType>& res,
const UList<Type>& f,
Field<typename Field<Type>::cmptType>& result,
const UList<Type>& f1,
const direction d
)
{
typedef typename Field<Type>::cmptType cmptType;
typedef typename Field<Type>::cmptType resultType;
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>
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>
void pow
(
Field<typename powProduct<Type, r>::type>& res,
const UList<Type>& vf
Field<typename powProduct<Type, r>::type>& result,
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
(
powProductType, res, =, pow, Type, vf, powProductType,
pTraits<powProductType>::zero
resultType, result, =, pow, Type, f1, resultType,
pTraits<resultType>::zero
)
}
@ -81,16 +83,13 @@ template<class Type, direction r>
tmp<Field<typename powProduct<Type, r>::type>>
pow
(
const UList<Type>& f,
const UList<Type>& f1,
typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
auto tres
(
tmp<Field<powProductType>>::New(f.size())
);
pow<Type, r>(tres.ref(), f);
typedef typename powProduct<Type, r>::type resultType;
auto tres = tmp<Field<resultType>>::New(f1.size());
pow<Type, r>(tres.ref(), f1);
return tres;
}
@ -98,14 +97,14 @@ template<class Type, direction r>
tmp<Field<typename powProduct<Type, r>::type>>
pow
(
const tmp<Field<Type>>& tf,
const tmp<Field<Type>>& tf1,
typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
auto tres = reuseTmp<powProductType, Type>::New(tf);
pow<Type, r>(tres.ref(), tf());
tf.clear();
typedef typename powProduct<Type, r>::type resultType;
auto tres = reuseTmp<resultType, Type>::New(tf1);
pow<Type, r>(tres.ref(), tf1());
tf1.clear();
return tres;
}
@ -113,35 +112,33 @@ pow
template<class Type>
void sqr
(
Field<typename outerProduct<Type, Type>::type>& res,
const UList<Type>& vf
Field<typename outerProduct<Type, Type>::type>& result,
const UList<Type>& f1
)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
TFOR_ALL_F_OP_FUNC_F(outerProductType, res, =, sqr, Type, vf)
typedef typename outerProduct<Type, Type>::type resultType;
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, sqr, Type, f1)
}
template<class 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;
auto tres
(
tmp<Field<outerProductType>>::New(f.size())
);
sqr(tres.ref(), f);
typedef typename outerProduct<Type, Type>::type resultType;
auto tres = tmp<Field<resultType>>::New(f1.size());
sqr(tres.ref(), f1);
return tres;
}
template<class 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;
auto tres = reuseTmp<outerProductType, Type>::New(tf);
sqr(tres.ref(), tf());
tf.clear();
typedef typename outerProduct<Type, Type>::type resultType;
auto tres = reuseTmp<resultType, Type>::New(tf1);
sqr(tres.ref(), tf1());
tf1.clear();
return tres;
}
@ -149,35 +146,35 @@ sqr(const tmp<Field<Type>>& tf)
template<class Type>
void magSqr
(
Field<typename typeOfMag<Type>::type>& res,
const UList<Type>& f
Field<typename typeOfMag<Type>::type>& result,
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>
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());
magSqr(tres.ref(), f);
auto tres = tmp<Field<resultType>>::New(f1.size());
magSqr(tres.ref(), f1);
return tres;
}
template<class 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);
magSqr(tres.ref(), tf());
tf.clear();
auto tres = reuseTmp<resultType, Type>::New(tf1);
magSqr(tres.ref(), tf1());
tf1.clear();
return tres;
}
@ -185,164 +182,179 @@ magSqr(const tmp<Field<Type>>& tf)
template<class Type>
void mag
(
Field<typename typeOfMag<Type>::type>& res,
const UList<Type>& f
Field<typename typeOfMag<Type>::type>& result,
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>
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());
mag(tres.ref(), f);
auto tres = tmp<Field<resultType>>::New(f1.size());
mag(tres.ref(), f1);
return tres;
}
template<class 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);
mag(tres.ref(), tf());
tf.clear();
auto tres = reuseTmp<resultType, Type>::New(tf1);
mag(tres.ref(), tf1());
tf1.clear();
return tres;
}
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;
TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMax, Type, f)
typedef typename Field<Type>::cmptType resultType;
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMax, Type, f1)
}
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;
auto tres = tmp<Field<cmptType>>::New(f.size());
cmptMax(tres.ref(), f);
typedef typename Field<Type>::cmptType resultType;
auto tres = tmp<Field<resultType>>::New(f1.size());
cmptMax(tres.ref(), f1);
return tres;
}
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;
auto tres = reuseTmp<cmptType, Type>::New(tf);
cmptMax(tres.ref(), tf());
tf.clear();
typedef typename Field<Type>::cmptType resultType;
auto tres = reuseTmp<resultType, Type>::New(tf1);
cmptMax(tres.ref(), tf1());
tf1.clear();
return tres;
}
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;
TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptMin, Type, f)
typedef typename Field<Type>::cmptType resultType;
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptMin, Type, f1)
}
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;
auto tres = tmp<Field<cmptType>>::New(f.size());
cmptMin(tres.ref(), f);
typedef typename Field<Type>::cmptType resultType;
auto tres = tmp<Field<resultType>>::New(f1.size());
cmptMin(tres.ref(), f1);
return tres;
}
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;
auto tres = reuseTmp<cmptType, Type>::New(tf);
cmptMin(tres.ref(), tf());
tf.clear();
typedef typename Field<Type>::cmptType resultType;
auto tres = reuseTmp<resultType, Type>::New(tf1);
cmptMin(tres.ref(), tf1());
tf1.clear();
return tres;
}
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;
TFOR_ALL_F_OP_FUNC_F(cmptType, res, =, cmptAv, Type, f)
typedef typename Field<Type>::cmptType resultType;
TFOR_ALL_F_OP_FUNC_F(resultType, result, =, cmptAv, Type, f1)
}
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;
auto tres = tmp<Field<cmptType>>::New(f.size());
cmptAv(tres.ref(), f);
typedef typename Field<Type>::cmptType resultType;
auto tres = tmp<Field<resultType>>::New(f1.size());
cmptAv(tres.ref(), f1);
return tres;
}
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;
auto tres = reuseTmp<cmptType, Type>::New(tf);
cmptAv(tres.ref(), tf());
tf.clear();
typedef typename Field<Type>::cmptType resultType;
auto tres = reuseTmp<resultType, Type>::New(tf1);
cmptAv(tres.ref(), tf1());
tf1.clear();
return tres;
}
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>
tmp<Field<Type>> cmptMag(const UList<Type>& f)
tmp<Field<Type>> cmptMag(const UList<Type>& f1)
{
auto tres = tmp<Field<Type>>::New(f.size());
cmptMag(tres.ref(), f);
auto tres = tmp<Field<Type>>::New(f1.size());
cmptMag(tres.ref(), f1);
return tres;
}
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);
cmptMag(tres.ref(), tf());
tf.clear();
auto tres = New(tf1);
cmptMag(tres.ref(), tf1());
tf1.clear();
return tres;
}
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>
tmp<Field<Type>> cmptMagSqr(const UList<Type>& f)
tmp<Field<Type>> cmptMagSqr(const UList<Type>& f1)
{
auto tres = tmp<Field<Type>>::New(f.size());
cmptMagSqr(tres.ref(), f);
auto tres = tmp<Field<Type>>::New(f1.size());
cmptMagSqr(tres.ref(), f1);
return tres;
}
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);
cmptMagSqr(tres.ref(), tf());
tf.clear();
auto tres = New(tf1);
cmptMagSqr(tres.ref(), tf1());
tf1.clear();
return tres;
}
@ -358,13 +370,13 @@ ReturnType Func(const tmp<Field<Type>>& tf1) \
}
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]);
TFOR_ALL_S_OP_FUNC_F_S(Type, Max, =, max, Type, f, Type, Max)
return Max;
Type result(f1[0]);
TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, max, Type, f1, Type, result)
return result;
}
return pTraits<Type>::min;
@ -373,13 +385,13 @@ Type max(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, max)
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]);
TFOR_ALL_S_OP_FUNC_F_S(Type, Min, =, min, Type, f, Type, Min)
return Min;
Type result(f1[0]);
TFOR_ALL_S_OP_FUNC_F_S(Type, result, =, min, Type, f1, Type, result)
return result;
}
return pTraits<Type>::max;
@ -388,18 +400,19 @@ Type min(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, min)
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)
@ -414,23 +427,23 @@ TMP_UNARY_FUNCTION(scalarMinMax, minMaxMag)
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
(
Type,
Max,
result,
=,
maxMagSqrOp<Type>(),
Type,
f,
f1,
Type,
Max
result
)
return Max;
return result;
}
return Zero;
@ -439,23 +452,23 @@ Type maxMagSqr(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, maxMagSqr)
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
(
Type,
Min,
result,
=,
minMagSqrOp<Type>(),
Type,
f,
f1,
Type,
Min
result
)
return Min;
return result;
}
return pTraits<Type>::rootMax;
@ -467,12 +480,12 @@ template<class Type>
typename scalarProduct<Type, Type>::type
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()))
{
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;
}
@ -502,37 +515,39 @@ Type sumCmptProd(const UList<Type>& f1, const UList<Type>& f2)
template<class Type>
typename outerProduct1<Type>::type
sumSqr(const UList<Type>& f)
sumSqr(const UList<Type>& f1)
{
typedef typename outerProduct1<Type>::type prodType;
prodType result = Zero;
if (f.size())
typedef typename outerProduct1<Type>::type resultType;
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;
}
template<class Type>
typename outerProduct1<Type>::type
sumSqr(const tmp<Field<Type>>& tf)
sumSqr(const tmp<Field<Type>>& tf1)
{
typedef typename outerProduct1<Type>::type prodType;
prodType result = sumSqr(tf());
tf.clear();
typedef typename outerProduct1<Type>::type resultType;
resultType result = sumSqr(tf1());
tf1.clear();
return result;
}
template<class Type>
typename typeOfMag<Type>::type
sumMag(const UList<Type>& f)
sumMag(const UList<Type>& f1)
{
typedef typename typeOfMag<Type>::type magType;
magType result = Zero;
if (f.size())
typedef typename typeOfMag<Type>::type resultType;
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;
}
@ -541,12 +556,12 @@ TMP_UNARY_FUNCTION(typename typeOfMag<Type>::type, sumMag)
template<class Type>
Type sumCmptMag(const UList<Type>& f)
Type sumCmptMag(const UList<Type>& f1)
{
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;
}
@ -554,13 +569,13 @@ Type sumCmptMag(const UList<Type>& f)
TMP_UNARY_FUNCTION(Type, sumCmptMag)
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
@ -608,10 +623,10 @@ typename scalarProduct<Type, Type>::type gSumProd
const label comm
)
{
typedef typename scalarProduct<Type, Type>::type prodType;
typedef typename scalarProduct<Type, Type>::type resultType;
prodType result = sumProd(f1, f2);
reduce(result, sumOp<prodType>(), UPstream::msgType(), comm);
resultType result = sumProd(f1, f2);
reduce(result, sumOp<resultType>(), UPstream::msgType(), comm);
return result;
}
@ -623,27 +638,27 @@ Type gSumCmptProd
const label comm
)
{
Type SumProd = sumCmptProd(f1, f2);
reduce(SumProd, sumOp<Type>(), UPstream::msgType(), comm);
return SumProd;
Type result = sumCmptProd(f1, f2);
reduce(result, sumOp<Type>(), UPstream::msgType(), comm);
return result;
}
template<class Type>
Type gAverage
(
const UList<Type>& f,
const UList<Type>& f1,
const label comm
)
{
label n = f.size();
Type s = sum(f);
label n = f1.size();
Type s = sum(f1);
sumReduce(s, n, UPstream::msgType(), comm);
if (n > 0)
{
Type avrg = s/n;
Type result = s/n;
return avrg;
return result;
}
WarningInFunction
@ -656,6 +671,8 @@ TMP_UNARY_FUNCTION(Type, gAverage)
#undef TMP_UNARY_FUNCTION
// Implement BINARY_FUNCTION_TRANSFORM_FS for clamp
template<class Type>
void clamp
(
@ -683,30 +700,7 @@ void clamp
}
}
template<class Type>
tmp<Field<Type>> clamp
(
const UList<Type>& f1,
const MinMax<Type>& range
)
{
auto tres = tmp<Field<Type>>::New(f1.size());
clamp(tres.ref(), f1, range);
return tres;
}
template<class Type>
tmp<Field<Type>> 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_INTERFACE_FS(Type, Type, MinMax<Type>, clamp)
BINARY_FUNCTION(Type, Type, Type, max)
@ -743,21 +737,21 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, divide)
template<class Type1, class Type2> \
void OpFunc \
( \
Field<typename product<Type1, Type2>::type>& res, \
Field<typename product<Type1, Type2>::type>& result, \
const UList<Type1>& f1, \
const UList<Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
TFOR_ALL_F_OP_F_OP_F(productType, res, =, Type1, f1, Op, Type2, f2) \
typedef typename product<Type1, Type2>::type resultType; \
TFOR_ALL_F_OP_F_OP_F(resultType, result, =, Type1, f1, Op, Type2, f2) \
} \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const UList<Type2>& f2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
auto tres = tmp<Field<productType>>::New(f1.size()); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = tmp<Field<resultType>>::New(f1.size()); \
OpFunc(tres.ref(), f1, f2); \
return tres; \
} \
@ -766,8 +760,8 @@ template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
auto tres = reuseTmp<productType, Type2>::New(tf2); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmp<resultType, Type2>::New(tf2); \
OpFunc(tres.ref(), f1, tf2()); \
tf2.clear(); \
return tres; \
@ -777,8 +771,8 @@ template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
auto tres = reuseTmp<productType, Type1>::New(tf1); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmp<resultType, Type1>::New(tf1); \
OpFunc(tres.ref(), tf1(), f2); \
tf1.clear(); \
return tres; \
@ -788,8 +782,8 @@ template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
auto tres = reuseTmpTmp<productType, Type1, Type1, Type2>::New(tf1, tf2); \
typedef typename product<Type1, Type2>::type resultType; \
auto tres = reuseTmpTmp<resultType, Type1, Type1, Type2>::New(tf1, tf2); \
OpFunc(tres.ref(), tf1(), tf2()); \
tf1.clear(); \
tf2.clear(); \
@ -799,22 +793,22 @@ operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \
template<class Type, class Form, class Cmpt, direction nCmpt> \
void OpFunc \
( \
Field<typename product<Type, Form>::type>& res, \
Field<typename product<Type, Form>::type>& result, \
const UList<Type>& f1, \
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 \
(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> \
tmp<Field<typename product<Type, Form>::type>> \
operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs) \
{ \
typedef typename product<Type, Form>::type productType; \
auto tres = tmp<Field<productType>>::New(f1.size()); \
typedef typename product<Type, Form>::type resultType; \
auto tres = tmp<Field<resultType>>::New(f1.size()); \
OpFunc(tres.ref(), f1, static_cast<const Form&>(vs)); \
return tres; \
} \
@ -827,8 +821,8 @@ operator Op \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
auto tres = reuseTmp<productType, Type>::New(tf1); \
typedef typename product<Type, Form>::type resultType; \
auto tres = reuseTmp<resultType, Type>::New(tf1); \
OpFunc(tres.ref(), tf1(), static_cast<const Form&>(vs)); \
tf1.clear(); \
return tres; \
@ -837,22 +831,22 @@ operator Op \
template<class Form, class Cmpt, direction nCmpt, class Type> \
void OpFunc \
( \
Field<typename product<Form, Type>::type>& res, \
Field<typename product<Form, Type>::type>& result, \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
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 \
(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> \
tmp<Field<typename product<Form, Type>::type>> \
operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1) \
{ \
typedef typename product<Form, Type>::type productType; \
auto tres = tmp<Field<productType>>::New(f1.size()); \
typedef typename product<Form, Type>::type resultType; \
auto tres = tmp<Field<resultType>>::New(f1.size()); \
OpFunc(tres.ref(), static_cast<const Form&>(vs), f1); \
return tres; \
} \
@ -864,8 +858,8 @@ operator Op \
const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type>>& tf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
auto tres = reuseTmp<productType, Type>::New(tf1); \
typedef typename product<Form, Type>::type resultType; \
auto tres = reuseTmp<resultType, Type>::New(tf1); \
OpFunc(tres.ref(), static_cast<const Form&>(vs), tf1()); \
tf1.clear(); \
return tres; \

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -31,77 +31,99 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define UNARY_FUNCTION(ReturnType, Type, 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) \
#define UNARY_FUNCTION(ReturnType, Type1, Func) \
\
TEMPLATE \
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<Type2>& f2 \
) \
{ \
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 \
tmp<Field<ReturnType>> Func \
@ -155,24 +177,30 @@ tmp<Field<ReturnType>> Func \
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 \
void Func \
( \
Field<ReturnType>& res, \
Field<ReturnType>& result, \
const Type1& s1, \
const UList<Type2>& f2 \
) \
{ \
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 \
tmp<Field<ReturnType>> Func \
@ -199,22 +227,28 @@ tmp<Field<ReturnType>> Func \
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 \
void Func \
( \
Field<ReturnType>& res, \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const Type2& s2 \
) \
{ \
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 \
tmp<Field<ReturnType>> Func \
@ -241,6 +275,10 @@ tmp<Field<ReturnType>> Func \
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) \
BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
@ -254,12 +292,12 @@ tmp<Field<ReturnType>> Func \
TEMPLATE \
void OpFunc \
( \
Field<ReturnType>& res, \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
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 \
@ -322,12 +360,12 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \
void OpFunc \
( \
Field<ReturnType>& res, \
Field<ReturnType>& result, \
const Type1& s1, \
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 \
@ -361,12 +399,12 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \
void OpFunc \
( \
Field<ReturnType>& res, \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
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 \

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

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -24,9 +25,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
High performance macro functions for Field\<Type\> algebra. These expand
using either array element access (for vector machines) or pointer
dereferencing for scalar machines as appropriate.
Macro functions for Field\<Type\> algebra.
\*---------------------------------------------------------------------------*/
@ -35,11 +34,13 @@ Description
#define UNARY_FUNCTION(ReturnType, Type1, Func) \
\
TEMPLATE \
void Func(Field<ReturnType>& res, const UList<Type1>& f); \
void Func(Field<ReturnType>& result, const UList<Type1>& f1); \
\
TEMPLATE \
tmp<Field<ReturnType>> Func(const UList<Type1>& f); \
tmp<Field<ReturnType>> Func(const UList<Type1>& f1); \
\
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) \
\
TEMPLATE \
void OpFunc(Field<ReturnType>& res, const UList<Type1>& f); \
void OpFunc(Field<ReturnType>& res, const UList<Type1>& f1); \
\
TEMPLATE \
tmp<Field<ReturnType>> operator Op(const UList<Type1>& f); \
tmp<Field<ReturnType>> operator Op(const UList<Type1>& f1); \
\
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) \
\
TEMPLATE \
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 \
);
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 \
void Func \
( \
Field<ReturnType>& f, \
Field<ReturnType>& result, \
const Type1& s1, \
const UList<Type2>& f2 \
); \
);
#define BINARY_FUNCTION_INTERFACE_SF(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
@ -121,16 +131,22 @@ tmp<Field<ReturnType>> Func \
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 \
void Func \
( \
Field<ReturnType>& f, \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const Type2& s2 \
); \
);
#define BINARY_FUNCTION_INTERFACE_FS(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<Field<ReturnType>> Func \
@ -146,6 +162,10 @@ tmp<Field<ReturnType>> Func \
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) \
BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
@ -159,7 +179,7 @@ tmp<Field<ReturnType>> Func \
TEMPLATE \
void OpFunc \
( \
Field<ReturnType>& f, \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const UList<Type2>& f2 \
); \
@ -200,7 +220,7 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \
void OpFunc \
( \
Field<ReturnType>& f, \
Field<ReturnType>& result, \
const Type1& s1, \
const UList<Type2>& f2 \
); \
@ -225,7 +245,7 @@ tmp<Field<ReturnType>> operator Op \
TEMPLATE \
void OpFunc \
( \
Field<ReturnType>& f, \
Field<ReturnType>& result, \
const UList<Type1>& f1, \
const Type2& s2 \
); \

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2022 OpenCFD Ltd.
Copyright (C) 2022-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -25,9 +25,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description
High performance macro functions for Field\<Type\> algebra. These expand
using either array element access (for vector machines) or pointer
dereferencing for scalar machines as appropriate.
Declaration macros for Field\<Type\> algebra.
\*---------------------------------------------------------------------------*/
@ -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
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
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// 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) \
\
@ -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) \
\
@ -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) \
\
@ -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) \
\
@ -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) \
\
@ -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) \
\
@ -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) \
\
@ -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) \
\
@ -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) \
\
@ -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
#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 |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019-2022 OpenCFD Ltd.
Copyright (C) 2019-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -35,10 +35,18 @@ namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// One-parameter versions
template<class TypeR, class Type1>
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)
{
return tmp<Field<TypeR>>::New(tf1().size());
@ -49,8 +57,8 @@ struct reuseTmp
template<class TypeR>
struct reuseTmp<TypeR, TypeR>
{
//- Allow optional copy assignment of the initial content
//- for identical input and output types
//- Identical input and return types:
//- allow optional copy assignment of the initial content
static tmp<Field<TypeR>> New
(
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>
struct reuseTmpTmp
{
//- Dissimilar types: just use size
static tmp<Field<TypeR>> New
(
const tmp<Field<Type1>>& tf1,
@ -102,6 +114,7 @@ struct reuseTmpTmp
template<class TypeR, class Type1, class Type12>
struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
{
//- Second input has return type
static tmp<Field<TypeR>> New
(
const tmp<Field<Type1>>& tf1,
@ -121,6 +134,7 @@ struct reuseTmpTmp<TypeR, Type1, Type12, TypeR>
template<class TypeR, class Type2>
struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
{
//- First input has return type
static tmp<Field<TypeR>> New
(
const tmp<Field<TypeR>>& tf1,
@ -140,6 +154,7 @@ struct reuseTmpTmp<TypeR, TypeR, TypeR, Type2>
template<class TypeR>
struct reuseTmpTmp<TypeR, TypeR, TypeR, TypeR>
{
//- Both inputs have return type
static tmp<Field<TypeR>> New
(
const tmp<Field<TypeR>>& tf1,

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

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -26,20 +27,40 @@ License
\*---------------------------------------------------------------------------*/
#undef UNARY_FUNCTION
#undef UNARY_FUNCTION_TRANSFORM
#undef UNARY_FUNCTION_INTERFACE
#undef UNARY_OPERATOR
#undef UNARY_OPERATOR_TRANSFORM
#undef UNARY_OPERATOR_INTERFACE
#undef BINARY_FUNCTION
#undef BINARY_FUNCTION_TRANSFORM
#undef BINARY_FUNCTION_INTERFACE
#undef BINARY_TYPE_FUNCTION
#undef BINARY_TYPE_FUNCTION_SF
#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_TYPE_OPERATOR
#undef BINARY_TYPE_OPERATOR_SF
#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

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

File diff suppressed because it is too large Load Diff

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2019 OpenCFD Ltd.
Copyright (C) 2018-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -37,7 +37,7 @@ License
namespace Foam
{
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * //
template<class Type, template<class> class PatchField, class GeoMesh>
void component
@ -47,16 +47,16 @@ void component
typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField,
GeoMesh
>& gcf,
const GeometricField<Type, PatchField, GeoMesh>& gf,
>& result,
const GeometricField<Type, PatchField, GeoMesh>& f1,
const direction d
);
template<class Type, template<class> class PatchField, class GeoMesh>
void T
(
GeometricField<Type, PatchField, GeoMesh>& gf,
const GeometricField<Type, PatchField, GeoMesh>& gf1
GeometricField<Type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& f1
);
template
@ -68,8 +68,9 @@ template
>
void pow
(
GeometricField<typename powProduct<Type, r>::type, PatchField, GeoMesh>& gf,
const GeometricField<Type, PatchField, GeoMesh>& gf1
GeometricField
<typename powProduct<Type, r>::type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& f1
);
template
@ -86,7 +87,7 @@ tmp
>
pow
(
const GeometricField<Type, PatchField, GeoMesh>& gf,
const GeometricField<Type, PatchField, GeoMesh>& f1,
typename powProduct<Type, r>::type
);
@ -104,7 +105,7 @@ tmp
>
pow
(
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf,
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1,
typename powProduct<Type, r>::type
);
@ -112,7 +113,7 @@ template<class Type, template<class> class PatchField, class GeoMesh>
void sqr
(
GeometricField
<typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& gf,
<typename outerProduct<Type, Type>::type, PatchField, GeoMesh>& f1,
const GeometricField<Type, PatchField, GeoMesh>& gf1
);
@ -126,7 +127,7 @@ tmp
GeoMesh
>
>
sqr(const GeometricField<Type, PatchField, GeoMesh>& gf);
sqr(const GeometricField<Type, PatchField, GeoMesh>& f1);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp
@ -138,48 +139,48 @@ tmp
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>
void magSqr
(
GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf,
const GeometricField<Type, PatchField, GeoMesh>& gf
GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& f1
);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
magSqr
(
const GeometricField<Type, PatchField, GeoMesh>& gf
const GeometricField<Type, PatchField, GeoMesh>& f1
);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
magSqr
(
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
);
template<class Type, template<class> class PatchField, class GeoMesh>
void mag
(
GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& gsf,
const GeometricField<Type, PatchField, GeoMesh>& gf
GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>& result,
const GeometricField<Type, PatchField, GeoMesh>& tf1
);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
mag
(
const GeometricField<Type, PatchField, GeoMesh>& gf
const GeometricField<Type, PatchField, GeoMesh>& f1
);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<typename typeOfMag<Type>::type, PatchField, GeoMesh>>
mag
(
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf1
);
template<class Type, template<class> class PatchField, class GeoMesh>
@ -190,8 +191,8 @@ void cmptAv
typename GeometricField<Type, PatchField, GeoMesh>::cmptType,
PatchField,
GeoMesh
>& gcf,
const GeometricField<Type, PatchField, GeoMesh>& gf
>& result,
const GeometricField<Type, PatchField, GeoMesh>& f1
);
template<class Type, template<class> class PatchField, class GeoMesh>
@ -204,7 +205,7 @@ tmp
GeoMesh
>
>
cmptAv(const GeometricField<Type, PatchField, GeoMesh>& gf);
cmptAv(const GeometricField<Type, PatchField, GeoMesh>& f1);
template<class Type, template<class> class PatchField, class GeoMesh>
tmp
@ -216,21 +217,21 @@ tmp
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> \
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> \
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)
@ -241,18 +242,18 @@ UNARY_REDUCTION_FUNCTION_WITH_BOUNDARY(scalarMinMax, minMaxMag, minMaxMagOp)
#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> \
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> \
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)
@ -273,7 +274,7 @@ BINARY_TYPE_FUNCTION(Type, Type, Type, cmptMultiply)
BINARY_TYPE_FUNCTION(Type, Type, Type, cmptDivide)
// * * * * * * * * * * * * * * * Global operators * * * * * * * * * * * * * //
// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * //
UNARY_OPERATOR(Type, Type, -, negate, transform)
@ -289,16 +290,16 @@ 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, template<class> class PatchField, class GeoMesh> \
void opFunc \
void OpFunc \
( \
GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh>& gf, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
<typename product<Type1, Type2>::type, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
template \
@ -308,10 +309,10 @@ tmp \
GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
template \
@ -321,10 +322,10 @@ tmp \
GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \
\
template \
@ -334,10 +335,10 @@ tmp \
GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
template \
@ -347,19 +348,19 @@ tmp \
GeometricField \
<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
void opFunc \
void OpFunc \
( \
GeometricField \
<typename product<Type, Form>::type, PatchField, GeoMesh>& gf, \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \
<typename product<Type, Form>::type, PatchField, GeoMesh>& result, \
const GeometricField<Type, PatchField, GeoMesh>& f1, \
const dimensioned<Form>& dvs \
); \
\
@ -370,9 +371,9 @@ tmp \
GeometricField \
<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 \
); \
\
@ -389,9 +390,9 @@ tmp \
GeometricField \
<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 \
); \
\
@ -402,9 +403,9 @@ tmp \
GeometricField \
<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 \
); \
\
@ -421,20 +422,20 @@ tmp \
GeometricField \
<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 \
); \
\
template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \
void opFunc \
void OpFunc \
( \
GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh>& gf, \
<typename product<Form, Type>::type, PatchField, GeoMesh>& result, \
const dimensioned<Form>& dvs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \
const GeometricField<Type, PatchField, GeoMesh>& f2 \
); \
\
template \
@ -444,10 +445,10 @@ tmp \
GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const dimensioned<Form>& dvs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \
const GeometricField<Type, PatchField, GeoMesh>& f2 \
); \
\
template \
@ -463,10 +464,10 @@ tmp \
GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const GeometricField<Type, PatchField, GeoMesh>& gf1 \
const GeometricField<Type, PatchField, GeoMesh>& f2 \
); \
\
template \
@ -476,10 +477,10 @@ tmp \
GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const dimensioned<Form>& dvs, \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2 \
); \
\
template \
@ -495,10 +496,10 @@ tmp \
GeometricField \
<typename product<Form, Type>::type, PatchField, GeoMesh> \
> \
operator op \
operator Op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf1 \
const tmp<GeometricField<Type, PatchField, GeoMesh>>& tf2 \
);
PRODUCT_OPERATOR(typeOfSum, +, add)

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

@ -6,7 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2019 OpenCFD Ltd.
Copyright (C) 2019-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -40,39 +40,31 @@ namespace Foam
TEMPLATE \
void Func \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1 \
) \
{ \
Foam::Func(res.primitiveFieldRef(), gf1.primitiveField()); \
Foam::Func(res.boundaryFieldRef(), gf1.boundaryField()); \
res.oriented() = gf1.oriented(); \
Foam::Func(result.primitiveFieldRef(), f1.primitiveField()); \
Foam::Func(result.boundaryFieldRef(), f1.boundaryField()); \
result.oriented() = f1.oriented(); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
const GeometricField<Type1, PatchField, GeoMesh>& f1 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + gf1.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
Dfunc(gf1.dimensions()) \
f1, \
#Func "(" + f1.name() + ')', \
Dfunc(f1.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1); \
\
Foam::Func(tres.ref(), f1); \
return tres; \
} \
\
@ -80,23 +72,21 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
tgf1, \
#Func "(" + gf1.name() + ')', \
Dfunc(gf1.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1); \
\
tgf1.clear(); \
tf1, \
#Func "(" + f1.name() + ')', \
Dfunc(f1.dimensions()) \
); \
\
Foam::Func(tres.ref(), f1); \
tf1.clear(); \
return tres; \
}
@ -108,38 +98,31 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
void OpFunc \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1 \
) \
{ \
Foam::OpFunc(res.primitiveFieldRef(), gf1.primitiveField()); \
Foam::OpFunc(res.boundaryFieldRef(), gf1.boundaryField()); \
res.oriented() = gf1.oriented(); \
Foam::OpFunc(result.primitiveFieldRef(), f1.primitiveField()); \
Foam::OpFunc(result.boundaryFieldRef(), f1.boundaryField()); \
result.oriented() = f1.oriented(); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 \
const GeometricField<Type1, PatchField, GeoMesh>& f1 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
IOobject \
( \
#Op + gf1.name(), \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
Dfunc(gf1.dimensions()) \
f1, \
#Op + f1.name(), \
Dfunc(f1.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1); \
\
Foam::OpFunc(tres.ref(), f1); \
return tres; \
} \
\
@ -147,23 +130,21 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
tgf1, \
#Op + gf1.name(), \
Dfunc(gf1.dimensions()) \
tf1, \
#Op + f1.name(), \
Dfunc(f1.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1); \
\
tgf1.clear(); \
\
Foam::OpFunc(tres.ref(), f1); \
tf1.clear(); \
return tres; \
}
@ -175,51 +156,43 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
void Func \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
Foam::Func \
( \
res.primitiveFieldRef(), \
gf1.primitiveField(), \
gf2.primitiveField() \
result.primitiveFieldRef(), \
f1.primitiveField(), \
f2.primitiveField() \
); \
Foam::Func \
( \
res.boundaryFieldRef(), \
gf1.boundaryField(), \
gf2.boundaryField() \
result.boundaryFieldRef(), \
f1.boundaryField(), \
f2.boundaryField() \
); \
res.oriented() = Func(gf1.oriented(), gf2.oriented()); \
result.oriented() = Func(f1.oriented(), f2.oriented()); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + gf1.name() + ',' + gf2.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
Func(gf1.dimensions(), gf2.dimensions()) \
f1, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1, gf2); \
\
Foam::Func(tres.ref(), f1, f2); \
return tres; \
} \
\
@ -227,24 +200,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
( \
tgf2, \
#Func "(" + gf1.name() + ',' + gf2.name() + ')', \
Func(gf1.dimensions(), gf2.dimensions()) \
tf2, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1, gf2); \
\
tgf2.clear(); \
\
Foam::Func(tres.ref(), f1, f2); \
tf2.clear(); \
return tres; \
} \
\
@ -252,24 +223,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
tgf1, \
#Func "(" + gf1.name() + ',' + gf2.name() + ')', \
Func(gf1.dimensions(), gf2.dimensions()) \
tf1, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1, gf2); \
\
tgf1.clear(); \
\
Foam::Func(tres.ref(), f1, f2); \
tf1.clear(); \
return tres; \
} \
\
@ -277,29 +246,27 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
const auto& f1 = tf1(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpTmpGeometricField \
<ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \
::New \
( \
tgf1, \
tgf2, \
#Func "(" + gf1.name() + ',' + gf2.name() + ')', \
Func(gf1.dimensions(), gf2.dimensions()) \
tf1, \
tf2, \
#Func "(" + f1.name() + ',' + f2.name() + ')', \
Func(f1.dimensions(), f2.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1, gf2); \
\
tgf1.clear(); \
tgf2.clear(); \
\
Foam::Func(tres.ref(), f1, f2); \
tf1.clear(); \
tf2.clear(); \
return tres; \
}
@ -311,14 +278,14 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
void Func \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
Foam::Func(res.primitiveFieldRef(), dt1.value(), gf2.primitiveField()); \
Foam::Func(res.boundaryFieldRef(), dt1.value(), gf2.boundaryField()); \
res.oriented() = gf2.oriented(); \
Foam::Func(result.primitiveFieldRef(), dt1.value(), f2.primitiveField()); \
Foam::Func(result.boundaryFieldRef(), dt1.value(), f2.boundaryField()); \
result.oriented() = f2.oriented(); \
} \
\
\
@ -326,26 +293,18 @@ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + dt1.name() + ',' + gf2.name() + ')', \
gf2.instance(), \
gf2.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf2.mesh(), \
Func(dt1.dimensions(), gf2.dimensions()) \
f2, \
#Func "(" + dt1.name() + ',' + f2.name() + ')', \
Func(dt1.dimensions(), f2.dimensions()) \
); \
\
Foam::Func(tres.ref(), dt1, gf2); \
\
Foam::Func(tres.ref(), dt1, f2); \
return tres; \
} \
\
@ -353,11 +312,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const Type1& t1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const Type1& s1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
return Func(dimensioned<Type1>(t1), gf2); \
return Func(dimensioned<Type1>(s1), f2); \
} \
\
\
@ -365,23 +324,21 @@ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
( \
tgf2, \
#Func "(" + dt1.name() + gf2.name() + ',' + ')', \
Func(dt1.dimensions(), gf2.dimensions()) \
tf2, \
#Func "(" + dt1.name() + ',' + f2.name() + ')', \
Func(dt1.dimensions(), f2.dimensions()) \
); \
\
Foam::Func(tres.ref(), dt1, gf2); \
\
tgf2.clear(); \
\
Foam::Func(tres.ref(), dt1, f2); \
tf2.clear(); \
return tres; \
} \
\
@ -389,11 +346,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const Type1& t1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const Type1& s1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
return Func(dimensioned<Type1>(t1), tgf2); \
return Func(dimensioned<Type1>(s1), tf2); \
}
@ -402,41 +359,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
void Func \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
Foam::Func(res.primitiveFieldRef(), gf1.primitiveField(), dt2.value()); \
Foam::Func(res.boundaryFieldRef(), gf1.boundaryField(), dt2.value()); \
res.oriented() = gf1.oriented(); \
Foam::Func(result.primitiveFieldRef(), f1.primitiveField(), dt2.value()); \
Foam::Func(result.boundaryFieldRef(), f1.boundaryField(), dt2.value()); \
result.oriented() = f1.oriented(); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
IOobject \
( \
#Func "(" + gf1.name() + ',' + dt2.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
Func(gf1.dimensions(), dt2.dimensions()) \
f1, \
#Func "(" + f1.name() + ',' + dt2.name() + ')', \
Func(f1.dimensions(), dt2.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1, dt2); \
\
Foam::Func(tres.ref(), f1, dt2); \
return tres; \
} \
\
@ -444,35 +393,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const Type2& t2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const Type2& s2 \
) \
{ \
return Func(gf1, dimensioned<Type2>(t2)); \
return Func(f1, dimensioned<Type2>(s2)); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
tgf1, \
#Func "(" + gf1.name() + ',' + dt2.name() + ')', \
Func(gf1.dimensions(), dt2.dimensions()) \
tf1, \
#Func "(" + f1.name() + ',' + dt2.name() + ')', \
Func(f1.dimensions(), dt2.dimensions()) \
); \
\
Foam::Func(tres.ref(), gf1, dt2); \
\
tgf1.clear(); \
\
Foam::Func(tres.ref(), f1, dt2); \
tf1.clear(); \
return tres; \
} \
\
@ -480,11 +427,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const Type2& t2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const Type2& s2 \
) \
{ \
return Func(tgf1, dimensioned<Type2>(t2)); \
return Func(tf1, dimensioned<Type2>(s2)); \
}
@ -500,43 +447,43 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
void OpFunc \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
Foam::OpFunc \
(res.primitiveFieldRef(), gf1.primitiveField(), gf2.primitiveField()); \
( \
result.primitiveFieldRef(), \
f1.primitiveField(), \
f2.primitiveField() \
); \
Foam::OpFunc \
(res.boundaryFieldRef(), gf1.boundaryField(), gf2.boundaryField()); \
res.oriented() = gf1.oriented() Op gf2.oriented(); \
( \
result.boundaryFieldRef(), \
f1.boundaryField(), \
f2.boundaryField() \
); \
result.oriented() = (f1.oriented() Op f2.oriented()); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
IOobject \
( \
'(' + gf1.name() + OpName + gf2.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
gf1.dimensions() Op gf2.dimensions() \
f1, \
'(' + f1.name() + OpName + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1, gf2); \
\
Foam::OpFunc(tres.ref(), f1, f2); \
return tres; \
} \
\
@ -544,24 +491,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
( \
tgf2, \
'(' + gf1.name() + OpName + gf2.name() + ')', \
gf1.dimensions() Op gf2.dimensions() \
tf2, \
'(' + f1.name() + OpName + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1, gf2); \
\
tgf2.clear(); \
\
Foam::OpFunc(tres.ref(), f1, f2); \
tf2.clear(); \
return tres; \
} \
\
@ -569,24 +514,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
tgf1, \
'(' + gf1.name() + OpName + gf2.name() + ')', \
gf1.dimensions() Op gf2.dimensions() \
tf1, \
'(' + f1.name() + OpName + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1, gf2); \
\
tgf1.clear(); \
\
Foam::OpFunc(tres.ref(), f1, f2); \
tf1.clear(); \
return tres; \
} \
\
@ -594,28 +537,26 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
const auto& f1 = tf1(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpTmpGeometricField \
<ReturnType, Type1, Type1, Type2, PatchField, GeoMesh>::New \
( \
tgf1, \
tgf2, \
'(' + gf1.name() + OpName + gf2.name() + ')', \
gf1.dimensions() Op gf2.dimensions() \
tf1, \
tf2, \
'(' + f1.name() + OpName + f2.name() + ')', \
(f1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1, gf2); \
\
tgf1.clear(); \
tgf2.clear(); \
\
Foam::OpFunc(tres.ref(), f1, f2); \
tf1.clear(); \
tf2.clear(); \
return tres; \
}
@ -627,14 +568,14 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
void OpFunc \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
Foam::OpFunc(res.primitiveFieldRef(), dt1.value(), gf2.primitiveField()); \
Foam::OpFunc(res.boundaryFieldRef(), dt1.value(), gf2.boundaryField()); \
res.oriented() = gf2.oriented(); \
Foam::OpFunc(result.primitiveFieldRef(), dt1.value(), f2.primitiveField());\
Foam::OpFunc(result.boundaryFieldRef(), dt1.value(), f2.boundaryField()); \
result.oriented() = f2.oriented(); \
\
} \
\
@ -642,26 +583,18 @@ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
( \
IOobject \
( \
'(' + dt1.name() + OpName + gf2.name() + ')', \
gf2.instance(), \
gf2.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf2.mesh(), \
dt1.dimensions() Op gf2.dimensions() \
f2, \
'(' + dt1.name() + OpName + f2.name() + ')', \
(dt1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), dt1, gf2); \
\
Foam::OpFunc(tres.ref(), dt1, f2); \
return tres; \
} \
\
@ -670,10 +603,10 @@ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const Type1& t1, \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
) \
{ \
return dimensioned<Type1>(t1) Op gf2; \
return dimensioned<Type1>(t1) Op f2; \
} \
\
\
@ -681,23 +614,21 @@ TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
const GeometricField<Type2, PatchField, GeoMesh>& gf2 = tgf2(); \
const auto& f2 = tf2(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh>::New \
( \
tgf2, \
'(' + dt1.name() + OpName + gf2.name() + ')', \
dt1.dimensions() Op gf2.dimensions() \
) ; \
\
Foam::OpFunc(tres.ref(), dt1, gf2); \
\
tgf2.clear(); \
tf2, \
'(' + dt1.name() + OpName + f2.name() + ')', \
(dt1.dimensions() Op f2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), dt1, f2); \
tf2.clear(); \
return tres; \
} \
\
@ -705,11 +636,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const Type1& t1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2 \
const Type1& s1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
) \
{ \
return dimensioned<Type1>(t1) Op tgf2; \
return dimensioned<Type1>(s1) Op tf2; \
}
@ -718,41 +649,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
void OpFunc \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& res, \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
Foam::OpFunc(res.primitiveFieldRef(), gf1.primitiveField(), dt2.value()); \
Foam::OpFunc(res.boundaryFieldRef(), gf1.boundaryField(), dt2.value()); \
res.oriented() = gf1.oriented(); \
Foam::OpFunc(result.primitiveFieldRef(), f1.primitiveField(), dt2.value());\
Foam::OpFunc(result.boundaryFieldRef(), f1.boundaryField(), dt2.value()); \
result.oriented() = f1.oriented(); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
) \
{ \
auto tres = \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>>::New \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
IOobject \
( \
'(' + gf1.name() + OpName + dt2.name() + ')', \
gf1.instance(), \
gf1.db(), \
IOobject::NO_READ, \
IOobject::NO_WRITE \
), \
gf1.mesh(), \
gf1.dimensions() Op dt2.dimensions() \
f1, \
'(' + f1.name() + OpName + dt2.name() + ')', \
(f1.dimensions() Op dt2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1, dt2); \
\
Foam::OpFunc(tres.ref(), f1, dt2); \
return tres; \
} \
\
@ -760,35 +683,33 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& gf1, \
const Type2& t2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const Type2& s2 \
) \
{ \
return gf1 Op dimensioned<Type2>(t2); \
return f1 Op dimensioned<Type2>(s2); \
} \
\
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const dimensioned<Type2>& dt2 \
) \
{ \
const GeometricField<Type1, PatchField, GeoMesh>& gf1 = tgf1(); \
const auto& f1 = tf1(); \
\
auto tres = \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh>::New \
( \
tgf1, \
'(' + gf1.name() + OpName + dt2.name() + ')', \
gf1.dimensions() Op dt2.dimensions() \
tf1, \
'(' + f1.name() + OpName + dt2.name() + ')', \
(f1.dimensions() Op dt2.dimensions()) \
); \
\
Foam::OpFunc(tres.ref(), gf1, dt2); \
\
tgf1.clear(); \
\
Foam::OpFunc(tres.ref(), f1, dt2); \
tf1.clear(); \
return tres; \
} \
\
@ -796,11 +717,11 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1, \
const Type2& t2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const Type2& s2 \
) \
{ \
return tgf1 Op dimensioned<Type2>(t2); \
return tf1 Op dimensioned<Type2>(s2); \
}

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

@ -6,6 +6,7 @@
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
@ -30,32 +31,46 @@ License
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
\
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 \
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 \
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 \
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) \
\
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 \
( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \
@ -73,22 +96,22 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
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) \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
void Func \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const Type1& t1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const Type1& t1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const Type1& s1, \
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) \
\
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 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf2, \
const Type2& t2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
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) \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
void OpFunc \
( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tf2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tf1, \
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 \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
void OpFunc \
( \
GeometricField<ReturnType, PatchField, GeoMesh>& result, \
const dimensioned<Type1>& dt1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const Type1& t1, \
const GeometricField<Type2, PatchField, GeoMesh>& df2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const GeometricField<Type2, PatchField, GeoMesh>& f2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const Type1& t1, \
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tdf2 \
const Type1& s1, \
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 \
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 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const GeometricField<Type1, PatchField, GeoMesh>& df1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
( \
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tdf1, \
const Type2& t2 \
const GeometricField<Type1, PatchField, GeoMesh>& f1, \
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 \
);

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

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