diff --git a/etc/codeTemplates/dynamicCode/Function1Template.H b/etc/codeTemplates/dynamicCode/Function1Template.H
index d7da5a2139..f7624d7429 100644
--- a/etc/codeTemplates/dynamicCode/Function1Template.H
+++ b/etc/codeTemplates/dynamicCode/Function1Template.H
@@ -93,7 +93,7 @@ public:
 
     // Member Functions
 
-        //- Return constant value
+        //- Return value as a function of scalar variable
         inline virtual ${TemplateType} value(const scalar x) const
         {
 //{{{ begin code
diff --git a/etc/codeTemplates/dynamicCode/Function2Template.C b/etc/codeTemplates/dynamicCode/Function2Template.C
new file mode 100644
index 0000000000..5214542e4e
--- /dev/null
+++ b/etc/codeTemplates/dynamicCode/Function2Template.C
@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) YEAR OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Function2Template.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Function2s
+{
+    defineTypeNameAndDebug(${typeName}Function2${TemplateType}, 0);
+}
+    Function2<${TemplateType}>::adddictionaryConstructorToTable<Function2s::
+        ${typeName}Function2${TemplateType}>
+        ${typeName}Function2${TemplateType}ConstructorToTable_;
+}
+
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+extern "C"
+{
+    // dynamicCode:
+    // SHA1 = ${SHA1sum}
+    //
+    // Unique function name that can be checked if the correct library version
+    // has been loaded
+    void ${typeName}_${SHA1sum}(bool load)
+    {
+        if (load)
+        {
+            // code that can be explicitly executed after loading
+        }
+        else
+        {
+            // code that can be explicitly executed before unloading
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::Function2s::${typeName}Function2${TemplateType}::
+${typeName}Function2${TemplateType}
+(
+    const word& entryName,
+    const dictionary& dict
+)
+:
+    FieldFunction2<${TemplateType}, ${typeName}Function2${TemplateType}>
+    (
+        entryName
+    )
+{
+    if (${verbose:-false})
+    {
+        Info<< "Construct ${typeName} sha1: ${SHA1sum} from dictionary\n";
+    }
+}
+
+
+Foam::Function2s::${typeName}Function2${TemplateType}::
+${typeName}Function2${TemplateType}
+(
+    const ${typeName}Function2${TemplateType}& f1
+)
+:
+    FieldFunction2<${TemplateType}, ${typeName}Function2${TemplateType}>
+    (
+        f1
+    )
+{
+    if (${verbose:-false})
+    {
+        Info<< "Construct ${typeName} sha1: ${SHA1sum} as copy\n";
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::Function2s::${typeName}Function2${TemplateType}::
+~${typeName}Function2${TemplateType}()
+{
+    if (${verbose:-false})
+    {
+        Info<< "Destroy ${typeName} sha1: ${SHA1sum}\n";
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::Function2s::${typeName}Function2${TemplateType}::writeData
+(
+    Ostream& os
+) const
+{
+    NotImplemented;
+}
+
+
+// ************************************************************************* i/
diff --git a/etc/codeTemplates/dynamicCode/Function2Template.H b/etc/codeTemplates/dynamicCode/Function2Template.H
new file mode 100644
index 0000000000..742c71a628
--- /dev/null
+++ b/etc/codeTemplates/dynamicCode/Function2Template.H
@@ -0,0 +1,128 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) YEAR OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Description
+    Template for use with dynamic code generation of a Function2.
+
+    - without state
+
+SourceFiles
+    Function2Template.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Function2Template_H
+#define Function2Template_H
+
+#include "Function2.H"
+
+//{{{ begin codeInclude
+${codeInclude}
+//}}} end codeInclude
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Function2s
+{
+
+/*---------------------------------------------------------------------------*\
+                           A templated Function2
+\*---------------------------------------------------------------------------*/
+
+class ${typeName}Function2${TemplateType}
+:
+    public FieldFunction2<${TemplateType}, ${typeName}Function2${TemplateType}>
+{
+
+public:
+
+    // Runtime type information
+    TypeName("${typeName}");
+
+
+    // Constructors
+
+        //- Construct from entry name and dictionary
+        ${typeName}Function2${TemplateType}
+        (
+            const word& entryName,
+            const dictionary& dict
+        );
+
+        //- Copy constructor
+        ${typeName}Function2${TemplateType}
+        (
+            const ${typeName}Function2${TemplateType}& f1
+        );
+
+        //- Construct and return a clone
+        virtual tmp<Function2<${TemplateType}>> clone() const
+        {
+            return tmp<Function2<${TemplateType}>>
+            (
+                new ${typeName}Function2${TemplateType}(*this)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~${typeName}Function2${TemplateType}();
+
+
+    // Member Functions
+
+        //- Return value as a function of two scalars
+        inline virtual ${TemplateType} value
+        (
+            const scalar x,
+            const scalar y
+        ) const
+        {
+//{{{ begin code
+    ${code}
+//}}} end code
+        }
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const ${typeName}Function2${TemplateType}&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Function2s
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index cafea9e161..9c4167ba7e 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -99,6 +99,8 @@ primitives/functions/Function1/halfCosineRamp/halfCosineRamp.C
 primitives/functions/Function1/Table/tableBase.C
 primitives/functions/Function1/TableFile/TableReader/makeTableReaders.C
 
+primitives/functions/Function2/makeFunction2s.C
+
 primitives/subModelBase/subModelBase.C
 
 strings = primitives/strings
diff --git a/src/OpenFOAM/primitives/functions/Function1/Coded/CodedFunction1.H b/src/OpenFOAM/primitives/functions/Function1/Coded/CodedFunction1.H
index 97791378b6..31344b0e53 100644
--- a/src/OpenFOAM/primitives/functions/Function1/Coded/CodedFunction1.H
+++ b/src/OpenFOAM/primitives/functions/Function1/Coded/CodedFunction1.H
@@ -145,16 +145,16 @@ public:
 
     // Member Functions
 
-        //- Return value
+        //- Return value as a function of a scalar
         virtual inline Type value(const scalar x) const;
 
-        //- Return value as a function of (scalar) independent variable
+        //- Return value as a function of a scalar field
         virtual tmp<Field<Type>> value(const scalarField& x) const;
 
-        //- Integrate between two values
+        //- Integrate between two scalars
         virtual Type integrate(const scalar x1, const scalar x2) const;
 
-        //- Integrate between two (scalar) values
+        //- Integrate between two scalar fields
         virtual tmp<Field<Type>> integrate
         (
             const scalarField& x1,
diff --git a/src/OpenFOAM/primitives/functions/Function1/Function1/Function1.H b/src/OpenFOAM/primitives/functions/Function1/Function1/Function1.H
index 5ab283a1a3..4bd70a6421 100644
--- a/src/OpenFOAM/primitives/functions/Function1/Function1/Function1.H
+++ b/src/OpenFOAM/primitives/functions/Function1/Function1/Function1.H
@@ -25,10 +25,10 @@ Class
     Foam::Function1
 
 Description
-    Top level data entry class for use in dictionaries. Provides a mechanism
-    to specify a variable as a certain type, e.g. constant or table, and
-    provide functions to return the (interpolated) value, and integral between
-    limits.
+    Run-time selectable general function of one variable
+
+    with many options provided from simple constant values to complex
+    functions, interpolated tabulated data etc. etc.
 
 SourceFiles
     Function1.C
@@ -118,32 +118,36 @@ public:
 
     // Member Functions
 
-        // Access
+        //- Return the name of the entry
+        const word& name() const;
 
-            //- Return the name of the entry
-            const word& name() const;
+        //- Return value as a function of scalar x
+        virtual Type value(const scalar x) const = 0;
+
+        //- Return value as a function of a scalar field x
+        virtual tmp<Field<Type>> value(const scalarField& x) const = 0;
+
+        //- Integrate between two scalars
+        virtual Type integrate(const scalar x1, const scalar x2) const = 0;
+
+        //- Integrate between two scalar fields
+        virtual tmp<Field<Type>> integrate
+        (
+            const scalarField& x1,
+            const scalarField& x2
+        ) const = 0;
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
 
 
-        // Evaluation
+    // Member Operators
 
-            //- Return value as a function of (scalar) independent variable
-            virtual Type value(const scalar x) const = 0;
-
-            //- Return value as a function of (scalar) independent variable
-            virtual tmp<Field<Type>> value(const scalarField& x) const = 0;
-
-            //- Integrate between two (scalar) values
-            virtual Type integrate(const scalar x1, const scalar x2) const = 0;
-
-            //- Integrate between two (scalar) values
-            virtual tmp<Field<Type>> integrate
-            (
-                const scalarField& x1,
-                const scalarField& x2
-            ) const = 0;
+        //- Disallow default bitwise assignment
+        void operator=(const Function1<Type>&) = delete;
 
 
-        // I/O
+    // IOstream Operators
 
             //- Ostream Operator
             friend Ostream& operator<< <Type>
@@ -151,15 +155,6 @@ public:
                 Ostream& os,
                 const Function1<Type>& func
             );
-
-            //- Write in dictionary format
-            virtual void writeData(Ostream& os) const;
-
-
-    // Member Operators
-
-        //- Disallow default bitwise assignment
-        void operator=(const Function1<Type>&) = delete;
 };
 
 
@@ -197,23 +192,21 @@ public:
 
     // Member Functions
 
-        // Evaluation
+        //- Return value as a function of one scalars
+        virtual Type value(const scalar x) const = 0;
 
-            //- Return value as a function of (scalar) independent variable
-            virtual Type value(const scalar x) const = 0;
+        //- Return value as a function of one scalar field
+        virtual tmp<Field<Type>> value(const scalarField& x) const;
 
-            //- Return value as a function of (scalar) independent variable
-            virtual tmp<Field<Type>> value(const scalarField& x) const;
+        //- Integrate between two scalar values
+        virtual Type integrate(const scalar x1, const scalar x2) const = 0;
 
-            //- Integrate between two (scalar) values
-            virtual Type integrate(const scalar x1, const scalar x2) const = 0;
-
-            //- Integrate between two (scalar) values
-            virtual tmp<Field<Type>> integrate
-            (
-                const scalarField& x1,
-                const scalarField& x2
-            ) const;
+        //- Integrate between two scalar fields
+        virtual tmp<Field<Type>> integrate
+        (
+            const scalarField& x1,
+            const scalarField& x2
+        ) const;
 };
 
 
@@ -235,7 +228,7 @@ public:
     defineNamedTemplateTypeNameAndDebug(Function1s::SS<Type>, 0);              \
                                                                                \
     Function1<Type>::adddictionaryConstructorToTable<Function1s::SS<Type>>     \
-        add##SS##Type##ConstructorToTable_;
+        addFunction1##SS##Type##ConstructorToTable_;
 
 
 #define makeScalarFunction1(SS)                                                \
@@ -243,7 +236,7 @@ public:
     defineTypeNameAndDebug(SS, 0);                                             \
                                                                                \
     Function1<scalar>::adddictionaryConstructorToTable<SS>                     \
-        add##SS##ConstructorToTable_;
+        addFunction1##SS##ConstructorToTable_;
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/OpenFOAM/primitives/functions/Function1/PolynomialEntry/PolynomialEntry.H b/src/OpenFOAM/primitives/functions/Function1/PolynomialEntry/PolynomialEntry.H
index 7d5cd42215..34ba210b16 100644
--- a/src/OpenFOAM/primitives/functions/Function1/PolynomialEntry/PolynomialEntry.H
+++ b/src/OpenFOAM/primitives/functions/Function1/PolynomialEntry/PolynomialEntry.H
@@ -103,10 +103,10 @@ public:
 
         // Evaluation
 
-            //- Return Polynomial value
+            //- Return Polynomial value as a function of scalar x
             virtual Type value(const scalar x) const;
 
-            //- Integrate between two (scalar) values
+            //- Integrate between two scalar fields
             virtual Type integrate(const scalar x1, const scalar x2) const;
 
 
diff --git a/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.H b/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.H
index a356218bb1..5e0503e9d8 100644
--- a/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.H
+++ b/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.H
@@ -128,10 +128,10 @@ public:
 
     // Member Functions
 
-        //- Return Table value
+        //- Return Table value as a function of scalar x
         virtual Type value(const scalar x) const;
 
-        //- Integrate between two (scalar) values
+        //- Integrate between two scalars
         virtual Type integrate(const scalar x1, const scalar x2) const;
 
         //- Return the reference values
diff --git a/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.C b/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.C
index 8a0e65c0bf..331086f52c 100644
--- a/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.C
+++ b/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.C
@@ -32,20 +32,20 @@ void Foam::evaluate
 (
     GeometricField<Type, PatchField, GeoMesh>& result,
     const Function1<Type>& func,
-    const GeometricField<Type, PatchField, GeoMesh>& f
+    const GeometricField<Type, PatchField, GeoMesh>& x
 )
 {
-    result.primitiveFieldRef() = func.value(f());
+    result.primitiveFieldRef() = func.value(x());
 
     typename GeometricField<Type, PatchField, GeoMesh>::Boundary& bresult =
         result.boundaryFieldRef();
 
-    const typename GeometricField<Type, PatchField, GeoMesh>::Boundary& bf =
-        f.boundaryField();
+    const typename GeometricField<Type, PatchField, GeoMesh>::Boundary& bx =
+        x.boundaryField();
 
     forAll(bresult, patchi)
     {
-        bresult[patchi] = func.value(bf[patchi]);
+        bresult[patchi] = func.value(bx[patchi]);
     }
 }
 
@@ -55,20 +55,20 @@ Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>> Foam::evaluate
 (
     const Function1<Type>& func,
     const dimensionSet& dims,
-    const GeometricField<Type, PatchField, GeoMesh>& f
+    const GeometricField<Type, PatchField, GeoMesh>& x
 )
 {
     tmp<GeometricField<Type, PatchField, GeoMesh>> tresult
     (
         GeometricField<Type, PatchField, GeoMesh>::New
         (
-            func.name() + "(" + f.name() + ')',
-            f.mesh(),
+            func.name() + "(" + x.name() + ')',
+            x.mesh(),
             dims
         )
     );
 
-    evaluate(tresult.ref(), func, f);
+    evaluate(tresult.ref(), func, x);
 
     return tresult;
 }
diff --git a/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.H b/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.H
index f6fd27340d..d96faa22b9 100644
--- a/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.H
+++ b/src/OpenFOAM/primitives/functions/Function1/evaluate/Function1Evaluate.H
@@ -49,7 +49,7 @@ void evaluate
 (
     GeometricField<Type, PatchField, GeoMesh>& result,
     const Function1<Type>& func,
-    const GeometricField<Type, PatchField, GeoMesh>& f
+    const GeometricField<Type, PatchField, GeoMesh>& x
 );
 
 template<class Type, template<class> class PatchField, class GeoMesh>
@@ -57,7 +57,7 @@ tmp<GeometricField<Type, PatchField, GeoMesh>> evaluate
 (
     const Function1<Type>& func,
     const dimensionSet& dims,
-    const GeometricField<Type, PatchField, GeoMesh>& f
+    const GeometricField<Type, PatchField, GeoMesh>& x
 );
 
 
diff --git a/src/OpenFOAM/primitives/functions/Function1/objectFunction1/objectFunction1.H b/src/OpenFOAM/primitives/functions/Function1/objectFunction1/objectFunction1.H
index e7007ccedf..97fe92a783 100644
--- a/src/OpenFOAM/primitives/functions/Function1/objectFunction1/objectFunction1.H
+++ b/src/OpenFOAM/primitives/functions/Function1/objectFunction1/objectFunction1.H
@@ -96,27 +96,25 @@ public:
 
     // Member Functions
 
-        // Evaluation
+        //- Return value as a function of scalar x
+        template <class PrimitiveType>
+        PrimitiveType value(const scalar x) const;
 
-            //- Return value as a function of (scalar) independent variable
-            template <class PrimitiveType>
-            PrimitiveType value(const scalar x) const;
+        //- Return value as a function of scalarField x
+        template <class PrimitiveType>
+        tmp<Field<PrimitiveType>> value(const scalarField& x) const;
 
-            //- Return value as a function of (scalar) independent variable
-            template <class PrimitiveType>
-            tmp<Field<PrimitiveType>> value(const scalarField& x) const;
+        //- Integrate between two scalars
+        template <class PrimitiveType>
+        PrimitiveType integrate(const scalar x1, const scalar x2) const;
 
-            //- Integrate between two (scalar) values
-            template <class PrimitiveType>
-            PrimitiveType integrate(const scalar x1, const scalar x2) const;
-
-            //- Integrate between two (scalar) values
-            template <class PrimitiveType>
-            tmp<Field<PrimitiveType>> integrate
-            (
-                const scalarField& x1,
-                const scalarField& x2
-            ) const;
+        //- Integrate between two scalar fields
+        template <class PrimitiveType>
+        tmp<Field<PrimitiveType>> integrate
+        (
+            const scalarField& x1,
+            const scalarField& x2
+        ) const;
 
 
     // Member Operators
diff --git a/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2.C b/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2.C
new file mode 100644
index 0000000000..3ce4317a69
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2.C
@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "CodedFunction2.H"
+#include "dynamicCode.H"
+#include "dynamicCodeContext.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::Function2s::Coded<Type>::prepare
+(
+    dynamicCode& dynCode,
+    const dynamicCodeContext& context
+) const
+{
+    dynCode.setFilterVariable("typeName", codeName());
+
+    // Set TemplateType filter variables
+    dynCode.setFilterVariable("TemplateType", pTraits<Type>::typeName);
+
+    // Compile filtered C template
+    dynCode.addCompileFile(codeTemplateC);
+
+    // Copy filtered H template
+    dynCode.addCopyFile(codeTemplateH);
+
+    // Debugging: make verbose
+    if (debug)
+    {
+        dynCode.setFilterVariable("verbose", "true");
+        Info<<"compile " << codeName() << " sha1: "
+            << context.sha1() << endl;
+    }
+
+    // Define Make/options
+    dynCode.setMakeOptions
+    (
+        "EXE_INC = -g \\\n"
+      + context.options()
+      + "\n\nLIB_LIBS = \\\n"
+      + "    -lOpenFOAM \\\n"
+      + context.libs()
+    );
+}
+
+
+template<class Type>
+void Foam::Function2s::Coded<Type>::clearRedirect() const
+{
+    // Remove instantiation of Function2 provided by library
+    redirectFunction2Ptr_.clear();
+}
+
+
+template<class Type>
+Foam::autoPtr<Foam::Function2<Type>>
+Foam::Function2s::Coded<Type>::compileNew()
+{
+    this->updateLibrary();
+
+    dictionary redirectDict(codeDict());
+    redirectDict.set(codeName(), codeName());
+
+    return Function2<Type>::New(codeName(), redirectDict);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::Coded<Type>::Coded
+(
+    const word& entryName,
+    const dictionary& dict
+)
+:
+    Function2<Type>(entryName),
+    CodedBase<coded>(dict)
+{
+    redirectFunction2Ptr_ = compileNew();
+}
+
+
+
+template<class Type>
+Foam::Function2s::Coded<Type>::Coded(const Coded<Type>& cf1)
+:
+    Function2<Type>(cf1),
+    CodedBase<coded>(cf1)
+{
+    redirectFunction2Ptr_ = compileNew();
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Function2<Type>> Foam::Function2s::Coded<Type>::clone() const
+{
+    return tmp<Function2<Type>>(new Coded<Type>(*this));
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::Coded<Type>::~Coded()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::tmp<Foam::Field<Type>> Foam::Function2s::Coded<Type>::value
+(
+    const scalarField& x,
+    const scalarField& y
+) const
+{
+    return redirectFunction2Ptr_->value(x, y);
+}
+
+
+template<class Type>
+void Foam::Function2s::Coded<Type>::writeData(Ostream& os) const
+{
+    Function2<Type>::writeData(os);
+    os  << token::END_STATEMENT << nl;
+    writeCode(os);
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2.H b/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2.H
new file mode 100644
index 0000000000..0b2c524875
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2.H
@@ -0,0 +1,159 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Function2s::Coded
+
+Description
+    Constructs a dynamically compiled function of two variables.
+
+See also
+    Foam::dynamicCode
+    Foam::functionEntries::codeStream
+
+SourceFiles
+    CodedFunction2I.H
+    CodedFunction2.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef CodedFunction2_H
+#define CodedFunction2_H
+
+#include "Function2.H"
+#include "CodedBase.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Function2s
+{
+
+/*---------------------------------------------------------------------------*\
+                            Class coded Declaration
+\*---------------------------------------------------------------------------*/
+
+class coded
+{
+public:
+
+    ClassNameNoDebug("Function2");
+};
+
+
+/*---------------------------------------------------------------------------*\
+                            Class Coded Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class Coded
+:
+    public Function2<Type>,
+    public CodedBase<coded>
+{
+    // Private Data
+
+        //- The dynamically generated Function2 pointer
+        mutable autoPtr<Function2<Type>> redirectFunction2Ptr_;
+
+
+    // Private Member Functions
+
+        //- Adapt the context for the current object
+        virtual void prepare(dynamicCode&, const dynamicCodeContext&) const;
+
+        //- Clear the ptr to the redirected object
+        virtual void clearRedirect() const;
+
+        //- Compile, link and return the now coded Function2
+        autoPtr<Function2<Type>> compileNew();
+
+
+public:
+
+    // Runtime type information
+    TypeName("coded");
+
+
+    // Constructors
+
+        //- Construct from entry name and dictionary
+        Coded
+        (
+            const word& entryName,
+            const dictionary& dict
+        );
+
+        //- Copy constructor
+        Coded(const Coded<Type>& cf1);
+
+        //- Construct and return a clone
+        virtual tmp<Function2<Type>> clone() const;
+
+
+    //- Destructor
+    virtual ~Coded();
+
+
+    // Member Functions
+
+        //- Return value as a function of two scalars
+        virtual inline Type value(const scalar x, const scalar y) const;
+
+        //- Return value as a function of two scalar fields
+        virtual tmp<Field<Type>> value
+        (
+            const scalarField& x,
+            const scalarField& y
+        ) const;
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const Coded<Type>&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Function2s
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "CodedFunction2I.H"
+
+#ifdef NoRepository
+    #include "CodedFunction2.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2I.H b/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2I.H
new file mode 100644
index 0000000000..c2183d3123
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Coded/CodedFunction2I.H
@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "CodedFunction2.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+inline Type Foam::Function2s::Coded<Type>::value
+(
+    const scalar x,
+    const scalar y
+) const
+{
+    // Make sure library containing user-defined Function2 is up-to-date
+    this->updateLibrary();
+
+    return redirectFunction2Ptr_->value(x, y);
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2.C b/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2.C
new file mode 100644
index 0000000000..88e37551ae
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2.C
@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Constant2.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::Constant<Type>::Constant
+(
+    const word& entryName,
+    const Type& val
+)
+:
+    FieldFunction2<Type, Constant<Type>>(entryName),
+    value_(val)
+{}
+
+
+template<class Type>
+Foam::Function2s::Constant<Type>::Constant
+(
+    const word& entryName,
+    const dictionary& dict
+)
+:
+    FieldFunction2<Type, Constant<Type>>(entryName),
+    value_(Zero)
+{
+    if (!dict.found(entryName))
+    {
+        dict.lookup("value") >> value_;
+    }
+    else
+    {
+        Istream& is(dict.lookup(entryName));
+        word entryType(is);
+        if (is.eof())
+        {
+            dict.lookup("value") >> value_;
+        }
+        else
+        {
+            is  >> value_;
+        }
+    }
+}
+
+
+template<class Type>
+Foam::Function2s::Constant<Type>::Constant
+(
+    const word& entryName,
+    Istream& is
+)
+:
+    FieldFunction2<Type, Constant<Type>>(entryName),
+    value_(pTraits<Type>(is))
+{}
+
+
+template<class Type>
+Foam::Function2s::Constant<Type>::Constant(const Constant<Type>& cnst)
+:
+    FieldFunction2<Type, Constant<Type>>(cnst),
+    value_(cnst.value_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::Constant<Type>::~Constant()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::Function2s::Constant<Type>::writeData(Ostream& os) const
+{
+    Function2<Type>::writeData(os);
+
+    os  << token::SPACE << value_ << token::END_STATEMENT << nl;
+}
+
+
+// ************************************************************************* i/
diff --git a/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2.H b/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2.H
new file mode 100644
index 0000000000..33f877d1e2
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2.H
@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Function2s::Constant
+
+Description
+    Templated function of two variables that returns a constant value.
+
+    Usage - for entry \<entryName\> returning the value <value>:
+    \verbatim
+        <entryName>     constant <value>;
+    \endverbatim
+
+    or simply
+
+    \verbatim
+        <entryName>     <value>;
+    \endverbatim
+
+SourceFiles
+    Constant.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Constant2_H
+#define Constant2_H
+
+#include "Function2.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Function2s
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class Constant Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class Constant
+:
+    public FieldFunction2<Type, Constant<Type>>
+{
+    // Private Data
+
+        //- Constant value
+        Type value_;
+
+
+public:
+
+    // Runtime type information
+    TypeName("constant");
+
+
+    // Constructors
+
+        //- Construct from entry name and value
+        Constant(const word& entryName, const Type& val);
+
+        //- Construct from entry name and dictionary
+        Constant(const word& entryName, const dictionary& dict);
+
+        //- Construct from entry name and Istream
+        //  Reads the constant value without the Function2 type
+        //  for backward compatibility
+        Constant(const word& entryName, Istream& is);
+
+        //- Copy constructor
+        Constant(const Constant<Type>& cnst);
+
+        //- Construct and return a clone
+        virtual tmp<Function2<Type>> clone() const
+        {
+            return tmp<Function2<Type>>(new Constant<Type>(*this));
+        }
+
+
+    //- Destructor
+    virtual ~Constant();
+
+
+    // Member Functions
+
+        //- Return constant
+        virtual inline Type value(const scalar x, const scalar y) const;
+
+        //- Return constant field
+        virtual inline tmp<Field<Type>> value
+        (
+            const scalarField& x,
+            const scalarField& y
+        ) const;
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const Constant<Type>&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Function2s
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "Constant2I.H"
+
+#ifdef NoRepository
+    #include "Constant2.C"
+    #include "Function2New.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2I.H b/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2I.H
new file mode 100644
index 0000000000..7b35c12eee
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Constant/Constant2I.H
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Constant2.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+inline Type Foam::Function2s::Constant<Type>::value
+(
+    const scalar x,
+    const scalar y
+) const
+{
+    return value_;
+}
+
+
+template<class Type>
+inline Foam::tmp<Foam::Field<Type>> Foam::Function2s::Constant<Type>::value
+(
+    const scalarField& x,
+    const scalarField& y
+) const
+{
+    return tmp<Field<Type>>(new Field<Type>(x.size(), value_));
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Function2/Function2.C b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2.C
new file mode 100644
index 0000000000..a330643d27
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2.C
@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Function2.H"
+
+// * * * * * * * * * * * * * * * * Constructor * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2<Type>::Function2(const word& entryName)
+:
+    name_(entryName)
+{}
+
+
+template<class Type>
+Foam::Function2<Type>::Function2(const Function2<Type>& de)
+:
+    tmp<Function2<Type>>::refCount(),
+    name_(de.name_)
+{}
+
+
+template<class Type, class Function2Type>
+Foam::FieldFunction2<Type, Function2Type>::FieldFunction2
+(
+    const word& entryName
+)
+:
+    Function2<Type>(entryName)
+{}
+
+
+template<class Type, class Function2Type>
+Foam::FieldFunction2<Type, Function2Type>::FieldFunction2
+(
+    const FieldFunction2<Type, Function2Type>& ff1
+)
+:
+    Function2<Type>(ff1)
+{}
+
+
+template<class Type, class Function2Type>
+Foam::tmp<Foam::Function2<Type>>
+Foam::FieldFunction2<Type, Function2Type>::clone() const
+{
+    return tmp<Function2<Type>>
+    (
+        new Function2Type(refCast<const Function2Type>(*this))
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2<Type>::~Function2()
+{}
+
+
+template<class Type, class Function2Type>
+Foam::FieldFunction2<Type, Function2Type>::~FieldFunction2()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+const Foam::word& Foam::Function2<Type>::name() const
+{
+    return name_;
+}
+
+
+template<class Type>
+void Foam::Function2<Type>::writeData(Ostream& os) const
+{
+    writeKeyword(os, name_) << type();
+}
+
+
+template<class Type, class Function2Type>
+Foam::tmp<Foam::Field<Type>> Foam::FieldFunction2<Type, Function2Type>::value
+(
+    const scalarField& x,
+    const scalarField& y
+) const
+{
+    tmp<Field<Type>> tfld(new Field<Type>(x.size()));
+    Field<Type>& fld = tfld.ref();
+
+    forAll(x, i)
+    {
+        fld[i] = refCast<const Function2Type>(*this).value(x[i], y[i]);
+    }
+
+    return tfld;
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Functions  * * * * * * * * * * * * //
+
+template<class Type>
+void  Foam::writeEntry(Ostream& os, const Function2<Type>& f1)
+{
+    f1.writeData(os);
+}
+
+
+// * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const Function2<Type>& f1
+)
+{
+    // Check state of Ostream
+    os.check
+    (
+        "Ostream& operator<<(Ostream&, const Function2<Type>&)"
+    );
+
+    f1.writeData(os);
+
+    return os;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Function2/Function2.H b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2.H
new file mode 100644
index 0000000000..86ef98a278
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2.H
@@ -0,0 +1,241 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Function2
+
+Description
+    Run-time selectable function of two variables
+
+    with many options provided from simple constant values to complex
+    functions, interpolated tabulated data etc. etc.
+
+SourceFiles
+    Function2.C
+    Function2New.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Function2_H
+#define Function2_H
+
+#include "dictionary.H"
+#include "tmp.H"
+#include "typeInfo.H"
+#include "Field.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of friend functions and operators
+template<class Type> class Function2;
+template<class Type> Ostream& operator<<(Ostream&, const Function2<Type>&);
+
+/*---------------------------------------------------------------------------*\
+                          Class Function2 Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class Function2
+:
+    public tmp<Function2<Type>>::refCount
+{
+
+protected:
+
+    // Protected data
+
+        //- Name of entry
+        const word name_;
+
+
+public:
+
+    typedef Type returnType;
+
+    //- Runtime type information
+    TypeName("Function2")
+
+    //- Declare runtime constructor selection table
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        Function2,
+        dictionary,
+        (
+            const word& entryName,
+            const dictionary& dict
+        ),
+        (entryName, dict)
+    );
+
+
+    // Constructors
+
+        //- Construct from entry name
+        Function2(const word& entryName);
+
+        //- Copy constructor
+        Function2(const Function2<Type>& f1);
+
+        //- Construct and return a clone
+        virtual tmp<Function2<Type>> clone() const = 0;
+
+
+    //- Selector
+    static autoPtr<Function2<Type>> New
+    (
+        const word& entryName,
+        const dictionary& dict
+    );
+
+
+    //- Destructor
+    virtual ~Function2();
+
+
+    // Member Functions
+
+        //- Return the name of the entry
+        const word& name() const;
+
+        //- Return value as a function of two scalars
+        virtual Type value(const scalar x, const scalar y) const = 0;
+
+        //- Return value as a function of two scalar fields
+        virtual tmp<Field<Type>> value
+        (
+            const scalarField& x,
+            const scalarField& y
+        ) const = 0;
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const Function2<Type>&) = delete;
+
+
+    // IOstream Operators
+
+        //- Ostream Operator
+        friend Ostream& operator<< <Type>
+        (
+            Ostream& os,
+            const Function2<Type>& func
+        );
+};
+
+
+template<class Type>
+void writeEntry(Ostream& os, const Function2<Type>& f1);
+
+
+/*---------------------------------------------------------------------------*\
+                       Class FieldFunction2 Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type, class Function2Type>
+class FieldFunction2
+:
+    public Function2<Type>
+{
+
+public:
+
+    // Constructors
+
+        //- Construct from entry name
+        FieldFunction2(const word& entryName);
+
+        //- Copy constructor
+        FieldFunction2(const FieldFunction2<Type, Function2Type>& ff1);
+
+        //- Construct and return a clone
+        virtual tmp<Function2<Type>> clone() const;
+
+
+    //- Destructor
+    virtual ~FieldFunction2();
+
+
+    // Member Functions
+
+        //- Return value as a function of two scalars
+        virtual Type value(const scalar x, const scalar y) const = 0;
+
+        //- Return value as a function of two scalar fields
+        virtual tmp<Field<Type>> value
+        (
+            const scalarField& x,
+            const scalarField& y
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeFunction2(Type)                                                    \
+                                                                               \
+    defineNamedTemplateTypeNameAndDebug(Function2<Type>, 0);                   \
+                                                                               \
+    defineTemplateRunTimeSelectionTable(Function2<Type>, dictionary);
+
+
+#define makeFunction2Type(SS, Type)                                            \
+                                                                               \
+    defineNamedTemplateTypeNameAndDebug(Function2s::SS<Type>, 0);              \
+                                                                               \
+    Function2<Type>::adddictionaryConstructorToTable<Function2s::SS<Type>>     \
+        addFunction2##SS##Type##ConstructorToTable_;
+
+
+#define makeScalarFunction2(SS)                                                \
+                                                                               \
+    defineTypeNameAndDebug(SS, 0);                                             \
+                                                                               \
+    Function2<scalar>::adddictionaryConstructorToTable<SS>                     \
+        addFunction2##SS##ConstructorToTable_;
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "Function2.C"
+    #include "Constant2.H"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Function2/Function2Fwd.H b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2Fwd.H
new file mode 100644
index 0000000000..dd7bf6d45a
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2Fwd.H
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Function2Fwd_H
+#define Function2Fwd_H
+
+#include "Function2.H"
+#include "vector.H"
+#include "symmTensor.H"
+#include "sphericalTensor.H"
+#include "tensor.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef Function2<label> labelFunction2;
+    typedef Function2<scalar> scalarFunction2;
+    typedef Function2<vector> vectorFunction2;
+    typedef Function2<symmTensor> symmTensorFunction2;
+    typedef Function2<sphericalTensor> sphericalTensorFunction2;
+    typedef Function2<tensor> tensorFunction2;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Function2/Function2New.C b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2New.C
new file mode 100644
index 0000000000..7ce0326d97
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Function2/Function2New.C
@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Constant.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::autoPtr<Foam::Function2<Type>> Foam::Function2<Type>::New
+(
+    const word& entryName,
+    const dictionary& dict
+)
+{
+    if (dict.isDict(entryName))
+    {
+        const dictionary& coeffsDict(dict.subDict(entryName));
+
+        const word Function2Type(coeffsDict.lookup("type"));
+
+        typename dictionaryConstructorTable::iterator cstrIter =
+            dictionaryConstructorTablePtr_->find(Function2Type);
+
+        if (cstrIter == dictionaryConstructorTablePtr_->end())
+        {
+            FatalErrorInFunction
+                << "Unknown Function2 type "
+                << Function2Type << " for Function2 "
+                << entryName << nl << nl
+                << "Valid Function2 types are:" << nl
+                << dictionaryConstructorTablePtr_->sortedToc() << nl
+                << exit(FatalError);
+        }
+
+        return cstrIter()(entryName, coeffsDict);
+    }
+    else
+    {
+        Istream& is(dict.lookup(entryName, false));
+
+        token firstToken(is);
+        word Function2Type;
+
+        if (!firstToken.isWord())
+        {
+            is.putBack(firstToken);
+            return autoPtr<Function2<Type>>
+            (
+                new Function2s::Constant<Type>(entryName, is)
+            );
+        }
+        else
+        {
+            Function2Type = firstToken.wordToken();
+        }
+
+        typename dictionaryConstructorTable::iterator cstrIter =
+            dictionaryConstructorTablePtr_->find(Function2Type);
+
+        if (cstrIter == dictionaryConstructorTablePtr_->end())
+        {
+            FatalErrorInFunction
+                << "Unknown Function2 type "
+                << Function2Type << " for Function2 "
+                << entryName << nl << nl
+                << "Valid Function2 types are:" << nl
+                << dictionaryConstructorTablePtr_->sortedToc() << nl
+                << exit(FatalError);
+        }
+
+        return cstrIter()
+        (
+            entryName,
+            dict.found(entryName + "Coeffs")
+          ? dict.subDict(entryName + "Coeffs")
+          : dict
+        );
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2.C b/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2.C
new file mode 100644
index 0000000000..e0e90cc320
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2.C
@@ -0,0 +1,66 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "OneConstant2.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::OneConstant<Type>::OneConstant(const word& entryName)
+:
+    FieldFunction2<Type, OneConstant<Type>>(entryName)
+{}
+
+
+template<class Type>
+Foam::Function2s::OneConstant<Type>::OneConstant
+(
+    const word& entryName,
+    const dictionary& dict
+)
+:
+    FieldFunction2<Type, OneConstant<Type>>(entryName)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::OneConstant<Type>::~OneConstant()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::Function2s::OneConstant<Type>::writeData(Ostream& os) const
+{
+    Function2<Type>::writeData(os);
+
+    os  << token::END_STATEMENT << nl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2.H b/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2.H
new file mode 100644
index 0000000000..dffcdc43b0
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2.H
@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Function2s::OneConstant
+
+Description
+    Templated function of two variables that returns the corresponding 1 (one).
+
+    Usage:
+    \verbatim
+        <entryName> one;
+    \endverbatim
+
+SourceFiles
+    OneConstant.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef OneConstant2_H
+#define OneConstant2_H
+
+#include "Function2.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Function2s
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class OneConstant Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class OneConstant
+:
+    public FieldFunction2<Type, OneConstant<Type>>
+{
+
+public:
+
+    // Runtime type information
+    TypeName("one");
+
+
+    // Constructors
+
+        //- Construct from entry name
+        OneConstant(const word& entryName);
+
+        //- Construct from entry name and dictionary
+        OneConstant(const word& entryName, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~OneConstant();
+
+
+    // Member Functions
+
+        //- Return One
+        virtual inline Type value(const scalar x, const scalar y) const;
+
+        //- Return One field
+        virtual inline tmp<Field<Type>> value
+        (
+            const scalarField& x,
+            const scalarField& y
+        ) const;
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const OneConstant<Type>&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Function2s
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "OneConstant2I.H"
+
+#ifdef NoRepository
+    #include "OneConstant2.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2I.H b/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2I.H
new file mode 100644
index 0000000000..2e77bca658
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/One/OneConstant2I.H
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "OneConstant2.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+inline Type Foam::Function2s::OneConstant<Type>::value
+(
+    const scalar x,
+    const scalar y
+) const
+{
+    return pTraits<Type>::one;
+}
+
+
+template<class Type>
+inline Foam::tmp<Foam::Field<Type>> Foam::Function2s::OneConstant<Type>::value
+(
+    const scalarField& x,
+    const scalarField& y
+) const
+{
+    return tmp<Field<Type>>(new Field<Type>(x.size(), pTraits<Type>::one));
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2.C b/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2.C
new file mode 100644
index 0000000000..716660008b
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2.C
@@ -0,0 +1,102 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Scale2.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::Function2s::Scale<Type>::read(const dictionary& coeffs)
+{
+    scale_ = Function2<scalar>::New("scale", coeffs);
+    xScale_ =
+        coeffs.found("xScale")
+      ? Function1<scalar>::New("xScale", coeffs)
+      : autoPtr<Function1<scalar>>
+        (
+            new Function1s::Constant<scalar>("xScale", 1)
+        );
+    yScale_ =
+        coeffs.found("yScale")
+      ? Function1<scalar>::New("yScale", coeffs)
+      : autoPtr<Function1<scalar>>
+        (
+            new Function1s::Constant<scalar>("yScale", 1)
+        );
+    value_ = Function2<Type>::New("value", coeffs);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::Scale<Type>::Scale
+(
+    const word& entryName,
+    const dictionary& dict
+)
+:
+    FieldFunction2<Type, Scale<Type>>(entryName)
+{
+    read(dict);
+}
+
+
+template<class Type>
+Foam::Function2s::Scale<Type>::Scale(const Scale<Type>& se)
+:
+    FieldFunction2<Type, Scale<Type>>(se),
+    scale_(se.scale_, false),
+    xScale_(se.xScale_, false),
+    yScale_(se.yScale_, false),
+    value_(se.value_, false)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::Scale<Type>::~Scale()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::Function2s::Scale<Type>::writeData(Ostream& os) const
+{
+    Function2<Type>::writeData(os);
+    os  << token::END_STATEMENT << nl;
+    os  << indent << word(this->name() + "Coeffs") << nl;
+    os  << indent << token::BEGIN_BLOCK << incrIndent << nl;
+    scale_->writeData(os);
+    xScale_->writeData(os);
+    yScale_->writeData(os);
+    value_->writeData(os);
+    os  << decrIndent << indent << token::END_BLOCK << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2.H b/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2.H
new file mode 100644
index 0000000000..582ac9e0de
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2.H
@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Function2s::Scale
+
+Description
+    Function2 which scales a given 'value' function by a 'scale' scalar function
+    and scales the 'x' and 'y' arguments of the 'value' and 'scale' functions
+    by the optional 'xScale' and 'yScale' scalar functions.
+
+See also
+    Foam::Function2s::ramp
+    Foam::Function2s::reverseRamp
+
+SourceFiles
+    Scale.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Scale2_H
+#define Scale2_H
+
+#include "Function2.H"
+#include "Function1.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Function2s
+{
+
+/*---------------------------------------------------------------------------*\
+                            Class Scale Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class Scale
+:
+    public FieldFunction2<Type, Scale<Type>>
+{
+    // Private Data
+
+        //- Scalar scaling function
+        autoPtr<Function2<scalar>> scale_;
+
+        //- Argument scaling function
+        autoPtr<Function1<scalar>> xScale_;
+
+        //- Argument scaling function
+        autoPtr<Function1<scalar>> yScale_;
+
+        //- Value function
+        autoPtr<Function2<Type>> value_;
+
+
+    // Private Member Functions
+
+        //- Read the coefficients from the given dictionary
+        void read(const dictionary& coeffs);
+
+
+public:
+
+    // Runtime type information
+    TypeName("scale");
+
+
+    // Constructors
+
+        //- Construct from entry name and dictionary
+        Scale
+        (
+            const word& entryName,
+            const dictionary& dict
+        );
+
+        //- Copy constructor
+        Scale(const Scale<Type>& se);
+
+
+    //- Destructor
+    virtual ~Scale();
+
+
+    // Member Functions
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
+
+        //- Return value
+        virtual inline Type value(const scalar x, const scalar y) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const Scale<Type>&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Function2s
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "Scale2I.H"
+
+#ifdef NoRepository
+    #include "Scale2.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2I.H b/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2I.H
new file mode 100644
index 0000000000..c8310f4f5b
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Scale/Scale2I.H
@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Scale2.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+inline Type Foam::Function2s::Scale<Type>::value
+(
+    const scalar x,
+    const scalar y
+) const
+{
+    const scalar sx = xScale_->value(x)*x;
+    const scalar sy = yScale_->value(y)*y;
+    return scale_->value(sx, sy)*value_->value(sx, sy);
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2.C b/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2.C
new file mode 100644
index 0000000000..244724d58e
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2.C
@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ZeroConstant2.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::ZeroConstant<Type>::ZeroConstant
+(
+    const word& entryName,
+    const dictionary& dict
+)
+:
+    FieldFunction2<Type, ZeroConstant<Type>>(entryName)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::Function2s::ZeroConstant<Type>::~ZeroConstant()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::Function2s::ZeroConstant<Type>::writeData(Ostream& os) const
+{
+    Function2<Type>::writeData(os);
+
+    os  << token::END_STATEMENT << nl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2.H b/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2.H
new file mode 100644
index 0000000000..442ac5bd47
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2.H
@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Function2s::ZeroConstant
+
+Description
+    Templated function of two variables that returns the corresponding 0 (zero).
+
+    Usage:
+    \verbatim
+        <entryName> zero;
+    \endverbatim
+
+SourceFiles
+    ZeroConstant.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef ZeroConstant2_H
+#define ZeroConstant2_H
+
+#include "Function2.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace Function2s
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class ZeroConstant Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class ZeroConstant
+:
+    public FieldFunction2<Type, ZeroConstant<Type>>
+{
+
+public:
+
+    // Runtime type information
+    TypeName("zero");
+
+
+    // Constructors
+
+        //- Construct from entry name and dictionary
+        ZeroConstant(const word& entryName, const dictionary& dict);
+
+
+    //- Destructor
+    virtual ~ZeroConstant();
+
+
+    // Member Functions
+
+        //- Return Zero
+        virtual inline Type value(const scalar x, const scalar y) const;
+
+        //- Return Zero field
+        virtual inline tmp<Field<Type>> value
+        (
+            const scalarField& x,
+            const scalarField& y
+        ) const;
+
+        //- Write in dictionary format
+        virtual void writeData(Ostream& os) const;
+
+
+    // Member Operators
+
+        //- Disallow default bitwise assignment
+        void operator=(const ZeroConstant<Type>&) = delete;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Function2s
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "ZeroConstant2I.H"
+
+#ifdef NoRepository
+    #include "ZeroConstant2.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2I.H b/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2I.H
new file mode 100644
index 0000000000..a299c724b5
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/Zero/ZeroConstant2I.H
@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ZeroConstant2.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+inline Type Foam::Function2s::ZeroConstant<Type>::value
+(
+    const scalar x,
+    const scalar y
+) const
+{
+    return pTraits<Type>::zero;
+}
+
+
+template<class Type>
+inline Foam::tmp<Foam::Field<Type>> Foam::Function2s::ZeroConstant<Type>::value
+(
+    const scalarField& x,
+    const scalarField& y
+) const
+{
+    return tmp<Field<Type>>(new Field<Type>(x.size(), pTraits<Type>::zero));
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/evaluate/Function2Evaluate.C b/src/OpenFOAM/primitives/functions/Function2/evaluate/Function2Evaluate.C
new file mode 100644
index 0000000000..8897494ccc
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/evaluate/Function2Evaluate.C
@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Function2Evaluate.H"
+
+// * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * * //
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+void Foam::evaluate
+(
+    GeometricField<Type, PatchField, GeoMesh>& result,
+    const Function2<Type>& func,
+    const GeometricField<Type, PatchField, GeoMesh>& x,
+    const GeometricField<Type, PatchField, GeoMesh>& y
+)
+{
+    result.primitiveFieldRef() = func.value(x(), y());
+
+    typename GeometricField<Type, PatchField, GeoMesh>::Boundary& bresult =
+        result.boundaryFieldRef();
+
+    const typename GeometricField<Type, PatchField, GeoMesh>::Boundary& bx =
+        x.boundaryField();
+
+    const typename GeometricField<Type, PatchField, GeoMesh>::Boundary& by =
+        y.boundaryField();
+
+    forAll(bresult, patchi)
+    {
+        bresult[patchi] = func.value(bx[patchi], by[patchi]);
+    }
+}
+
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+Foam::tmp<Foam::GeometricField<Type, PatchField, GeoMesh>> Foam::evaluate
+(
+    const Function2<Type>& func,
+    const dimensionSet& dims,
+    const GeometricField<Type, PatchField, GeoMesh>& x,
+    const GeometricField<Type, PatchField, GeoMesh>& y
+)
+{
+    tmp<GeometricField<Type, PatchField, GeoMesh>> tresult
+    (
+        GeometricField<Type, PatchField, GeoMesh>::New
+        (
+            func.name() + '(' + x.name() + ',' + y.name() + ')',
+            x.mesh(),
+            dims
+        )
+    );
+
+    evaluate(tresult.ref(), func, x, y);
+
+    return tresult;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/evaluate/Function2Evaluate.H b/src/OpenFOAM/primitives/functions/Function2/evaluate/Function2Evaluate.H
new file mode 100644
index 0000000000..1d7819a6b5
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/evaluate/Function2Evaluate.H
@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Function2Evaluate
+
+Description
+    Global functions to evaluate Function2 of GeometricFields
+
+SourceFiles
+    Function2Evaluate.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Function2Evaluate_H
+#define Function2Evaluate_H
+
+#include "Function2.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+void evaluate
+(
+    GeometricField<Type, PatchField, GeoMesh>& result,
+    const Function2<Type>& func,
+    const GeometricField<Type, PatchField, GeoMesh>& f
+);
+
+template<class Type, template<class> class PatchField, class GeoMesh>
+tmp<GeometricField<Type, PatchField, GeoMesh>> evaluate
+(
+    const Function2<Type>& func,
+    const dimensionSet& dims,
+    const GeometricField<Type, PatchField, GeoMesh>& f
+);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "Function2Evaluate.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function2/makeFunction2s.C b/src/OpenFOAM/primitives/functions/Function2/makeFunction2s.C
new file mode 100644
index 0000000000..db1820e616
--- /dev/null
+++ b/src/OpenFOAM/primitives/functions/Function2/makeFunction2s.C
@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2020 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Constant2.H"
+#include "ZeroConstant2.H"
+#include "OneConstant2.H"
+#include "Scale2.H"
+#include "CodedFunction2.H"
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeName(Foam::Function2s::coded);
+
+template<>
+const Foam::wordList Foam::CodedBase<Foam::Function2s::coded>::codeKeys_ =
+{
+    "code",
+    "codeInclude"
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeFunction2s(Type)                                                   \
+    makeFunction2(Type);                                                       \
+    makeFunction2Type(Constant, Type);                                         \
+    makeFunction2Type(ZeroConstant, Type);                                     \
+    makeFunction2Type(OneConstant, Type);                                      \
+    makeFunction2Type(Scale, Type);                                            \
+    makeFunction2Type(Coded, Type);
+
+namespace Foam
+{
+    makeFunction2(label);
+    makeFunction2Type(Constant, label);
+
+    makeFunction2s(scalar);
+    makeFunction2s(vector);
+    makeFunction2s(sphericalTensor);
+    makeFunction2s(symmTensor);
+    makeFunction2s(tensor);
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/TimeFunction1/TimeFunction1.H b/src/OpenFOAM/primitives/functions/TimeFunction1/TimeFunction1.H
index 4fc2342057..5de934d64b 100644
--- a/src/OpenFOAM/primitives/functions/TimeFunction1/TimeFunction1.H
+++ b/src/OpenFOAM/primitives/functions/TimeFunction1/TimeFunction1.H
@@ -111,10 +111,10 @@ public:
 
         // Evaluation
 
-            //- Return value as a function of (scalar) independent variable
+            //- Return value as a function of scalar x
             virtual Type value(const scalar x) const;
 
-            //- Integrate between two (scalar) values
+            //- Integrate between two scalars
             virtual Type integrate(const scalar x1, const scalar x2) const;