From e9ba8242caea8d987508acff865e5f479627693d Mon Sep 17 00:00:00 2001
From: Henry Weller <http://cfd.direct>
Date: Wed, 12 Apr 2017 14:33:45 +0100
Subject: [PATCH] FieldFieldFunctionsM: Corrected macro names and order for
 binary functions

---
 .../FieldField/FieldFieldFunctionsM.C         | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
index a32972d21a1..4160f382ab8 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -206,44 +206,44 @@ TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
     FieldField<Field, ReturnType>& f,                                          \
-    const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type1& s,                                                            \
+    const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
     forAll(f, i)                                                               \
     {                                                                          \
-        Func(f[i], f1[i], s);                                                  \
+        Func(f[i], s, f2[i]);                                                  \
     }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const FieldField<Field, Type1>& f1,                                        \
-    const Type2& s                                                             \
+    const Type1& s,                                                            \
+    const FieldField<Field, Type2>& f2                                         \
 )                                                                              \
 {                                                                              \
     tmp<FieldField<Field, ReturnType>> tRes                                    \
     (                                                                          \
-        FieldField<Field, Type1>::NewCalculatedType(f1)                        \
+        FieldField<Field, Type2>::NewCalculatedType(f2)                        \
     );                                                                         \
-    Func(tRes.ref(), f1, s);                                                   \
+    Func(tRes.ref(), s, f2);                                                   \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const tmp<FieldField<Field, Type1>>& tf1,                                  \
-    const Type2& s                                                             \
+    const Type1& s,                                                            \
+    const tmp<FieldField<Field, Type2>>& tf2                                   \
 )                                                                              \
 {                                                                              \
     tmp<FieldField<Field, ReturnType>> tRes                                    \
     (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1)                 \
+        reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)                 \
     );                                                                         \
-    Func(tRes.ref(), tf1(), s);                                                \
-    tf1.clear();                                                               \
+    Func(tRes.ref(), s, tf2());                                                \
+    tf2.clear();                                                               \
     return tRes;                                                               \
 }
 
@@ -254,44 +254,44 @@ TEMPLATE                                                                       \
 void Func                                                                      \
 (                                                                              \
     FieldField<Field, ReturnType>& f,                                          \
-    const Type1& s,                                                            \
-    const FieldField<Field, Type2>& f2                                         \
+    const FieldField<Field, Type1>& f1,                                        \
+    const Type2& s                                                             \
 )                                                                              \
 {                                                                              \
     forAll(f, i)                                                               \
     {                                                                          \
-        Func(f[i], s, f2[i]);                                                  \
+        Func(f[i], f1[i], s);                                                  \
     }                                                                          \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const Type1& s,                                                            \
-    const FieldField<Field, Type2>& f2                                         \
+    const FieldField<Field, Type1>& f1,                                        \
+    const Type2& s                                                             \
 )                                                                              \
 {                                                                              \
     tmp<FieldField<Field, ReturnType>> tRes                                    \
     (                                                                          \
-        FieldField<Field, Type2>::NewCalculatedType(f2)                        \
+        FieldField<Field, Type1>::NewCalculatedType(f1)                        \
     );                                                                         \
-    Func(tRes.ref(), s, f2);                                                   \
+    Func(tRes.ref(), f1, s);                                                   \
     return tRes;                                                               \
 }                                                                              \
                                                                                \
 TEMPLATE                                                                       \
 tmp<FieldField<Field, ReturnType>> Func                                        \
 (                                                                              \
-    const Type1& s,                                                            \
-    const tmp<FieldField<Field, Type2>>& tf2                                   \
+    const tmp<FieldField<Field, Type1>>& tf1,                                  \
+    const Type2& s                                                             \
 )                                                                              \
 {                                                                              \
     tmp<FieldField<Field, ReturnType>> tRes                                    \
     (                                                                          \
-        reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2)                 \
+        reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1)                 \
     );                                                                         \
-    Func(tRes.ref(), s, tf2());                                                \
-    tf2.clear();                                                               \
+    Func(tRes.ref(), tf1(), s);                                                \
+    tf1.clear();                                                               \
     return tRes;                                                               \
 }
 
-- 
GitLab