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

FieldField, DimensionedField, GeometricField: Simplified tmp reuse and cleanup

Browse Source
This commit is contained in:
Henry Weller
2016-02-25 18:29:00 +00:00
parent 85fa6c2649
commit e1405f2260
14 changed files with 318 additions and 434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -88,7 +88,7 @@ pow
pow<Type, r, GeoMesh>(tPow().field(), df.field()); pow<Type, r, GeoMesh>(tPow().field(), df.field());
reuseTmpDimensionedField<powProductType, Type, GeoMesh>::clear(tdf); tdf.clear();
return tPow; return tPow;
} }
@ -137,7 +137,7 @@ sqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
sqr(tSqr().field(), df.field()); sqr(tSqr().field(), df.field());
reuseTmpDimensionedField<outerProductType, Type, GeoMesh>::clear(tdf); tdf.clear();
return tSqr; return tSqr;
} }
@ -187,7 +187,7 @@ tmp<DimensionedField<scalar, GeoMesh>> magSqr
magSqr(tMagSqr().field(), df.field()); magSqr(tMagSqr().field(), df.field());
reuseTmpDimensionedField<scalar, Type, GeoMesh>::clear(tdf); tdf.clear();
return tMagSqr; return tMagSqr;
} }
@ -237,7 +237,7 @@ tmp<DimensionedField<scalar, GeoMesh>> mag
mag(tMag().field(), df.field()); mag(tMag().field(), df.field());
reuseTmpDimensionedField<scalar, Type, GeoMesh>::clear(tdf); tdf.clear();
return tMag; return tMag;
} }
@ -296,7 +296,7 @@ cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
cmptAv(CmptAv().field(), df.field()); cmptAv(CmptAv().field(), df.field());
reuseTmpDimensionedField<cmptType, Type, GeoMesh>::clear(tdf); tdf.clear();
return CmptAv; return CmptAv;
} }
@ -417,7 +417,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \ Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<productType, Type2, GeoMesh>::clear(tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -444,7 +444,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \ Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<productType, Type1, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -474,8 +474,8 @@ operator op \
\ \
Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \ Foam::opFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpTmpDimensionedField \ tdf1.clear(); \
<productType, Type1, Type1, Type2, GeoMesh>::clear(tdf1, tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -544,7 +544,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref().field(), df1.field(), dvs.value()); \ Foam::opFunc(tRes.ref().field(), df1.field(), dvs.value()); \
\ \
reuseTmpDimensionedField<productType, Type, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -623,7 +623,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref().field(), dvs.value(), df1.field()); \ Foam::opFunc(tRes.ref().field(), dvs.value(), df1.field()); \
\ \
reuseTmpDimensionedField<productType, Type, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \

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

@ -75,7 +75,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
\ \
Func(tRes.ref().field(), df1.field()); \ Func(tRes.ref().field(), df1.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} }
@ -131,7 +131,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref().field(), df1.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} }
@ -189,7 +189,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
\ \
Func(tRes.ref().field(), df1.field(), df2.field()); \ Func(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -215,7 +215,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
\ \
Func(tRes.ref().field(), df1.field(), df2.field()); \ Func(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -244,8 +244,8 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
\ \
Func(tRes.ref().field(), df1.field(), df2.field()); \ Func(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpTmpDimensionedField<ReturnType, Type1, Type1, Type2, GeoMesh> \ tdf1.clear(); \
::clear(tdf1, tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} }
@ -314,7 +314,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
\ \
Func(tRes.ref().field(), dt1.value(), df2.field()); \ Func(tRes.ref().field(), dt1.value(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -391,7 +391,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> Func \
\ \
Func(tRes.ref().field(), df1.field(), dt2.value()); \ Func(tRes.ref().field(), df1.field(), dt2.value()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -464,7 +464,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -490,7 +490,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -519,8 +519,8 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \ Foam::OpFunc(tRes.ref().field(), df1.field(), df2.field()); \
\ \
reuseTmpTmpDimensionedField<ReturnType, Type1, Type1, Type2, GeoMesh>:: \ tdf1.clear(); \
clear(tdf1, tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} }
@ -589,7 +589,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref().field(), dt1.value(), tdf2().field()); \ Foam::OpFunc(tRes.ref().field(), dt1.value(), tdf2().field()); \
\ \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::clear(tdf2); \ tdf2.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -666,7 +666,7 @@ tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref().field(), tdf1().field(), dt2.value()); \ Foam::OpFunc(tRes.ref().field(), tdf1().field(), dt2.value()); \
\ \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::clear(tdf1); \ tdf1.clear(); \
\ \
return tRes; \ return tRes; \
} \ } \

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

@ -33,6 +33,43 @@ namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class TypeR, class GeoMesh>
tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const word& name,
const dimensionSet& dimensions
)
{
DimensionedField<TypeR, GeoMesh>& df1 =
const_cast<DimensionedField<TypeR, GeoMesh>& >(tdf1());
if (tdf1.isTmp())
{
df1.rename(name);
df1.dimensions().reset(dimensions);
return tdf1;
}
else
{
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
(
IOobject
(
name,
df1.instance(),
df1.db()
),
df1.mesh(),
dimensions
)
);
}
}
template<class TypeR, class Type1, class GeoMesh> template<class TypeR, class Type1, class GeoMesh>
class reuseTmpDimensionedField class reuseTmpDimensionedField
{ {
@ -62,11 +99,6 @@ public:
) )
); );
} }
static void clear(const tmp<DimensionedField<Type1, GeoMesh>>& tdf1)
{
tdf1.clear();
}
}; };
@ -109,11 +141,6 @@ public:
); );
} }
} }
static void clear(const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1)
{
tdf1.clear();
}
}; };
@ -147,16 +174,6 @@ public:
) )
); );
} }
static void clear
(
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2
)
{
tdf1.clear();
tdf2.clear();
}
}; };
@ -201,16 +218,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2
)
{
tdf1.clear();
tdf2.clear();
}
}; };
@ -254,16 +261,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2
)
{
tdf1.clear();
tdf2.clear();
}
}; };
@ -315,16 +312,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2
)
{
tdf1.clear();
tdf2.clear();
}
}; };

165
src/OpenFOAM/fields/DimensionedFields/DimensionedScalarField/DimensionedScalarField.C
View File

@ -72,17 +72,16 @@ tmp<DimensionedField<scalar, GeoMesh>> stabilise
{ {
const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh>> tRes = tmp<DimensionedField<scalar, GeoMesh>> tRes = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
( tdsf,
tdsf, "stabilise(" + dsf.name() + ',' + ds.name() + ')',
"stabilise(" + dsf.name() + ',' + ds.name() + ')', dsf.dimensions() + ds.dimensions()
dsf.dimensions() + ds.dimensions() );
);
stabilise(tRes.ref().field(), dsf.field(), ds.value()); stabilise(tRes.ref().field(), dsf.field(), ds.value());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); tdsf.clear();
return tRes; return tRes;
} }
@ -141,21 +140,20 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
{ {
const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1(); const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
tmp<DimensionedField<scalar, GeoMesh>> tPow = tmp<DimensionedField<scalar, GeoMesh>> tPow = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
tdsf1,
"pow(" + dsf1.name() + ',' + dsf2.name() + ')',
pow
( (
tdsf1, dsf1.dimensions(),
"pow(" + dsf1.name() + ',' + dsf2.name() + ')', dimensionedScalar("1", 1.0, dsf2.dimensions())
pow )
( );
dsf1.dimensions(),
dimensionedScalar("1", 1.0, dsf2.dimensions())
)
);
pow(tPow.ref().field(), dsf1.field(), dsf2.field()); pow(tPow.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf1); tdsf1.clear();
return tPow; return tPow;
} }
@ -170,21 +168,20 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
{ {
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2(); const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh>> tPow = tmp<DimensionedField<scalar, GeoMesh>> tPow = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
tdsf2,
"pow(" + dsf1.name() + ',' + dsf2.name() + ')',
pow
( (
tdsf2, dsf1.dimensions(),
"pow(" + dsf1.name() + ',' + dsf2.name() + ')', dimensionedScalar("1", 1.0, dsf2.dimensions())
pow )
( );
dsf1.dimensions(),
dimensionedScalar("1", 1.0, dsf2.dimensions())
)
);
pow(tPow.ref().field(), dsf1.field(), dsf2.field()); pow(tPow.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2); tdsf2.clear();
return tPow; return tPow;
} }
@ -215,11 +212,8 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
pow(tPow.ref().field(), dsf1.field(), dsf2.field()); pow(tPow.ref().field(), dsf1.field(), dsf2.field());
reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::clear tdsf1.clear();
( tdsf2.clear();
tdsf1,
tdsf2
);
return tPow; return tPow;
} }
@ -261,17 +255,16 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
{ {
const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh>> tPow = tmp<DimensionedField<scalar, GeoMesh>> tPow = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
( tdsf,
tdsf, "pow(" + dsf.name() + ',' + ds.name() + ')',
"pow(" + dsf.name() + ',' + ds.name() + ')', pow(dsf.dimensions(), ds)
pow(dsf.dimensions(), ds) );
);
pow(tPow.ref().field(), dsf.field(), ds.value()); pow(tPow.ref().field(), dsf.field(), ds.value());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); tdsf.clear();
return tPow; return tPow;
} }
@ -334,17 +327,16 @@ tmp<DimensionedField<scalar, GeoMesh>> pow
{ {
const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh>> tPow = tmp<DimensionedField<scalar, GeoMesh>> tPow = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
( tdsf,
tdsf, "pow(" + ds.name() + ',' + dsf.name() + ')',
"pow(" + ds.name() + ',' + dsf.name() + ')', pow(ds, dsf.dimensions())
pow(ds, dsf.dimensions()) );
);
pow(tPow.ref().field(), ds.value(), dsf.field()); pow(tPow.ref().field(), ds.value(), dsf.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); tdsf.clear();
return tPow; return tPow;
} }
@ -409,17 +401,16 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
{ {
const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1(); const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
( tdsf1,
tdsf1, "atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
"atan2(" + dsf1.name() + ',' + dsf2.name() + ')', atan2(dsf1.dimensions(), dsf2.dimensions())
atan2(dsf1.dimensions(), dsf2.dimensions()) );
);
atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field()); atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf1); tdsf1.clear();
return tAtan2; return tAtan2;
} }
@ -434,17 +425,16 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
{ {
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2(); const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
( tdsf2,
tdsf2, "atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
"atan2(" + dsf1.name() + ',' + dsf2.name() + ')', atan2(dsf1.dimensions(), dsf2.dimensions())
atan2(dsf1.dimensions(), dsf2.dimensions()) );
);
atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field()); atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2); tdsf2.clear();
return tAtan2; return tAtan2;
} }
@ -471,11 +461,8 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field()); atan2(tAtan2.ref().field(), dsf1.field(), dsf2.field());
reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::clear tdsf1.clear();
( tdsf2.clear();
tdsf1,
tdsf2
);
return tAtan2; return tAtan2;
} }
@ -517,17 +504,16 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
{ {
const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
( tdsf,
tdsf, "atan2(" + dsf.name() + ',' + ds.name() + ')',
"atan2(" + dsf.name() + ',' + ds.name() + ')', atan2(dsf.dimensions(), ds)
atan2(dsf.dimensions(), ds) );
);
atan2(tAtan2.ref().field(), dsf.field(), ds.value()); atan2(tAtan2.ref().field(), dsf.field(), ds.value());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); tdsf.clear();
return tAtan2; return tAtan2;
} }
@ -590,17 +576,16 @@ tmp<DimensionedField<scalar, GeoMesh>> atan2
{ {
const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = tmp<DimensionedField<scalar, GeoMesh>> tAtan2 = New
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New (
( tdsf,
tdsf, "atan2(" + ds.name() + ',' + dsf.name() + ')',
"atan2(" + ds.name() + ',' + dsf.name() + ')', atan2(ds, dsf.dimensions())
atan2(ds, dsf.dimensions()) );
);
atan2(tAtan2.ref().field(), ds.value(), dsf.field()); atan2(tAtan2.ref().field(), ds.value(), dsf.field());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); tdsf.clear();
return tAtan2; return tAtan2;
} }
@ -721,7 +706,7 @@ tmp<DimensionedField<scalar, GeoMesh>> func \
\ \
tmp<DimensionedField<scalar, GeoMesh>> tFunc \ tmp<DimensionedField<scalar, GeoMesh>> tFunc \
( \ ( \
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New \ New \
( \ ( \
tdsf, \ tdsf, \
#func "(" + name(n) + ',' + dsf.name() + ')', \ #func "(" + name(n) + ',' + dsf.name() + ')', \
@ -731,7 +716,7 @@ tmp<DimensionedField<scalar, GeoMesh>> func \
\ \
func(tFunc.ref().field(), n, dsf.field()); \ func(tFunc.ref().field(), n, dsf.field()); \
\ \
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf); \ tdsf.clear(); \
\ \
return tFunc; \ return tFunc; \
} }

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

@ -103,7 +103,7 @@ pow
reuseTmpFieldField<Field, powProductType, Type>::New(tf) reuseTmpFieldField<Field, powProductType, Type>::New(tf)
); );
pow<Type, r>(tRes.ref(), tf()); pow<Type, r>(tRes.ref(), tf());
reuseTmpFieldField<Field, powProductType, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -144,7 +144,7 @@ sqr(const tmp<FieldField<Field, Type>>& tf)
reuseTmpFieldField<Field, outerProductType, Type>::New(tf) reuseTmpFieldField<Field, outerProductType, Type>::New(tf)
); );
sqr(tRes.ref(), tf()); sqr(tRes.ref(), tf());
reuseTmpFieldField<Field, outerProductType, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -179,7 +179,7 @@ tmp<FieldField<Field, scalar>> magSqr(const tmp<FieldField<Field, Type>>& tf)
); );
magSqr(tRes.ref(), tf()); magSqr(tRes.ref(), tf());
reuseTmpFieldField<Field, scalar, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -214,7 +214,7 @@ tmp<FieldField<Field, scalar>> mag(const tmp<FieldField<Field, Type>>& tf)
); );
mag(tRes.ref(), tf()); mag(tRes.ref(), tf());
reuseTmpFieldField<Field, scalar, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -259,7 +259,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
reuseTmpFieldField<Field, cmptType, Type>::New(tf) reuseTmpFieldField<Field, cmptType, Type>::New(tf)
); );
cmptMax(tRes.ref(), tf()); cmptMax(tRes.ref(), tf());
reuseTmpFieldField<Field, cmptType, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -304,7 +304,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
reuseTmpFieldField<Field, cmptType, Type>::New(tf) reuseTmpFieldField<Field, cmptType, Type>::New(tf)
); );
cmptMin(tRes.ref(), tf()); cmptMin(tRes.ref(), tf());
reuseTmpFieldField<Field, cmptType, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -349,7 +349,7 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
reuseTmpFieldField<Field, cmptType, Type>::New(tf) reuseTmpFieldField<Field, cmptType, Type>::New(tf)
); );
cmptAv(tRes.ref(), tf()); cmptAv(tRes.ref(), tf());
reuseTmpFieldField<Field, cmptType, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -387,12 +387,9 @@ tmp<FieldField<Field, Type>> cmptMag
const tmp<FieldField<Field, Type>>& tf const tmp<FieldField<Field, Type>>& tf
) )
{ {
tmp<FieldField<Field, Type>> tRes tmp<FieldField<Field, Type>> tRes(New(tf));
(
reuseTmpFieldField<Field, Type, Type>::New(tf)
);
cmptMag(tRes.ref(), tf()); cmptMag(tRes.ref(), tf());
reuseTmpFieldField<Field, Type, Type>::clear(tf); tf.clear();
return tRes; return tRes;
} }
@ -685,7 +682,7 @@ operator op \
reuseTmpFieldField<Field, productType, Type2>::New(tf2) \ reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
); \ ); \
opFunc(tRes.ref(), f1, tf2()); \ opFunc(tRes.ref(), f1, tf2()); \
reuseTmpFieldField<Field, productType, Type2>::clear(tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -733,7 +730,7 @@ operator op \
reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \ reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \
); \ ); \
opFunc(tRes.ref(), tf1(), f2); \ opFunc(tRes.ref(), tf1(), f2); \
reuseTmpFieldField<Field1, productType, Type1>::clear(tf1); \ tf1.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -758,8 +755,8 @@ operator op \
(tf1, tf2) \ (tf1, tf2) \
); \ ); \
opFunc(tRes.ref(), tf1(), tf2()); \ opFunc(tRes.ref(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::clear \ tf1.clear(); \
(tf1, tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -811,7 +808,7 @@ operator op \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \ reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \ ); \
opFunc(tRes.ref(), tf1(), static_cast<const Form&>(vs)); \ opFunc(tRes.ref(), tf1(), static_cast<const Form&>(vs)); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \ tf1.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -863,7 +860,7 @@ operator op \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \ reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \ ); \
opFunc(tRes.ref(), static_cast<const Form&>(vs), tf1()); \ opFunc(tRes.ref(), static_cast<const Form&>(vs), tf1()); \
reuseTmpFieldField<Field, productType, Type>::clear(tf1); \ tf1.clear(); \
return tRes; \ return tRes; \
} }

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

@ -63,12 +63,9 @@ tmp<FieldField<Field, ReturnType>> Func \
const tmp<FieldField<Field, Type>>& tf \ const tmp<FieldField<Field, Type>>& tf \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tRes \ tmp<FieldField<Field, ReturnType>> tRes(New(tf)); \
( \
reuseTmpFieldField<Field, Type, Type>::New(tf) \
); \
Func(tRes.ref(), tf()); \ Func(tRes.ref(), tf()); \
reuseTmpFieldField<Field, Type, Type>::clear(tf); \ tf.clear(); \
return tRes; \ return tRes; \
} }
@ -110,12 +107,9 @@ tmp<FieldField<Field, ReturnType>> operator Op \
const tmp<FieldField<Field, Type>>& tf \ const tmp<FieldField<Field, Type>>& tf \
) \ ) \
{ \ { \
tmp<FieldField<Field, ReturnType>> tRes \ tmp<FieldField<Field, ReturnType>> tRes(New(tf)); \
( \
reuseTmpFieldField<Field, Type, Type>::New(tf) \
); \
OpFunc(tRes.ref(), tf()); \ OpFunc(tRes.ref(), tf()); \
reuseTmpFieldField<Field, Type, Type>::clear(tf); \ tf.clear(); \
return tRes; \ return tRes; \
} }
@ -165,7 +159,7 @@ tmp<FieldField<Field, ReturnType>> Func \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
Func(tRes.ref(), f1, tf2()); \ Func(tRes.ref(), f1, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -181,7 +175,7 @@ tmp<FieldField<Field, ReturnType>> Func \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
Func(tRes.ref(), tf1(), f2); \ Func(tRes.ref(), tf1(), f2); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ tf1.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -198,8 +192,8 @@ tmp<FieldField<Field, ReturnType>> Func \
New(tf1, tf2) \ New(tf1, tf2) \
); \ ); \
Func(tRes.ref(), tf1(), tf2()); \ Func(tRes.ref(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ tf1.clear(); \
clear(tf1, tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} }
@ -249,7 +243,7 @@ tmp<FieldField<Field, ReturnType>> Func \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
Func(tRes.ref(), tf1(), s); \ Func(tRes.ref(), tf1(), s); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ tf1.clear(); \
return tRes; \ return tRes; \
} }
@ -297,7 +291,7 @@ tmp<FieldField<Field, ReturnType>> Func \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
Func(tRes.ref(), s, tf2()); \ Func(tRes.ref(), s, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} }
@ -352,7 +346,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
OpFunc(tRes.ref(), f1, tf2()); \ OpFunc(tRes.ref(), f1, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -368,7 +362,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
OpFunc(tRes.ref(), tf1(), f2); \ OpFunc(tRes.ref(), tf1(), f2); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ tf1.clear(); \
return tRes; \ return tRes; \
} \ } \
\ \
@ -385,8 +379,8 @@ tmp<FieldField<Field, ReturnType>> operator Op \
New(tf1, tf2) \ New(tf1, tf2) \
); \ ); \
OpFunc(tRes.ref(), tf1(), tf2()); \ OpFunc(tRes.ref(), tf1(), tf2()); \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \ tf1.clear(); \
clear(tf1, tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} }
@ -436,7 +430,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \ reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \ ); \
OpFunc(tRes.ref(), s, tf2()); \ OpFunc(tRes.ref(), s, tf2()); \
reuseTmpFieldField<Field, ReturnType, Type2>::clear(tf2); \ tf2.clear(); \
return tRes; \ return tRes; \
} }
@ -484,7 +478,7 @@ tmp<FieldField<Field, ReturnType>> operator Op \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \ reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \ ); \
OpFunc(tRes.ref(), tf1(), s); \ OpFunc(tRes.ref(), tf1(), s); \
reuseTmpFieldField<Field, ReturnType, Type1>::clear(tf1); \ tf1.clear(); \
return tRes; \ return tRes; \
} }

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

@ -33,6 +33,34 @@ namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<template<class> class Field, class TypeR>
tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, TypeR>>& tf1,
const bool initRet = false
)
{
if (tf1.isTmp())
{
return tf1;
}
else
{
tmp<FieldField<Field, TypeR>> rtf
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
if (initRet)
{
rtf.ref() = tf1();
}
return rtf;
}
}
template<template<class> class Field, class TypeR, class Type1> template<template<class> class Field, class TypeR, class Type1>
class reuseTmpFieldField class reuseTmpFieldField
{ {
@ -48,11 +76,6 @@ public:
FieldField<Field, TypeR>::NewCalculatedType(tf1()) FieldField<Field, TypeR>::NewCalculatedType(tf1())
); );
} }
static void clear(const tmp<FieldField<Field, Type1>>& tf1)
{
tf1.clear();
}
}; };
@ -63,8 +86,7 @@ public:
static tmp<FieldField<Field, TypeR>> New static tmp<FieldField<Field, TypeR>> New
( (
const tmp<FieldField<Field, TypeR>>& tf1, const tmp<FieldField<Field, TypeR>>& tf1
const bool initRet = false
) )
{ {
if (tf1.isTmp()) if (tf1.isTmp())
@ -73,24 +95,12 @@ public:
} }
else else
{ {
tmp<FieldField<Field, TypeR>> rtf return tmp<FieldField<Field, TypeR>>
( (
FieldField<Field, TypeR>::NewCalculatedType(tf1()) FieldField<Field, TypeR>::NewCalculatedType(tf1())
); );
if (initRet)
{
rtf.ref() = tf1();
}
return rtf;
} }
} }
static void clear(const tmp<FieldField<Field, TypeR>>& tf1)
{
tf1.clear();
}
}; };
@ -117,16 +127,6 @@ public:
FieldField<Field, TypeR>::NewCalculatedType(tf1()) FieldField<Field, TypeR>::NewCalculatedType(tf1())
); );
} }
static void clear
(
const tmp<FieldField<Field, Type1>>& tf1,
const tmp<FieldField<Field, Type2>>& tf2
)
{
tf1.clear();
tf2.clear();
}
}; };
@ -153,16 +153,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<FieldField<Field, Type1>>& tf1,
const tmp<FieldField<Field, TypeR>>& tf2
)
{
tf1.clear();
tf2.clear();
}
}; };
@ -189,16 +179,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<FieldField<Field, TypeR>>& tf1,
const tmp<FieldField<Field, Type2>>& tf2
)
{
tf1.clear();
tf2.clear();
}
}; };
@ -229,16 +209,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<FieldField<Field, TypeR>>& tf1,
const tmp<FieldField<Field, TypeR>>& tf2
)
{
tf1.clear();
tf2.clear();
}
}; };

7
src/OpenFOAM/fields/FieldFields/scalarFieldField/scalarFieldField.C
View File

@ -173,12 +173,9 @@ tmp<FieldField<Field, scalar>> func \
const tmp<FieldField<Field, scalar>>& tsf \ const tmp<FieldField<Field, scalar>>& tsf \
) \ ) \
{ \ { \
tmp<FieldField<Field, scalar>> tRes \ tmp<FieldField<Field, scalar>> tRes(New(tsf)); \
( \
reuseTmpFieldField<Field, scalar, scalar>::New(tsf) \
); \
func(tRes(), n, tsf()); \ func(tRes(), n, tsf()); \
reuseTmpFieldField<Field, scalar, scalar>::clear(tsf); \ tsf.clear(); \
return tRes; \ return tRes; \
} }

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

@ -624,7 +624,7 @@ template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \ <class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
tmp \ tmp \
< \ < \
GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \ GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator op \
( \ ( \
@ -646,8 +646,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref(), gf1, gf2); \ Foam::opFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField<productType, Type2, PatchField, GeoMesh> \ tgf2.clear(); \
::clear(tgf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -656,7 +655,7 @@ template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \ <class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
tmp \ tmp \
< \ < \
GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \ GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator op \
( \ ( \
@ -678,8 +677,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref(), gf1, gf2); \ Foam::opFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField<productType, Type1, PatchField, GeoMesh> \ tgf1.clear(); \
::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -688,7 +686,7 @@ template \
<class Type1, class Type2, template<class> class PatchField, class GeoMesh> \ <class Type1, class Type2, template<class> class PatchField, class GeoMesh> \
tmp \ tmp \
< \ < \
GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \ GeometricField<typename product<Type1, Type2>::type, PatchField, GeoMesh> \
> \ > \
operator op \ operator op \
( \ ( \
@ -713,9 +711,8 @@ operator op \
\ \
Foam::opFunc(tRes.ref(), gf1, gf2); \ Foam::opFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpTmpGeometricField \ tgf1.clear(); \
<productType, Type1, Type1, Type2, PatchField, GeoMesh> \ tgf2.clear(); \
::clear(tgf1, tgf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -736,7 +733,7 @@ void opFunc \
\ \
template \ template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \ <class Form, class Type, template<class> class PatchField, class GeoMesh> \
tmp<GeometricField<typename product<Type, Form>::type, PatchField, GeoMesh>> \ tmp<GeometricField<typename product<Type, Form>::type, PatchField, GeoMesh>> \
operator op \ operator op \
( \ ( \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \ const GeometricField<Type, PatchField, GeoMesh>& gf1, \
@ -775,7 +772,7 @@ template \
class Type, template<class> class PatchField, \ class Type, template<class> class PatchField, \
class GeoMesh \ class GeoMesh \
> \ > \
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \ tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \ operator op \
( \ ( \
const GeometricField<Type, PatchField, GeoMesh>& gf1, \ const GeometricField<Type, PatchField, GeoMesh>& gf1, \
@ -788,7 +785,7 @@ operator op \
\ \
template \ template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \ <class Form, class Type, template<class> class PatchField, class GeoMesh> \
tmp<GeometricField<typename product<Type, Form>::type, PatchField, GeoMesh>> \ 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>>& tgf1, \
@ -809,8 +806,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref(), gf1, dvs); \ Foam::opFunc(tRes.ref(), gf1, dvs); \
\ \
reuseTmpGeometricField<productType, Type, PatchField, GeoMesh> \ tgf1.clear(); \
::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -823,7 +819,7 @@ template \
class Type, template<class> class PatchField, \ class Type, template<class> class PatchField, \
class GeoMesh \ class GeoMesh \
> \ > \
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \ 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>>& tgf1, \
@ -850,7 +846,7 @@ void opFunc \
\ \
template \ template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \ <class Form, class Type, template<class> class PatchField, class GeoMesh> \
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \ tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \ operator op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
@ -888,7 +884,7 @@ template \
class Type, template<class> class PatchField, \ class Type, template<class> class PatchField, \
class GeoMesh \ class GeoMesh \
> \ > \
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \ tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \ operator op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \
@ -900,7 +896,7 @@ operator op \
\ \
template \ template \
<class Form, class Type, template<class> class PatchField, class GeoMesh> \ <class Form, class Type, template<class> class PatchField, class GeoMesh> \
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \ tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \ operator op \
( \ ( \
const dimensioned<Form>& dvs, \ const dimensioned<Form>& dvs, \
@ -921,8 +917,7 @@ operator op \
\ \
Foam::opFunc(tRes.ref(), dvs, gf1); \ Foam::opFunc(tRes.ref(), dvs, gf1); \
\ \
reuseTmpGeometricField<productType, Type, PatchField, GeoMesh> \ tgf1.clear(); \
::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -935,7 +930,7 @@ template \
class Type, template<class> class PatchField, \ class Type, template<class> class PatchField, \
class GeoMesh \ class GeoMesh \
> \ > \
tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \ tmp<GeometricField<typename product<Form, Type>::type, PatchField, GeoMesh>> \
operator op \ operator op \
( \ ( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \ const VectorSpace<Form,Cmpt,nCmpt>& vs, \

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

@ -93,8 +93,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
\ \
Foam::Func(tRes.ref(), gf1); \ Foam::Func(tRes.ref(), gf1); \
\ \
reuseTmpGeometricField \ tgf1.clear(); \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} }
@ -163,8 +162,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref(), gf1); \ Foam::OpFunc(tRes.ref(), gf1); \
\ \
reuseTmpGeometricField \ tgf1.clear(); \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} }
@ -236,8 +234,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
\ \
Foam::Func(tRes.ref(), gf1, gf2); \ Foam::Func(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ tgf2.clear(); \
<ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -263,8 +260,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
\ \
Foam::Func(tRes.ref(), gf1, gf2); \ Foam::Func(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ tgf1.clear(); \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -294,9 +290,8 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
\ \
Foam::Func(tRes.ref(), gf1, gf2); \ Foam::Func(tRes.ref(), gf1, gf2); \
\ \
reuseTmpTmpGeometricField \ tgf1.clear(); \
<ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \ tgf2.clear(); \
::clear(tgf1, tgf2); \
\ \
return tRes; \ return tRes; \
} }
@ -378,8 +373,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
\ \
Foam::Func(tRes.ref(), dt1, gf2); \ Foam::Func(tRes.ref(), dt1, gf2); \
\ \
reuseTmpGeometricField \ tgf2.clear(); \
<ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -470,8 +464,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> Func \
\ \
Foam::Func(tRes.ref(), gf1, dt2); \ Foam::Func(tRes.ref(), gf1, dt2); \
\ \
reuseTmpGeometricField \ tgf1.clear(); \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -560,8 +553,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref(), gf1, gf2); \ Foam::OpFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ tgf2.clear(); \
<ReturnType, Type2, PatchField, GeoMesh>::clear(tgf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -587,8 +579,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref(), gf1, gf2); \ Foam::OpFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpGeometricField \ tgf1.clear(); \
<ReturnType, Type1, PatchField, GeoMesh>::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -617,9 +608,8 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref(), gf1, gf2); \ Foam::OpFunc(tRes.ref(), gf1, gf2); \
\ \
reuseTmpTmpGeometricField \ tgf1.clear(); \
<ReturnType, Type1, Type1, Type2, PatchField, GeoMesh> \ tgf2.clear(); \
::clear(tgf1, tgf2); \
\ \
return tRes; \ return tRes; \
} }
@ -702,8 +692,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref(), dt1, gf2); \ Foam::OpFunc(tRes.ref(), dt1, gf2); \
\ \
reuseTmpGeometricField<ReturnType, Type2, PatchField, GeoMesh> \ tgf2.clear(); \
::clear(tgf2); \
\ \
return tRes; \ return tRes; \
} \ } \
@ -794,8 +783,7 @@ tmp<GeometricField<ReturnType, PatchField, GeoMesh>> operator Op \
\ \
Foam::OpFunc(tRes.ref(), gf1, dt2); \ Foam::OpFunc(tRes.ref(), gf1, dt2); \
\ \
reuseTmpGeometricField<ReturnType, Type1, PatchField, GeoMesh> \ tgf1.clear(); \
::clear(tgf1); \
\ \
return tRes; \ return tRes; \
} \ } \

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

@ -75,6 +75,51 @@ bool reusable(const tmp<GeometricField<Type, PatchField, GeoMesh>>& tgf)
} }
template<class TypeR, template<class> class PatchField, class GeoMesh>
tmp<GeometricField<TypeR, PatchField, GeoMesh>> New
(
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
const word& name,
const dimensionSet& dimensions,
const bool initRet = false
)
{
GeometricField<TypeR, PatchField, GeoMesh>& gf1 =
const_cast<GeometricField<TypeR, PatchField, GeoMesh>& >(tgf1());
if (reusable(tgf1))
{
gf1.rename(name);
gf1.dimensions().reset(dimensions);
return tgf1;
}
else
{
tmp<GeometricField<TypeR, PatchField, GeoMesh>> rtgf
(
new GeometricField<TypeR, PatchField, GeoMesh>
(
IOobject
(
name,
gf1.instance(),
gf1.db()
),
gf1.mesh(),
dimensions
)
);
if (initRet)
{
rtgf.ref() == tgf1();
}
return rtgf;
}
}
template template
< <
class TypeR, class TypeR,
@ -110,14 +155,6 @@ public:
) )
); );
} }
static void clear
(
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1
)
{
tgf1.clear();
}
}; };
@ -130,8 +167,7 @@ public:
( (
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1, const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
const word& name, const word& name,
const dimensionSet& dimensions, const dimensionSet& dimensions
const bool initRet = false
) )
{ {
GeometricField<TypeR, PatchField, GeoMesh>& gf1 = GeometricField<TypeR, PatchField, GeoMesh>& gf1 =
@ -145,7 +181,7 @@ public:
} }
else else
{ {
tmp<GeometricField<TypeR, PatchField, GeoMesh>> rtgf return tmp<GeometricField<TypeR, PatchField, GeoMesh>>
( (
new GeometricField<TypeR, PatchField, GeoMesh> new GeometricField<TypeR, PatchField, GeoMesh>
( (
@ -159,23 +195,8 @@ public:
dimensions dimensions
) )
); );
if (initRet)
{
rtgf.ref() == tgf1();
}
return rtgf;
} }
} }
static void clear
(
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1
)
{
tgf1.clear();
}
}; };
@ -217,16 +238,6 @@ public:
) )
); );
} }
static void clear
(
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2
)
{
tgf1.clear();
tgf2.clear();
}
}; };
@ -279,16 +290,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<GeometricField<Type1, PatchField, GeoMesh>>& tgf1,
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2
)
{
tgf1.clear();
tgf2.clear();
}
}; };
@ -338,16 +339,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
const tmp<GeometricField<Type2, PatchField, GeoMesh>>& tgf2
)
{
tgf1.clear();
tgf2.clear();
}
}; };
@ -399,16 +390,6 @@ public:
); );
} }
} }
static void clear
(
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf1,
const tmp<GeometricField<TypeR, PatchField, GeoMesh>>& tgf2
)
{
tgf1.clear();
tgf2.clear();
}
}; };

51
src/OpenFOAM/fields/GeometricFields/GeometricScalarField/GeometricScalarField.C
View File

@ -89,7 +89,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> stabilise
tmp<GeometricField<scalar, PatchField, GeoMesh>> tRes tmp<GeometricField<scalar, PatchField, GeoMesh>> tRes
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf, tgsf,
"stabilise(" + gsf.name() + ',' + ds.name() + ')', "stabilise(" + gsf.name() + ',' + ds.name() + ')',
@ -99,7 +99,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> stabilise
stabilise(tRes.ref(), gsf, ds); stabilise(tRes.ref(), gsf, ds);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); tgsf.clear();
return tRes; return tRes;
} }
@ -176,7 +176,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf1, tgsf1,
"pow(" + gsf1.name() + ',' + gsf2.name() + ')', "pow(" + gsf1.name() + ',' + gsf2.name() + ')',
@ -190,7 +190,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
pow(tPow.ref(), gsf1, gsf2); pow(tPow.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf1); tgsf1.clear();
return tPow; return tPow;
} }
@ -207,7 +207,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf2, tgsf2,
"pow(" + gsf1.name() + ',' + gsf2.name() + ')', "pow(" + gsf1.name() + ',' + gsf2.name() + ')',
@ -221,7 +221,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
pow(tPow.ref(), gsf1, gsf2); pow(tPow.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf2); tgsf2.clear();
return tPow; return tPow;
} }
@ -254,9 +254,8 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
pow(tPow.ref(), gsf1, gsf2); pow(tPow.ref(), gsf1, gsf2);
reuseTmpTmpGeometricField tgsf1.clear();
<scalar, scalar, scalar, scalar, PatchField, GeoMesh> tgsf2.clear();
::clear(tgsf1, tgsf2);
return tPow; return tPow;
} }
@ -315,7 +314,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf, tgsf,
"pow(" + gsf.name() + ',' + ds.name() + ')', "pow(" + gsf.name() + ',' + ds.name() + ')',
@ -325,7 +324,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
pow(tPow.ref(), gsf, ds); pow(tPow.ref(), gsf, ds);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); tgsf.clear();
return tPow; return tPow;
} }
@ -405,7 +404,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow tmp<GeometricField<scalar, PatchField, GeoMesh>> tPow
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf, tgsf,
"pow(" + ds.name() + ',' + gsf.name() + ')', "pow(" + ds.name() + ',' + gsf.name() + ')',
@ -415,7 +414,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> pow
pow(tPow.ref(), ds, gsf); pow(tPow.ref(), ds, gsf);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); tgsf.clear();
return tPow; return tPow;
} }
@ -497,7 +496,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2 tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf1, tgsf1,
"atan2(" + gsf1.name() + ',' + gsf2.name() + ')', "atan2(" + gsf1.name() + ',' + gsf2.name() + ')',
@ -507,7 +506,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
atan2(tAtan2.ref(), gsf1, gsf2); atan2(tAtan2.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf1); tgsf1.clear();
return tAtan2; return tAtan2;
} }
@ -524,7 +523,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2 tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf2, tgsf2,
"atan2(" + gsf1.name() + ',' + gsf2.name() + ')', "atan2(" + gsf1.name() + ',' + gsf2.name() + ')',
@ -534,7 +533,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
atan2(tAtan2.ref(), gsf1, gsf2); atan2(tAtan2.ref(), gsf1, gsf2);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf2); tgsf2.clear();
return tAtan2; return tAtan2;
} }
@ -563,9 +562,8 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
atan2(tAtan2.ref(), gsf1, gsf2); atan2(tAtan2.ref(), gsf1, gsf2);
reuseTmpTmpGeometricField tgsf1.clear();
<scalar, scalar, scalar, scalar, PatchField, GeoMesh> tgsf2.clear();
::clear(tgsf1, tgsf2);
return tAtan2; return tAtan2;
} }
@ -624,7 +622,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2 tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf, tgsf,
"atan2(" + gsf.name() + ',' + ds.name() + ')', "atan2(" + gsf.name() + ',' + ds.name() + ')',
@ -634,7 +632,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
atan2(tAtan2.ref(), gsf, ds); atan2(tAtan2.ref(), gsf, ds);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); tgsf.clear();
return tAtan2; return tAtan2;
} }
@ -714,7 +712,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2 tmp<GeometricField<scalar, PatchField, GeoMesh>> tAtan2
( (
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New New
( (
tgsf, tgsf,
"atan2(" + ds.name() + ',' + gsf.name() + ')', "atan2(" + ds.name() + ',' + gsf.name() + ')',
@ -724,7 +722,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> atan2
atan2(tAtan2.ref(), ds, gsf); atan2(tAtan2.ref(), ds, gsf);
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::clear(tgsf); tgsf.clear();
return tAtan2; return tAtan2;
} }
@ -859,7 +857,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> func \
\ \
tmp<GeometricField<scalar, PatchField, GeoMesh>> tFunc \ tmp<GeometricField<scalar, PatchField, GeoMesh>> tFunc \
( \ ( \
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh>::New \ New \
( \ ( \
tgsf, \ tgsf, \
#func "(" + gsf.name() + ')', \ #func "(" + gsf.name() + ')', \
@ -869,8 +867,7 @@ tmp<GeometricField<scalar, PatchField, GeoMesh>> func \
\ \
func(tFunc.ref(), n, gsf); \ func(tFunc.ref(), n, gsf); \
\ \
reuseTmpGeometricField<scalar, scalar, PatchField, GeoMesh> \ tgsf.clear(); \
::clear(tgsf); \
\ \
return tFunc; \ return tFunc; \
} }

20
src/OpenFOAM/memory/tmp/tmpI.H
View File

@ -82,23 +82,23 @@ inline Foam::tmp<T>::tmp(const tmp<T>& t, bool allowTransfer)
{ {
if (isTmp()) if (isTmp())
{ {
if (allowTransfer) if (ptr_)
{ {
const_cast<tmp<T>&>(t).ptr_ = 0; if (allowTransfer)
}
else
{
if (ptr_)
{ {
ptr_->operator++(); t.ptr_ = 0;
} }
else else
{ {
FatalErrorInFunction ptr_->operator++();
<< "Attempted copy of a deallocated " << typeName()
<< abort(FatalError);
} }
} }
else
{
FatalErrorInFunction
<< "Attempted copy of a deallocated " << typeName()
<< abort(FatalError);
}
} }
} }

19
src/finiteVolume/cfdTools/general/MRF/MRFZoneList.C
View File

@ -228,8 +228,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::MRFZoneList::relative
{ {
tmp<surfaceScalarField> rphi tmp<surfaceScalarField> rphi
( (
reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh> New
::New
( (
tphi, tphi,
"relative(" + tphi().name() + ')', "relative(" + tphi().name() + ')',
@ -240,8 +239,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::MRFZoneList::relative
makeRelative(rphi.ref()); makeRelative(rphi.ref());
reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh> tphi.clear();
::clear(tphi);
return rphi; return rphi;
} }
@ -260,17 +258,14 @@ Foam::MRFZoneList::relative
{ {
if (size()) if (size())
{ {
tmp<FieldField<fvsPatchField, scalar>> rphi tmp<FieldField<fvsPatchField, scalar>> rphi(New(tphi, true));
(
reuseTmpFieldField<fvsPatchField, scalar, scalar>::New(tphi, true)
);
forAll(*this, i) forAll(*this, i)
{ {
operator[](i).makeRelative(rphi.ref()); operator[](i).makeRelative(rphi.ref());
} }
reuseTmpFieldField<fvsPatchField, scalar, scalar>::clear(tphi); tphi.clear();
return rphi; return rphi;
} }
@ -348,8 +343,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::MRFZoneList::absolute
{ {
tmp<surfaceScalarField> rphi tmp<surfaceScalarField> rphi
( (
reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh> New
::New
( (
tphi, tphi,
"absolute(" + tphi().name() + ')', "absolute(" + tphi().name() + ')',
@ -360,8 +354,7 @@ Foam::tmp<Foam::surfaceScalarField> Foam::MRFZoneList::absolute
makeAbsolute(rphi.ref()); makeAbsolute(rphi.ref());
reuseTmpGeometricField<scalar, scalar, fvsPatchField, surfaceMesh> tphi.clear();
::clear(tphi);
return rphi; return rphi;
} }