From 85fa6c2649535b78b502fa35ca62b77905b028f3 Mon Sep 17 00:00:00 2001
From: Henry Weller <http://cfd.direct>
Date: Thu, 25 Feb 2016 15:07:14 +0000
Subject: [PATCH] Field: Simplified tmp reuse and cleanup

---
 .../fields/Fields/Field/FieldFunctions.C      | 29 +++---
 .../fields/Fields/Field/FieldFunctionsM.C     | 26 +++---
 .../fields/Fields/Field/FieldReuseFunctions.H | 90 ++++++-------------
 .../fields/Fields/scalarField/scalarField.C   |  8 +-
 .../Fields/symmTensorField/symmTensorField.C  |  4 +-
 .../symmTransformField/symmTransformField.C   | 12 +--
 .../fields/Fields/tensorField/tensorField.C   |  4 +-
 .../Fields/transformField/transformField.C    |  8 +-
 .../transformField/transformFieldTemplates.C  | 12 +--
 .../cfdTools/general/MRF/MRFZoneList.C        |  7 +-
 10 files changed, 82 insertions(+), 118 deletions(-)

diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
index f927266195..d2b3e2d6b1 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
@@ -102,7 +102,7 @@ pow
     typedef typename powProduct<Type, r>::type powProductType;
     tmp<Field<powProductType>> tRes = reuseTmp<powProductType, Type>::New(tf);
     pow<Type, r>(tRes.ref(), tf());
-    reuseTmp<powProductType, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -139,7 +139,7 @@ sqr(const tmp<Field<Type>>& tf)
     tmp<Field<outerProductType>> tRes =
         reuseTmp<outerProductType, Type>::New(tf);
     sqr(tRes.ref(), tf());
-    reuseTmp<outerProductType, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -163,7 +163,7 @@ tmp<Field<scalar>> magSqr(const tmp<Field<Type>>& tf)
 {
     tmp<Field<scalar>> tRes = reuseTmp<scalar, Type>::New(tf);
     magSqr(tRes.ref(), tf());
-    reuseTmp<scalar, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -187,7 +187,7 @@ tmp<Field<scalar>> mag(const tmp<Field<Type>>& tf)
 {
     tmp<Field<scalar>> tRes = reuseTmp<scalar, Type>::New(tf);
     mag(tRes.ref(), tf());
-    reuseTmp<scalar, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -214,7 +214,7 @@ tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf)
     typedef typename Field<Type>::cmptType cmptType;
     tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
     cmptMax(tRes.ref(), tf());
-    reuseTmp<cmptType, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -241,7 +241,7 @@ tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf)
     typedef typename Field<Type>::cmptType cmptType;
     tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
     cmptMin(tRes.ref(), tf());
-    reuseTmp<cmptType, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -268,7 +268,7 @@ tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf)
     typedef typename Field<Type>::cmptType cmptType;
     tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
     cmptAv(tRes.ref(), tf());
-    reuseTmp<cmptType, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -290,9 +290,9 @@ tmp<Field<Type>> cmptMag(const UList<Type>& f)
 template<class Type>
 tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf)
 {
-    tmp<Field<Type>> tRes = reuseTmp<Type, Type>::New(tf);
+    tmp<Field<Type>> tRes = New(tf);
     cmptMag(tRes.ref(), tf());
-    reuseTmp<Type, Type>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
@@ -664,7 +664,7 @@ operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2)              \
     typedef typename product<Type1, Type2>::type productType;                  \
     tmp<Field<productType>> tRes = reuseTmp<productType, Type2>::New(tf2);     \
     OpFunc(tRes.ref(), f1, tf2());                                             \
-    reuseTmp<productType, Type2>::clear(tf2);                                  \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -675,7 +675,7 @@ operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2)              \
     typedef typename product<Type1, Type2>::type productType;                  \
     tmp<Field<productType>> tRes = reuseTmp<productType, Type1>::New(tf1);     \
     OpFunc(tRes.ref(), tf1(), f2);                                             \
-    reuseTmp<productType, Type1>::clear(tf1);                                  \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -687,7 +687,8 @@ operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2)        \
     tmp<Field<productType>> tRes =                                             \
         reuseTmpTmp<productType, Type1, Type1, Type2>::New(tf1, tf2);          \
     OpFunc(tRes.ref(), tf1(), tf2());                                          \
-    reuseTmpTmp<productType, Type1, Type1, Type2>::clear(tf1, tf2);            \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -725,7 +726,7 @@ operator Op                                                                    \
     typedef typename product<Type, Form>::type productType;                    \
     tmp<Field<productType>> tRes = reuseTmp<productType, Type>::New(tf1);      \
     OpFunc(tRes.ref(), tf1(), static_cast<const Form&>(vs));                   \
-    reuseTmp<productType, Type>::clear(tf1);                                   \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -762,7 +763,7 @@ operator Op                                                                    \
     typedef typename product<Form, Type>::type productType;                    \
     tmp<Field<productType>> tRes = reuseTmp<productType, Type>::New(tf1);      \
     OpFunc(tRes.ref(), static_cast<const Form&>(vs), tf1());                   \
-    reuseTmp<productType, Type>::clear(tf1);                                   \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }
 
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
index c4a7ff6c03..f286d319f0 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
+++ b/src/OpenFOAM/fields/Fields/Field/FieldFunctionsM.C
@@ -49,7 +49,7 @@ tmp<Field<ReturnType>> Func(const tmp<Field<Type>>& tf)                        \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type>::New(tf);         \
     Func(tRes.ref(), tf());                                                    \
-    reuseTmp<ReturnType, Type>::clear(tf);                                     \
+    tf.clear();                                                                \
     return tRes;                                                               \
 }
 
@@ -77,7 +77,7 @@ tmp<Field<ReturnType>> operator Op(const tmp<Field<Type>>& tf)                 \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type>::New(tf);         \
     OpFunc(tRes.ref(), tf());                                                  \
-    reuseTmp<ReturnType, Type>::clear(tf);                                     \
+    tf.clear();                                                                \
     return tRes;                                                               \
 }
 
@@ -121,7 +121,7 @@ tmp<Field<ReturnType>> Func                                                    \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type2>::New(tf2);       \
     Func(tRes.ref(), f1, tf2());                                               \
-    reuseTmp<ReturnType, Type2>::clear(tf2);                                   \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -134,7 +134,7 @@ tmp<Field<ReturnType>> Func                                                    \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type1>::New(tf1);       \
     Func(tRes.ref(), tf1(), f2);                                               \
-    reuseTmp<ReturnType, Type1>::clear(tf1);                                   \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -148,7 +148,8 @@ tmp<Field<ReturnType>> Func                                                    \
     tmp<Field<ReturnType>> tRes =                                              \
         reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2);           \
     Func(tRes.ref(), tf1(), tf2());                                            \
-    reuseTmpTmp<ReturnType, Type1, Type1, Type2>::clear(tf1, tf2);             \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }
 
@@ -192,7 +193,7 @@ tmp<Field<ReturnType>> Func                                                    \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type2>::New(tf2);       \
     Func(tRes.ref(), s1, tf2());                                               \
-    reuseTmp<ReturnType, Type2>::clear(tf2);                                   \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }
 
@@ -234,7 +235,7 @@ tmp<Field<ReturnType>> Func                                                    \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type1>::New(tf1);       \
     Func(tRes.ref(), tf1(), s2);                                               \
-    reuseTmp<ReturnType, Type1>::clear(tf1);                                   \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }
 
@@ -280,7 +281,7 @@ tmp<Field<ReturnType>> operator Op                                             \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type2>::New(tf2);       \
     OpFunc(tRes.ref(), f1, tf2());                                             \
-    reuseTmp<ReturnType, Type2>::clear(tf2);                                   \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -293,7 +294,7 @@ tmp<Field<ReturnType>> operator Op                                             \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type1>::New(tf1);       \
     OpFunc(tRes.ref(), tf1(), f2);                                             \
-    reuseTmp<ReturnType, Type1>::clear(tf1);                                   \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
@@ -307,7 +308,8 @@ tmp<Field<ReturnType>> operator Op                                             \
     tmp<Field<ReturnType>> tRes =                                              \
         reuseTmpTmp<ReturnType, Type1, Type1, Type2>::New(tf1, tf2);           \
     OpFunc(tRes.ref(), tf1(), tf2());                                          \
-    reuseTmpTmp<ReturnType, Type1, Type1, Type2>::clear(tf1, tf2);             \
+    tf1.clear();                                                               \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }
 
@@ -348,7 +350,7 @@ tmp<Field<ReturnType>> operator Op                                             \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type2>::New(tf2);       \
     OpFunc(tRes.ref(), s1, tf2());                                             \
-    reuseTmp<ReturnType, Type2>::clear(tf2);                                   \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }
 
@@ -387,7 +389,7 @@ tmp<Field<ReturnType>> operator Op                                             \
 {                                                                              \
     tmp<Field<ReturnType>> tRes = reuseTmp<ReturnType, Type1>::New(tf1);       \
     OpFunc(tRes.ref(), tf1(), s2);                                             \
-    reuseTmp<ReturnType, Type1>::clear(tf1);                                   \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }
 
diff --git a/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H b/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
index 4eedccdc43..fac9e9a51c 100644
--- a/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
+++ b/src/OpenFOAM/fields/Fields/Field/FieldReuseFunctions.H
@@ -33,6 +33,31 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+template<class TypeR>
+tmp<Field<TypeR>> New
+(
+    const tmp<Field<TypeR>>& tf1,
+    const bool initRet = false
+)
+{
+    if (tf1.isTmp())
+    {
+        return tf1;
+    }
+    else
+    {
+        tmp<Field<TypeR>> rtf(new Field<TypeR>(tf1().size()));
+
+        if (initRet)
+        {
+            rtf.ref() = tf1();
+        }
+
+        return rtf;
+    }
+}
+
+
 template<class TypeR, class Type1>
 class reuseTmp
 {
@@ -42,11 +67,6 @@ public:
     {
         return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
     }
-
-    static void clear(const tmp<Field<Type1>>& tf1)
-    {
-        tf1.clear();
-    }
 };
 
 
@@ -55,11 +75,7 @@ class reuseTmp<TypeR, TypeR>
 {
 public:
 
-    static tmp<Field<TypeR>> New
-    (
-        const tmp<Field<TypeR>>& tf1,
-        const bool initRet = false
-    )
+    static tmp<Field<TypeR>> New(const tmp<Field<TypeR>>& tf1)
     {
         if (tf1.isTmp())
         {
@@ -67,21 +83,9 @@ public:
         }
         else
         {
-            tmp<Field<TypeR>> rtf(new Field<TypeR>(tf1().size()));
-
-            if (initRet)
-            {
-                rtf.ref() = tf1();
-            }
-
-            return rtf;
+            return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
         }
     }
-
-    static void clear(const tmp<Field<TypeR>>& tf1)
-    {
-        tf1.clear();
-    }
 };
 
 
@@ -98,16 +102,6 @@ public:
     {
         return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
     }
-
-    static void clear
-    (
-        const tmp<Field<Type1>>& tf1,
-        const tmp<Field<Type2>>& tf2
-    )
-    {
-        tf1.clear();
-        tf2.clear();
-    }
 };
 
 
@@ -131,16 +125,6 @@ public:
             return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
         }
     }
-
-    static void clear
-    (
-        const tmp<Field<Type1>>& tf1,
-        const tmp<Field<TypeR>>& tf2
-    )
-    {
-        tf1.clear();
-        tf2.clear();
-    }
 };
 
 
@@ -164,16 +148,6 @@ public:
             return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
         }
     }
-
-    static void clear
-    (
-        const tmp<Field<TypeR>>& tf1,
-        const tmp<Field<Type2>>& tf2
-    )
-    {
-        tf1.clear();
-        tf2.clear();
-    }
 };
 
 
@@ -201,16 +175,6 @@ public:
             return tmp<Field<TypeR>>(new Field<TypeR>(tf1().size()));
         }
     }
-
-    static void clear
-    (
-        const tmp<Field<TypeR>>& tf1,
-        const tmp<Field<TypeR>>& tf2
-    )
-    {
-        tf1.clear();
-        tf2.clear();
-    }
 };
 
 
diff --git a/src/OpenFOAM/fields/Fields/scalarField/scalarField.C b/src/OpenFOAM/fields/Fields/scalarField/scalarField.C
index 875e610cb7..0aac998c8d 100644
--- a/src/OpenFOAM/fields/Fields/scalarField/scalarField.C
+++ b/src/OpenFOAM/fields/Fields/scalarField/scalarField.C
@@ -80,9 +80,9 @@ tmp<scalarField> stabilise(const UList<scalar>& sf, const scalar s)
 
 tmp<scalarField> stabilise(const tmp<scalarField>& tsf, const scalar s)
 {
-    tmp<scalarField> tRes = reuseTmp<scalar, scalar>::New(tsf);
+    tmp<scalarField> tRes = New(tsf);
     stabilise(tRes.ref(), tsf(), s);
-    reuseTmp<scalar, scalar>::clear(tsf);
+    tsf.clear();
     return tRes;
 }
 
@@ -179,9 +179,9 @@ tmp<scalarField> func(const int n, const UList<scalar>& sf)                    \
                                                                                \
 tmp<scalarField> func(const int n, const tmp<scalarField>& tsf)                \
 {                                                                              \
-    tmp<scalarField> tRes = reuseTmp<scalar, scalar>::New(tsf);                \
+    tmp<scalarField> tRes = New(tsf);                                          \
     func(tRes.ref(), n, tsf());                                                \
-    reuseTmp<scalar, scalar>::clear(tsf);                                      \
+    tsf.clear();                                                               \
     return tRes;                                                               \
 }
 
diff --git a/src/OpenFOAM/fields/Fields/symmTensorField/symmTensorField.C b/src/OpenFOAM/fields/Fields/symmTensorField/symmTensorField.C
index 6304130a71..c50ab3daa4 100644
--- a/src/OpenFOAM/fields/Fields/symmTensorField/symmTensorField.C
+++ b/src/OpenFOAM/fields/Fields/symmTensorField/symmTensorField.C
@@ -114,9 +114,9 @@ tmp<symmTensorField> inv(const UList<symmTensor>& tf)
 
 tmp<symmTensorField> inv(const tmp<symmTensorField>& tf)
 {
-    tmp<symmTensorField> tRes = reuseTmp<symmTensor, symmTensor>::New(tf);
+    tmp<symmTensorField> tRes = New(tf);
     inv(tRes.ref(), tf());
-    reuseTmp<symmTensor, symmTensor>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
diff --git a/src/OpenFOAM/fields/Fields/symmTransformField/symmTransformField.C b/src/OpenFOAM/fields/Fields/symmTransformField/symmTransformField.C
index 1b6c52bb14..e1b19cf8df 100644
--- a/src/OpenFOAM/fields/Fields/symmTransformField/symmTransformField.C
+++ b/src/OpenFOAM/fields/Fields/symmTransformField/symmTransformField.C
@@ -75,9 +75,9 @@ tmp<Field<Type>> transform
     const tmp<Field<Type>>& ttf
 )
 {
-    tmp<Field<Type>> tranf = reuseTmp<Type, Type>::New(ttf);
+    tmp<Field<Type>> tranf = New(ttf);
     transform(tranf.ref(), trf, ttf());
-    reuseTmp<Type, Type>::clear(ttf);
+    ttf.clear();
     return tranf;
 }
 
@@ -103,9 +103,9 @@ tmp<Field<Type>> transform
     const tmp<Field<Type>>& ttf
 )
 {
-    tmp<Field<Type>> tranf = reuseTmp<Type, Type>::New(ttf);
+    tmp<Field<Type>> tranf = New(ttf);
     transform(tranf.ref(), ttrf(), ttf());
-    reuseTmp<Type, Type>::clear(ttf);
+    ttf.clear();
     ttrf.clear();
     return tranf;
 }
@@ -143,9 +143,9 @@ tmp<Field<Type>> transform
     const tmp<Field<Type>>& ttf
 )
 {
-    tmp<Field<Type>> tranf = reuseTmp<Type, Type>::New(ttf);
+    tmp<Field<Type>> tranf = New(ttf);
     transform(tranf.ref(), t, ttf());
-    reuseTmp<Type, Type>::clear(ttf);
+    ttf.clear();
     return tranf;
 }
 
diff --git a/src/OpenFOAM/fields/Fields/tensorField/tensorField.C b/src/OpenFOAM/fields/Fields/tensorField/tensorField.C
index a85f6052ea..45ea27e12c 100644
--- a/src/OpenFOAM/fields/Fields/tensorField/tensorField.C
+++ b/src/OpenFOAM/fields/Fields/tensorField/tensorField.C
@@ -112,9 +112,9 @@ tmp<tensorField> inv(const UList<tensor>& tf)
 
 tmp<tensorField> inv(const tmp<tensorField>& tf)
 {
-    tmp<tensorField> tRes = reuseTmp<tensor, tensor>::New(tf);
+    tmp<tensorField> tRes = New(tf);
     inv(tRes.ref(), tf());
-    reuseTmp<tensor, tensor>::clear(tf);
+    tf.clear();
     return tRes;
 }
 
diff --git a/src/OpenFOAM/fields/Fields/transformField/transformField.C b/src/OpenFOAM/fields/Fields/transformField/transformField.C
index d548c90260..4d35792d73 100644
--- a/src/OpenFOAM/fields/Fields/transformField/transformField.C
+++ b/src/OpenFOAM/fields/Fields/transformField/transformField.C
@@ -59,9 +59,9 @@ Foam::tmp<Foam::vectorField> Foam::transform
     const tmp<vectorField>& ttf
 )
 {
-    tmp<vectorField > tranf = reuseTmp<vector, vector>::New(ttf);
+    tmp<vectorField > tranf = New(ttf);
     transform(tranf.ref(), q, ttf());
-    reuseTmp<vector, vector>::clear(ttf);
+    ttf.clear();
     return tranf;
 }
 
@@ -117,9 +117,9 @@ Foam::tmp<Foam::vectorField> Foam::transform
     const tmp<vectorField>& ttf
 )
 {
-    tmp<vectorField > tranf = reuseTmp<vector, vector>::New(ttf);
+    tmp<vectorField > tranf = New(ttf);
     transform(tranf.ref(), tr, ttf());
-    reuseTmp<vector, vector>::clear(ttf);
+    ttf.clear();
     return tranf;
 }
 
diff --git a/src/OpenFOAM/fields/Fields/transformField/transformFieldTemplates.C b/src/OpenFOAM/fields/Fields/transformField/transformFieldTemplates.C
index 985054bede..7e87d7af92 100644
--- a/src/OpenFOAM/fields/Fields/transformField/transformFieldTemplates.C
+++ b/src/OpenFOAM/fields/Fields/transformField/transformFieldTemplates.C
@@ -75,9 +75,9 @@ tmp<Field<Type>> transform
     const tmp<Field<Type>>& ttf
 )
 {
-    tmp<Field<Type>> tranf = reuseTmp<Type, Type>::New(ttf);
+    tmp<Field<Type>> tranf = New(ttf);
     transform(tranf.ref(), trf, ttf());
-    reuseTmp<Type, Type>::clear(ttf);
+    ttf.clear();
     return tranf;
 }
 
@@ -103,9 +103,9 @@ tmp<Field<Type>> transform
     const tmp<Field<Type>>& ttf
 )
 {
-    tmp<Field<Type>> tranf = reuseTmp<Type, Type>::New(ttf);
+    tmp<Field<Type>> tranf = New(ttf);
     transform(tranf.ref(), ttrf(), ttf());
-    reuseTmp<Type, Type>::clear(ttf);
+    ttf.clear();
     ttrf.clear();
     return tranf;
 }
@@ -143,9 +143,9 @@ tmp<Field<Type>> transform
     const tmp<Field<Type>>& ttf
 )
 {
-    tmp<Field<Type>> tranf = reuseTmp<Type, Type>::New(ttf);
+    tmp<Field<Type>> tranf = New(ttf);
     transform(tranf.ref(), t, ttf());
-    reuseTmp<Type, Type>::clear(ttf);
+    ttf.clear();
     return tranf;
 }
 
diff --git a/src/finiteVolume/cfdTools/general/MRF/MRFZoneList.C b/src/finiteVolume/cfdTools/general/MRF/MRFZoneList.C
index a4b099b6cb..5e31ac1269 100644
--- a/src/finiteVolume/cfdTools/general/MRF/MRFZoneList.C
+++ b/src/finiteVolume/cfdTools/general/MRF/MRFZoneList.C
@@ -290,17 +290,14 @@ Foam::MRFZoneList::relative
 {
     if (size())
     {
-        tmp<Field<scalar>> rphi
-        (
-            reuseTmp<scalar, scalar>::New(tphi, true)
-        );
+        tmp<Field<scalar>> rphi(New(tphi, true));
 
         forAll(*this, i)
         {
             operator[](i).makeRelative(rphi.ref(), patchi);
         }
 
-        reuseTmp<scalar, scalar>::clear(tphi);
+        tphi.clear();
 
         return rphi;
     }