diff --git a/applications/test/TestTools/TestTools.H b/applications/test/TestTools/TestTools.H
new file mode 100644
index 0000000000..c24cb9fa05
--- /dev/null
+++ b/applications/test/TestTools/TestTools.H
@@ -0,0 +1,305 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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
+    Various tools for test applications.
+
+\*---------------------------------------------------------------------------*/
+
+using namespace Foam;
+
+#include "Random.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Total number of unit tests
+unsigned nTest_ = 0;
+
+
+// Total number of failed unit tests
+unsigned nFail_ = 0;
+
+
+// Create a non-complex random Matrix.
+template<class MatrixType>
+typename std::enable_if
+<
+    !std::is_same<complex, typename MatrixType::cmptType>:: value,
+    MatrixType
+>::type makeRandomMatrix
+(
+    const labelPair& dims,
+    Random& rndGen
+)
+{
+    MatrixType mat(dims);
+
+    std::generate
+    (
+        mat.begin(),
+        mat.end(),
+        [&]{return rndGen.GaussNormal<scalar>();}
+    );
+
+    return mat;
+}
+
+
+// Create a complex random Matrix.
+template<class MatrixType>
+typename std::enable_if
+<
+    std::is_same<complex, typename MatrixType::cmptType>:: value,
+    MatrixType
+>::type makeRandomMatrix
+(
+    const labelPair& dims,
+    Random& rndGen
+)
+{
+    MatrixType mat(dims);
+
+    for (auto& x : mat)
+    {
+        x = complex(rndGen.GaussNormal<scalar>(), rndGen.GaussNormal<scalar>());
+    }
+
+    return mat;
+}
+
+
+// Copy an initializer list into a DiagonalMatrix
+template<class Type>
+void assignMatrix
+(
+    UList<Type>& A,
+    std::initializer_list<Type> list
+)
+{
+    std::copy(list.begin(), list.end(), A.begin());
+}
+
+
+// Copy an initializer list into a SymmetricSquareMatrix.
+template<class Form, class Type>
+void assignMatrix
+(
+    Matrix<Form, Type>& A,
+    std::initializer_list<typename Matrix<Form, Type>::cmptType> list
+)
+{
+    const label nargs = list.size();
+
+    if (nargs != A.size())
+    {
+        FatalErrorInFunction
+            << "Mismatch in matrix dimension ("
+            << A.m() << ", "
+            << A.n() << ") and number of args (" << nargs << ')' << nl
+            << exit(FatalError);
+     }
+
+    std::copy(list.begin(), list.end(), A.begin());
+}
+
+
+// Return a copy of the Matrix collapsed into one dimension.
+template<class Form, class Type>
+List<Type> flt
+(
+    const Matrix<Form, Type>& A,
+    const bool rowMajorOrder = true
+)
+{
+   List<Type> flatMatrix(A.size());
+
+   if (rowMajorOrder)
+   {
+       std::copy(A.cbegin(), A.cend(), flatMatrix.begin());
+   }
+   else
+   {
+       for (label j = 0; j < A.n(); ++j)
+       {
+           for (label i = 0; i < A.m(); ++i)
+           {
+               flatMatrix[i + j*A.m()] = A(i, j);
+           }
+       }
+   }
+
+   return flatMatrix;
+}
+
+
+// Compare two floating point types, and print output.
+// Do ++nFail_ if values of two objects are not equal within a given tolerance.
+// The function is converted from PEP-485.
+template<class Type>
+typename std::enable_if
+<
+    std::is_same<floatScalar, Type>::value ||
+    std::is_same<doubleScalar, Type>::value ||
+    std::is_same<complex, Type>::value,
+    void
+>::type cmp
+(
+    const word& msg,
+    const Type& x,
+    const Type& y,
+    const scalar absTol = 0,    //<! useful for cmps near zero
+    const scalar relTol = 1e-8  //<! are values the same within 8 decimals
+)
+{
+    Info<< msg << x << "?=" << y << endl;
+
+    unsigned nFail = 0;
+
+    if (max(absTol, relTol*max(mag(x), mag(y))) < mag(x - y))
+    {
+        ++nFail;
+    }
+
+    if (nFail)
+    {
+        Info<< nl
+            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
+        ++nFail_;
+    }
+    ++nTest_;
+}
+
+
+// Compare two containers elementwise, and print output.
+// Do ++nFail_ if two components are not equal within a given tolerance.
+// The function is converted from PEP-485
+template<class Type>
+typename std::enable_if
+<
+    !std::is_same<floatScalar, Type>::value &&
+    !std::is_same<doubleScalar, Type>::value &&
+    !std::is_same<complex, Type>::value,
+    void
+>::type cmp
+(
+    const word& msg,
+    const Type& x,
+    const Type& y,
+    const scalar absTol = 0,
+    const scalar relTol = 1e-8
+)
+{
+    Info<< msg << x << "?=" << y << endl;
+
+    unsigned nFail = 0;
+
+    for (label i = 0; i < x.size(); ++i)
+    {
+        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        {
+            ++nFail;
+        }
+    }
+
+    if (nFail)
+    {
+        Info<< nl
+            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
+        ++nFail_;
+    }
+    ++nTest_;
+}
+
+
+// Compare two containers elementwise, and print output.
+// Do ++nFail_ if two components are not equal within a given tolerance.
+// The function is converted from PEP-485
+template<class Type1, class Type2>
+typename std::enable_if
+<
+    !std::is_same<floatScalar, Type1>::value &&
+    !std::is_same<doubleScalar, Type1>::value &&
+    !std::is_same<complex, Type1>::value,
+    void
+>::type cmp
+(
+    const word& msg,
+    const Type1& x,
+    const Type2& y,
+    const scalar absTol = 0,
+    const scalar relTol = 1e-8
+)
+{
+    Info<< msg << x << "?=" << y << endl;
+
+    unsigned nFail = 0;
+
+    for (label i = 0; i < x.size(); ++i)
+    {
+        if (max(absTol, relTol*max(mag(x[i]), mag(y[i]))) < mag(x[i] - y[i]))
+        {
+            ++nFail;
+        }
+    }
+
+    if (nFail)
+    {
+        Info<< nl
+            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
+        ++nFail_;
+    }
+    ++nTest_;
+}
+
+
+// Compare two Booleans, and print output.
+// Do ++nFail_ if two Booleans are not equal.
+void cmp
+(
+    const word& msg,
+    const bool x,
+    const bool y
+)
+{
+    Info<< msg << x << "?=" << y << endl;
+
+    unsigned nFail = 0;
+
+    if (x != y)
+    {
+        ++nFail;
+    }
+
+    if (nFail)
+    {
+        Info<< nl
+            << "        #### Fail in " << nFail << " comps ####" << nl << endl;
+        ++nFail_;
+    }
+    ++nTest_;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/matrices/DiagonalMatrix/Make/files b/applications/test/matrices/DiagonalMatrix/Make/files
new file mode 100644
index 0000000000..0f5877472a
--- /dev/null
+++ b/applications/test/matrices/DiagonalMatrix/Make/files
@@ -0,0 +1,3 @@
+Test-DiagonalMatrix.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-DiagonalMatrix
diff --git a/applications/test/matrices/DiagonalMatrix/Make/options b/applications/test/matrices/DiagonalMatrix/Make/options
new file mode 100644
index 0000000000..b23590707c
--- /dev/null
+++ b/applications/test/matrices/DiagonalMatrix/Make/options
@@ -0,0 +1,2 @@
+EXE_INC = -I../../TestTools
+/* EXE_LIBS = -lfiniteVolume */
diff --git a/applications/test/matrices/DiagonalMatrix/Test-DiagonalMatrix.C b/applications/test/matrices/DiagonalMatrix/Test-DiagonalMatrix.C
new file mode 100644
index 0000000000..3d8ae06979
--- /dev/null
+++ b/applications/test/matrices/DiagonalMatrix/Test-DiagonalMatrix.C
@@ -0,0 +1,231 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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/>.
+
+Application
+    Test-DiagonalMatrix
+
+Description
+    Tests for \c DiagonalMatrix constructors, member functions and global
+    functions using \c floatScalar, \c doubleScalar, and \c complex base types.
+
+    Cross-checks were obtained from 'NumPy 1.15.1' if no theoretical
+    cross-check exists (like eigendecomposition relations), and
+    were hard-coded for elementwise comparisons.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DiagonalMatrix.H"
+#include "RectangularMatrix.H"
+#include "floatScalar.H"
+#include "doubleScalar.H"
+#include "complex.H"
+#include "TestTools.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Create each constructor of DiagonalMatrix<Type>, and print output
+template<class Type>
+void test_constructors(Type)
+{
+    {
+        Info<< "# Construct empty from size:" << nl;
+        const DiagonalMatrix<Type> A(5);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct from size and initialise all elems to zero:" << nl;
+        const DiagonalMatrix<Type> A(5, Zero);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct from size and initialise all elems to value" << nl;
+        const DiagonalMatrix<Type> A(5, Type(8));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct from the diagonal of a Matrix" << nl;
+        const RectangularMatrix<Type> M(3, 5, Zero);
+        const DiagonalMatrix<Type> A(M);
+        Info<< A << endl;
+    }
+}
+
+
+// Execute each member function of DiagonalMatrix<Type>, and print output
+template<class Type>
+void test_member_funcs(Type)
+{
+    DiagonalMatrix<Type> A(3, Zero);
+    assignMatrix(A, {Type(1), Type(2), Type(-3)});
+
+    Info<< "# Operand: " << nl
+        << "  DiagonalMatrix = " << A << endl;
+
+
+    {
+        Info<< "# Return the matrix inverse into itself:" << nl;
+        A.invert();
+        cmp
+        (
+            "  DiagonalMatrix<Type>.invert() = ",
+            A,
+            List<Type>({Type(1), Type(0.5), Type(-0.333333)}),
+            1e-6
+        );
+    }
+    {
+        Info<< "# Sort:" << nl;
+
+        DiagonalMatrix<Type> B(5, Zero);
+        assignMatrix(B, {Type(1), Type(2), Type(-3), Type(5), Type(1.01)});
+
+        auto descend = [&](Type a, Type b){ return mag(a) > mag(b); };
+        const List<label> sortPermutation(B.sortPermutation(descend));
+        cmp
+        (
+            "  Return a sort permutation labelList according to "
+            "a given comparison on the diagonal entries",
+            sortPermutation,
+            List<label>({3, 2, 1, 4, 0})
+        );
+
+        DiagonalMatrix<Type> sortedB0(5, Zero);
+        assignMatrix
+        (
+            sortedB0,
+            {
+                Type(5),
+                        Type(-3),
+                                 Type(2),
+                                         Type(1.01),
+                                                    Type(1)
+            }
+        );
+        const DiagonalMatrix<Type> sortedB1
+        (
+            applyPermutation(B, sortPermutation)
+        );
+        cmp
+        (
+            "  Return Matrix column-reordered according to "
+            "a given permutation labelList",
+            sortedB0,
+            sortedB1
+        );
+
+        DiagonalMatrix<Type> cpB(B);
+        cpB.applyPermutation(sortPermutation);
+        cmp
+        (
+            "  Column-reorder this Matrix according to "
+            "a given permutation labelList",
+            sortedB0,
+            cpB
+        );
+    }
+
+}
+
+
+// Execute each global function of DiagonalMatrix<Type>, and print output
+template<class Type>
+void test_global_funcs(Type)
+{
+    DiagonalMatrix<Type> A(3, Zero);
+    assignMatrix(A, {Type(1), Type(2), Type(-3)});
+
+    Info<< "# Operand: " << nl
+        << "  DiagonalMatrix = " << A << nl << endl;
+
+
+    cmp
+    (
+        "  Inverse = ",
+        inv(A),
+        List<Type>({Type(1), Type(0.5), Type(-0.333333)}),
+        1e-6
+    );
+}
+
+
+// Do compile-time recursion over the given types
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I == sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
+
+
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I < sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+{
+    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
+    test_constructors(std::get<I>(types));
+
+    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
+    test_member_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
+    test_global_funcs(std::get<I>(types));
+
+    run_tests<I + 1, Tp...>(types, typeID);
+}
+
+
+// * * * * * * * * * * * * * * * Main Program  * * * * * * * * * * * * * * * //
+
+int main()
+{
+    const std::tuple<floatScalar, doubleScalar, complex> types
+    (
+        std::make_tuple(Zero, Zero, Zero)
+    );
+
+    const List<word> typeID
+    ({
+        "DiagonalMatrix<floatScalar>",
+        "DiagonalMatrix<doubleScalar>",
+        "DiagonalMatrix<complex>"
+    });
+
+    run_tests(types, typeID);
+
+
+    if (nFail_)
+    {
+        Info<< nl << "        #### "
+            << "Failed in " << nFail_ << " tests "
+            << "out of total " << nTest_ << " tests "
+            << "####\n" << endl;
+        return 1;
+    }
+
+    Info<< nl << "        #### Passed all " << nTest_ <<" tests ####\n" << endl;
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/matrices/EigenMatrix/Make/files b/applications/test/matrices/EigenMatrix/Make/files
new file mode 100644
index 0000000000..1bd5722a5f
--- /dev/null
+++ b/applications/test/matrices/EigenMatrix/Make/files
@@ -0,0 +1,3 @@
+Test-EigenMatrix.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-EigenMatrix
diff --git a/applications/test/matrices/EigenMatrix/Make/options b/applications/test/matrices/EigenMatrix/Make/options
new file mode 100644
index 0000000000..b23590707c
--- /dev/null
+++ b/applications/test/matrices/EigenMatrix/Make/options
@@ -0,0 +1,2 @@
+EXE_INC = -I../../TestTools
+/* EXE_LIBS = -lfiniteVolume */
diff --git a/applications/test/matrices/EigenMatrix/Test-EigenMatrix.C b/applications/test/matrices/EigenMatrix/Test-EigenMatrix.C
new file mode 100644
index 0000000000..bae8bc7630
--- /dev/null
+++ b/applications/test/matrices/EigenMatrix/Test-EigenMatrix.C
@@ -0,0 +1,556 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is derivative work 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/>.
+
+Application
+    Test-EigenMatrix
+
+Description
+    Tests for \c EigenMatrix constructors, and member functions
+    using \c floatScalar, and \c doubleScalar base types.
+
+    Cross-checks were obtained from 'NumPy 1.15.1' if no theoretical
+    cross-check exists (like eigendecomposition relations), and
+    were hard-coded for elementwise comparisons.
+
+\*---------------------------------------------------------------------------*/
+
+#include "scalarMatrices.H"
+#include "RectangularMatrix.H"
+#include "SquareMatrix.H"
+#include "complex.H"
+#include "IOmanip.H"
+#include "EigenMatrix.H"
+#include "TestTools.H"
+#include <algorithm>
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Return the absolute tolerance value for bitwise comparisons of floatScalars
+floatScalar getTol(floatScalar)
+{
+    return 1e-2;
+}
+
+
+// Return the absolute tolerance value for bitwise comparisons of doubleScalars
+doubleScalar getTol(doubleScalar)
+{
+    return 1e-10;
+}
+
+
+// Create each constructor of EigenMatrix<Type>, and print output
+template<class Type>
+void test_constructors(Type)
+{
+    {
+        Info<< "# Construct from a SquareMatrix<Type>" << nl;
+        const SquareMatrix<Type> A(5, Zero);
+        const EigenMatrix<Type> EM(A);
+    }
+    {
+        Info<< "# Construct from a SquareMatrix<Type> and symmetry flag" << nl;
+        const SquareMatrix<Type> A(5, Zero);
+        const EigenMatrix<Type> EM(A, true);
+    }
+}
+
+
+// Execute each member function of EigenMatrix<Type>, and print output
+template<class Type>
+void test_member_funcs(Type)
+{
+    SquareMatrix<Type> A(3, Zero);
+    assignMatrix
+    (
+        A,
+        {
+            Type(1), Type(2), Type(3),
+            Type(4), Type(5), Type(6),
+            Type(7), Type(8), Type(9)
+        }
+    );
+
+    Info<< "# Operand: " << nl
+        << "  SquareMatrix = " << A << endl;
+
+
+    // Since eigenvalues are unique and eigenvectors are not unique,
+    // the bitwise comparisons are limited to eigenvalue computations.
+    // Here, only the execution of the functions is tested, rather than
+    // the verification of the eigendecomposition through theoretical relations.
+    {
+        const EigenMatrix<Type> EM(A);
+        const DiagonalMatrix<Type> EValsRe = EM.EValsRe();
+        const DiagonalMatrix<Type>& EValsIm = EM.EValsIm();
+        const SquareMatrix<Type>& EVecs = EM.EVecs();
+
+        cmp
+        (
+            "  Return real eigenvalues or real part of complex eigenvalues = ",
+            EValsRe,
+            List<Type>
+            ({
+                Type(16.116844),
+                Type(-1.116844),
+                Type(0)
+            }),
+            getTol(Type(0)),
+            1e-6
+        );
+        cmp
+        (
+            "  Return zero-matrix for real eigenvalues "
+            "or imaginary part of complex eigenvalues = ",
+            EValsIm,
+            List<Type>(3, Zero)
+        );
+        Info<< "  Return eigenvectors matrix = " << EVecs << endl;
+    }
+}
+
+
+// Test the relation: "sum(eigenvalues) = trace(A)"
+// w.wiki/4zs (Retrieved: 16-06-19) # Item-1
+template<class Type>
+void test_eigenvalues_sum
+(
+    const SquareMatrix<Type>& A,
+    const DiagonalMatrix<Type>& EValsRe
+)
+{
+    const Type trace = A.trace();
+    // Imaginary part of complex conjugates cancel each other
+    const Type EValsSum = sum(EValsRe);
+    Info<< "  # A.mRows = " << A.m() << nl;
+    cmp
+    (
+        "  # sum(eigenvalues) = trace(A) = ",
+        EValsSum,
+        trace,
+        getTol(Type(0))
+    );
+}
+
+
+// Test the relation: "prod(eigenvalues) = det(A)"
+// w.wiki/4zs (Retrieved: 16-06-19) # Item-2
+// Note that the determinant computation may fail
+// which is not a suggestion that eigendecomposition fails
+template<class Type>
+void test_eigenvalues_prod
+(
+    const SquareMatrix<Type>& A,
+    const DiagonalMatrix<Type>& EValsRe,
+    const DiagonalMatrix<Type>& EValsIm
+)
+{
+    const Type determinant = mag(det(A));
+    Type EValsProd = Type(1);
+
+    if (EValsIm.empty())
+    {
+        for (label i = 0; i < EValsRe.size(); ++i)
+        {
+            EValsProd *= Foam::sqrt(sqr(EValsRe[i]));
+        }
+    }
+    else
+    {
+        for (label i = 0; i < EValsRe.size(); ++i)
+        {
+            EValsProd *= Foam::sqrt(sqr(EValsRe[i]) + sqr(EValsIm[i]));
+        }
+    }
+    cmp
+    (
+        "  # prod(eigenvalues) = det(A) = ",
+        EValsProd,
+        determinant,
+        getTol(Type(0))
+    );
+}
+
+
+// Test eigenvalues in eigendecomposition relations
+// Relations: (Beauregard & Fraleigh (1973), ISBN 0-395-14017-X, p. 307)
+template<class Type>
+void test_eigenvalues(Type)
+{
+    Random rndGen(1234);
+    const label numberOfTests = 20;
+
+    // Non-symmetric
+    for (label i = 0; i < numberOfTests; ++i)
+    {
+        const label mRows = rndGen.position(100, 200);
+        const labelPair m(mRows, mRows);
+
+        const SquareMatrix<Type> A
+        (
+            makeRandomMatrix<SquareMatrix<Type>>(m, rndGen)
+        );
+
+        const EigenMatrix<Type> EM(A);
+        const DiagonalMatrix<Type>& EValsRe = EM.EValsRe();
+
+        test_eigenvalues_sum(A, EValsRe);
+
+        // LUDecompose does not work with floatScalar at the time of writing,
+        // hence det function. Once LUDecompose is refactored, comment out below
+        // const DiagonalMatrix<Type>& EValsIm = EM.EValsIm();
+        // test_eigenvalues_prod(A, EValsRe, EValsIm);
+    }
+
+    // Symmetric
+    for (label i = 0; i < numberOfTests; ++i)
+    {
+        const label mRows = rndGen.position(100, 200);
+        const labelPair m(mRows, mRows);
+
+        SquareMatrix<Type> A
+        (
+            makeRandomMatrix<SquareMatrix<Type>>(m, rndGen)
+        );
+        // Symmetrise with noise
+        for (label n = 0; n < A.n() - 1; ++n)
+        {
+            for (label m = A.m() - 1; m > n; --m)
+            {
+                A(n, m) = A(m, n) + SMALL;
+            }
+        }
+
+        const bool symmetric = true;
+        const EigenMatrix<Type> EM(A, symmetric);
+        const DiagonalMatrix<Type>& EValsRe = EM.EValsRe();
+
+        test_eigenvalues_sum(A, EValsRe);
+    }
+}
+
+
+// Test the relation: "(A & EVec - EVal*EVec) = 0"
+template<class Type>
+void test_characteristic_eq
+(
+    const SquareMatrix<Type>& Aorig,
+    const DiagonalMatrix<Type>& EValsRe,
+    const DiagonalMatrix<Type>& EValsIm,
+    const SquareMatrix<complex>& EVecs
+)
+{
+    SquareMatrix<complex> A(Aorig.m());
+    auto convertToComplex = [&](const scalar& val) { return complex(val); };
+    std::transform
+    (
+        Aorig.cbegin(),
+        Aorig.cend(),
+        A.begin(),
+        convertToComplex
+    );
+
+    for (label i = 0; i < A.m(); ++i)
+    {
+        const RectangularMatrix<complex>& EVec(EVecs.subColumn(i));
+        const complex EVal(EValsRe[i], EValsIm[i]);
+        const RectangularMatrix<complex> leftSide(A*EVec);
+        const RectangularMatrix<complex> rightSide(EVal*EVec);
+
+        cmp
+        (
+            "  # (A & EVec - EVal*EVec) = 0:",
+            flt(leftSide),
+            flt(rightSide),
+            getTol(Type(0))
+        );
+    }
+}
+
+
+// Test eigenvectors in eigendecomposition relations
+template<class Type>
+void test_eigenvectors(Type)
+{
+    Random rndGen(1234);
+    const label numberOfTests = 20;
+
+    // Non-symmetric
+    for (label i = 0; i < numberOfTests; ++i)
+    {
+        const label mRows = rndGen.position(100, 200);
+        const labelPair m(mRows, mRows);
+
+        const SquareMatrix<Type> A
+        (
+            makeRandomMatrix<SquareMatrix<Type>>(m, rndGen)
+        );
+
+        const EigenMatrix<Type> EM(A);
+        const DiagonalMatrix<Type>& EValsRe = EM.EValsRe();
+        const DiagonalMatrix<Type>& EValsIm = EM.EValsIm();
+        const SquareMatrix<complex> EVecs(EM.complexEVecs());
+
+        test_characteristic_eq(A, EValsRe, EValsIm, EVecs);
+    }
+
+    // Symmetric
+    for (label i = 0; i < numberOfTests; ++i)
+    {
+        const label mRows = rndGen.position(100, 200);
+        const labelPair m(mRows, mRows);
+
+        SquareMatrix<Type> A
+        (
+            makeRandomMatrix<SquareMatrix<Type>>(m, rndGen)
+        );
+        // Symmetrise with noise
+        for (label n = 0; n < A.n() - 1; ++n)
+        {
+            for (label m = A.m() - 1; m > n; --m)
+            {
+                A(n, m) = A(m, n) + SMALL;
+            }
+        }
+
+        const bool symmetric = true;
+        const EigenMatrix<Type> EM(A, symmetric);
+        const DiagonalMatrix<Type>& EValsRe = EM.EValsRe();
+        const DiagonalMatrix<Type>& EValsIm = EM.EValsIm();
+        const SquareMatrix<complex> EVecs(EM.complexEVecs());
+
+        test_characteristic_eq(A, EValsRe, EValsIm, EVecs);
+    }
+}
+
+
+// Do compile-time recursion over the given types
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I == sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
+
+
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I < sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+{
+    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
+    test_constructors(std::get<I>(types));
+
+    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
+    test_member_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test eigenvalues: "<< typeID[I] <<" ##" << nl;
+    test_eigenvalues(std::get<I>(types));
+
+    Info<< nl << "    ## Test eigenvectors: "<< typeID[I] <<" ##" << nl;
+    test_eigenvectors(std::get<I>(types));
+
+    run_tests<I + 1, Tp...>(types, typeID);
+}
+
+
+// * * * * * * * * * * * * * * * Main Program  * * * * * * * * * * * * * * * //
+
+int main()
+{
+    Info<< setprecision(15);
+
+    const std::tuple<floatScalar, doubleScalar> types
+    (
+        std::make_tuple(Zero, Zero)
+    );
+
+    const List<word> typeID
+    ({
+        "SquareMatrix<floatScalar>",
+        "SquareMatrix<doubleScalar>"
+    });
+
+    run_tests(types, typeID);
+
+
+    Info<< nl << "    ## Test corner cases ##" << endl;
+    {
+        Info<< nl  << "  ## Rosser et al. (1951) matrix: ##" << nl;
+        // Rosser, J. B., Lanczos, C., Hestenes, M. R., & Karush, W. (1951).
+        // Separation of close eigenvalues of a real symmetric matrix.
+        // Jour. Research of the National Bureau of Standards, 47(4), 291-297.
+        // DOI:10.6028/jres.047.037
+        // 
+        // 8x8 symmetric square matrix consisting of close real eigenvalues
+        // ibid, p. 294
+        // {
+        //      1020.04901843, 1020.000, 1019.90195136, 1000.000,
+        //      1000.000, 0.09804864072, 0.000, -1020.0490
+        // }
+        // Note that prod(eigenvalues) != determinant(A) for this matrix
+        // via the LAPACK routine z/dgetrf
+
+        SquareMatrix<doubleScalar> A(8, Zero);
+        assignMatrix
+        (
+            A,
+            {
+                611, 196, -192, 407, -8, -52, -49, 29,
+                196, 899, 113, -192, -71, -43, -8, -44,
+                -192, 113, 899, 196, 61, 49, 8, 52,
+                407, -192, 196, 611, 8, 44, 59, -23,
+                -8, -71, 61, 8, 411, -599, 208, 208,
+                -52, -43, 49, 44, -599, 411, 208, 208,
+                -49, -8, 8, 59, 208, 208, 99, -911,
+                29, -44, 52, -23, 208, 208, -911, 99
+            }
+        );
+        const EigenMatrix<doubleScalar> EM(A);
+        const DiagonalMatrix<doubleScalar>& EValsRe = EM.EValsRe();
+        const DiagonalMatrix<doubleScalar>& EValsIm = EM.EValsIm();
+
+        test_eigenvalues_sum(A, EValsRe);
+
+        cmp
+        (
+            "  # Rosser et al. (1951) case, EValsRe = ",
+            EValsRe,
+            List<doubleScalar> // theoretical EValsRe
+            ({
+                -1020.0490, 0.000, 0.09804864072, 1000.000,
+                1000.000, 1019.90195136, 1020.000, 1020.04901843
+            }),
+            1e-3
+        );
+        cmp
+        (
+            "  # Rosser et al. (1951) case, EValsIm = ",
+            EValsIm,
+            List<doubleScalar>(8, Zero)
+        );
+    }
+    {
+        Info<< nl  << "  ## Test eigenvector unpacking: ##" << nl;
+
+        SquareMatrix<doubleScalar> A(3, Zero);
+        assignMatrix
+        (
+            A,
+            {
+                1, 2, 3,
+                -4, -5, 6,
+                7, -8, 9
+            }
+        );
+        const EigenMatrix<doubleScalar> EM(A);
+        const SquareMatrix<complex> complexEVecs(EM.complexEVecs());
+
+        SquareMatrix<complex> B(3, Zero);
+        assignMatrix
+        (
+            B,
+            {
+                complex(-0.373220280),
+                complex(0.417439996, 0.642691344),
+                complex(0.417439996, -0.642691344),
+                complex(-0.263919251),
+                complex(-1.165275867, 0.685068715),
+                complex(-1.165275867, -0.685068715),
+                complex(-0.889411744),
+                complex(-0.89990601, -0.3672785281),
+                complex(-0.89990601, 0.3672785281),
+            }
+        );
+
+        cmp
+        (
+            "  # ",
+            flt(complexEVecs),
+            flt(B)
+        );
+    }
+    {
+        Info<< nl << "  ## Test matrices with small values: ##" << nl;
+
+        const List<doubleScalar> epsilons
+        ({
+            0, SMALL, Foam::sqrt(SMALL), sqr(SMALL), Foam::cbrt(SMALL),
+            -SMALL, -Foam::sqrt(SMALL), -sqr(SMALL), -Foam::cbrt(SMALL)
+        });
+
+        Random rndGen(1234);
+        const label numberOfTests = 20;
+
+        for (label i = 0; i < numberOfTests; ++i)
+        {
+            const label mRows = rndGen.position(100, 200);
+ 
+            for (const auto& eps : epsilons)
+            {
+                const SquareMatrix<doubleScalar> A(mRows, eps);
+
+                const EigenMatrix<doubleScalar> EM(A);
+                const DiagonalMatrix<doubleScalar>& EValsRe = EM.EValsRe();
+                const DiagonalMatrix<doubleScalar>& EValsIm = EM.EValsIm();
+                const SquareMatrix<complex> EVecs(EM.complexEVecs());
+
+                test_eigenvalues_sum(A, EValsRe);
+                test_characteristic_eq(A, EValsRe, EValsIm, EVecs);
+            }
+        }
+    }
+    {
+        Info<< nl << "  ## Test matrices with repeating eigenvalues: ##" << nl;
+        SquareMatrix<doubleScalar> A(3, Zero);
+        assignMatrix
+        (
+            A,
+            {
+                0, 1, 1,
+                1, 0, 1,
+                1, 1, 0
+            }
+        );
+        const EigenMatrix<doubleScalar> EM(A);
+        const DiagonalMatrix<doubleScalar>& EValsRe = EM.EValsRe();
+        const DiagonalMatrix<doubleScalar>& EValsIm = EM.EValsIm();
+        const SquareMatrix<complex> EVecs(EM.complexEVecs());
+
+        test_eigenvalues_sum(A, EValsRe);
+        test_characteristic_eq(A, EValsRe, EValsIm, EVecs);
+    }
+
+
+    if (nFail_)
+    {
+        Info<< nl << "        #### "
+            << "Failed in " << nFail_ << " tests "
+            << "out of total " << nTest_ << " tests "
+            << "####\n" << endl;
+        return 1;
+    }
+
+    Info<< nl << "        #### Passed all " << nTest_ <<" tests ####\n" << endl;
+    return 0;
+}
diff --git a/applications/test/Matrix/Make/files b/applications/test/matrices/Matrix/Make/files
similarity index 100%
rename from applications/test/Matrix/Make/files
rename to applications/test/matrices/Matrix/Make/files
diff --git a/applications/test/Matrix/Make/options b/applications/test/matrices/Matrix/Make/options
similarity index 100%
rename from applications/test/Matrix/Make/options
rename to applications/test/matrices/Matrix/Make/options
diff --git a/applications/test/Matrix/Test-Matrix.C b/applications/test/matrices/Matrix/Test-Matrix.C
similarity index 99%
rename from applications/test/Matrix/Test-Matrix.C
rename to applications/test/matrices/Matrix/Test-Matrix.C
index 1cbc602545..43115df871 100644
--- a/applications/test/Matrix/Test-Matrix.C
+++ b/applications/test/matrices/Matrix/Test-Matrix.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
diff --git a/applications/test/QRMatrix/Make/files b/applications/test/matrices/QRMatrix/Make/files
similarity index 100%
rename from applications/test/QRMatrix/Make/files
rename to applications/test/matrices/QRMatrix/Make/files
diff --git a/applications/test/QRMatrix/Make/options b/applications/test/matrices/QRMatrix/Make/options
similarity index 100%
rename from applications/test/QRMatrix/Make/options
rename to applications/test/matrices/QRMatrix/Make/options
diff --git a/applications/test/QRMatrix/Test-QRMatrix.C b/applications/test/matrices/QRMatrix/Test-QRMatrix.C
similarity index 99%
rename from applications/test/QRMatrix/Test-QRMatrix.C
rename to applications/test/matrices/QRMatrix/Test-QRMatrix.C
index 281c62dd5b..6790727152 100644
--- a/applications/test/QRMatrix/Test-QRMatrix.C
+++ b/applications/test/matrices/QRMatrix/Test-QRMatrix.C
@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,7 +37,6 @@ using namespace Foam::MatrixTools;
 #define RUNALL true
 const bool verbose = true;
 
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 void horizontalLine()
diff --git a/applications/test/matrices/RectangularMatrix/Make/files b/applications/test/matrices/RectangularMatrix/Make/files
new file mode 100644
index 0000000000..49b520d079
--- /dev/null
+++ b/applications/test/matrices/RectangularMatrix/Make/files
@@ -0,0 +1,3 @@
+Test-RectangularMatrix.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-RectangularMatrix
diff --git a/applications/test/matrices/RectangularMatrix/Make/options b/applications/test/matrices/RectangularMatrix/Make/options
new file mode 100644
index 0000000000..b23590707c
--- /dev/null
+++ b/applications/test/matrices/RectangularMatrix/Make/options
@@ -0,0 +1,2 @@
+EXE_INC = -I../../TestTools
+/* EXE_LIBS = -lfiniteVolume */
diff --git a/applications/test/matrices/RectangularMatrix/Test-RectangularMatrix.C b/applications/test/matrices/RectangularMatrix/Test-RectangularMatrix.C
new file mode 100644
index 0000000000..fbcf4c6343
--- /dev/null
+++ b/applications/test/matrices/RectangularMatrix/Test-RectangularMatrix.C
@@ -0,0 +1,878 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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/>.
+
+Application
+    Test-RectangularMatrix
+
+Description
+    Tests for \c RectangularMatrix constructors, member functions, member
+    operators, global functions, global operators, and friend functions using
+    \c floatScalar, \c doubleScalar, and \c complex base types.
+
+    Cross-checks were obtained from 'NumPy 1.15.1' if no theoretical
+    cross-check exists (like eigendecomposition relations), and
+    were hard-coded for elementwise comparisons.
+
+    For \c complex base type, the cross-checks do only involve zero imag part.
+
+Note
+    Pending tests were tagged as "## Pending ##".
+
+\*---------------------------------------------------------------------------*/
+
+#include "RectangularMatrix.H"
+#include "SquareMatrix.H"
+#include "floatScalar.H"
+#include "doubleScalar.H"
+#include "complex.H"
+#include "IOmanip.H"
+#include "TestTools.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Create each constructor of RectangularMatrix<Type>, and print output
+template<class Type>
+void test_constructors(Type)
+{
+    {
+        Info<< "# Construct a square matrix (rows == columns):" << nl;
+        const RectangularMatrix<Type> A(5);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns:" << nl;
+        const RectangularMatrix<Type> A(2, 4);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "initializing all elements to zero:" << nl;
+        const RectangularMatrix<Type> A(2, 4, Zero);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "initializing all elements to a value:" << nl;
+        const RectangularMatrix<Type> A(2, 4, Type(3));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "initializing all elements to zero, and diagonal to one:" << nl;
+        const RectangularMatrix<Type> A(labelPair(2, 4), I);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "by using a label pair:" << nl;
+        const RectangularMatrix<Type> A(labelPair(2, 4));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns by using a label pair "
+            << "and initializing all elements to zero:" << nl;
+        const RectangularMatrix<Type> A(labelPair(2, 4), Zero);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns by using a label pair "
+            << "and initializing all elements to the given value:" << nl;
+        const RectangularMatrix<Type> A(labelPair(2, 4), Type(3));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct from a block of another matrix:" << nl;
+        const RectangularMatrix<Type> B(labelPair(2, 4), Type(3));
+        const RectangularMatrix<Type> A(B.subMatrix(1, 1));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct from a block of another matrix:" << nl;
+        RectangularMatrix<Type> B(labelPair(2, 4), Type(3));
+        const RectangularMatrix<Type> A(B.subMatrix(1, 1));
+        Info<< A << endl;
+    }
+    {
+        Info<< "#: Construct as copy of a square matrix:" << nl;
+        const SquareMatrix<Type> B(5);
+        const RectangularMatrix<Type> A(B);
+        Info<< A << endl;
+    }
+}
+
+
+// Execute each member function of RectangularMatrix<Type>, and print output
+template<class Type>
+void test_member_funcs(Type)
+{
+    RectangularMatrix<Type> A(labelPair(2, 3), Zero);
+    assignMatrix
+    (
+        A,
+        {
+            Type(1), Type(-2.2), Type(-3.4),
+            Type(-0.35), Type(1), Type(5)
+        }
+    );
+
+    Info<< "# Operand: " << nl
+        << "  RectangularMatrix = " << A << endl;
+
+
+    // Matrix.H
+    {
+        Info<< "# Access:" << nl;
+
+        cmp("  The number of rows = ", Type(A.m()), Type(2));
+        cmp("  The number of columns = ", Type(A.n()), Type(3));
+        cmp("  The number of elements in Matrix = ", Type(A.size()), Type(6));
+        cmp("  Return row/column sizes = ", A.sizes(), labelPair(2, 3));
+        cmp("  Return true if Matrix is empty = ", A.empty(), false);
+        cmp
+        (
+            "  Return const pointer to the first data elem = ",
+            *(A.cdata()),
+            Type(1)
+        );
+        cmp
+        (
+            "  Return pointer to the first data elem = ",
+            *(A.data()),
+            Type(1)
+        );
+        cmp
+        (
+            "  Return const pointer to data in the specified row = ",
+            *(A.rowData(1)),
+            Type(-0.35)
+        );
+        cmp
+        (
+            "  Return pointer to data in the specified row = ",
+            *(A.rowData(1)),
+            Type(-0.35)
+        );
+        const Type& a = A.at(4);
+        cmp("  Linear addressing const element access = ", a, Type(1));
+        Type& b = A.at(4);
+        cmp("  Linear addressing element access = ", b, Type(1));
+    }
+    {
+        Info<< "# Block access (const):" << nl;
+
+        const RectangularMatrix<Type> Acol(A.subColumn(1));
+        cmp
+        (
+            "  Return const column or column's subset of Matrix = ",
+            flt(Acol),
+            List<Type>({Type(-2.2), Type(1)})
+        );
+
+        const RectangularMatrix<Type> Arow(A.subRow(1));
+        cmp
+        (
+            "  Return const row or row's subset of Matrix = ",
+            flt(Arow),
+            List<Type>({Type(-0.35), Type(1), Type(5)})
+        );
+
+        const RectangularMatrix<Type> Amat(A.subMatrix(1, 1));
+        cmp
+        (
+            "  Return const sub-block of Matrix = ",
+            flt(Amat),
+            List<Type>({Type(1), Type(5)})
+        );
+    }
+    {
+        Info<< "# Block access (non-const):" << nl;
+
+        RectangularMatrix<Type> Acol(A.subColumn(1));
+        cmp
+        (
+            "  Return column or column's subset of Matrix = ",
+            flt(Acol),
+            List<Type>({Type(-2.2), Type(1)})
+        );
+
+        RectangularMatrix<Type> Arow(A.subRow(1));
+        cmp
+        (
+            "  Return row or row's subset of Matrix = ",
+            flt(Arow),
+            List<Type>({Type(-0.35), Type(1), Type(5)})
+        );
+
+        RectangularMatrix<Type> Amat(A.subMatrix(1, 1));
+        cmp
+        (
+            "  Return sub-block of Matrix = ",
+            flt(Amat),
+            List<Type>({Type(1), Type(5)})
+        );
+    }
+    {
+        Info<< "# Check:" << nl;
+
+        A.checki(0);
+        A.checkj(1);
+        A.checkSize();
+        cmp("  Check all entries have identical values = ", A.uniform(), false);
+    }
+    {
+        Info<< "# Edit:" << nl;
+
+        RectangularMatrix<Type> cpA(A);
+        cpA.clear();
+        cmp("  Clear Matrix, i.e. set sizes to zero = ", cpA.empty(), true);
+
+        RectangularMatrix<Type> cpA1(A);
+        cmp
+        (
+            "  Release storage management of Matrix contents by transferring "
+            "management to a List = ",
+            (cpA1.release()),
+            List<Type>
+            ({
+                Type(1), Type(-2.2), Type(-3.4), Type(-0.35), Type(1), Type(5)
+            })
+        );
+
+        RectangularMatrix<Type> cpA2(A);
+        cpA2.swap(cpA1);
+        cmp("  Swap contents = ", flt(cpA1), flt(A));
+
+        cpA2.transfer(cpA1);
+        cmp
+        (
+            "  Transfer the contents of the argument Matrix into this Matrix "
+            "and annul the argument MatrixSwap contents = ",
+            flt(cpA2),
+            flt(A)
+        );
+
+        cpA2.resize(1, 2);
+        cmp
+        (
+            "  Change Matrix dimensions, preserving the elements = ",
+            flt(cpA2),
+            List<Type>({Type(1), Type(-2.2)})
+        );
+
+        RectangularMatrix<Type> cpA3(A);
+        cpA3.setSize(1, 2);
+        cmp
+        (
+            "  Change Matrix dimensions, preserving the elements = ",
+            flt(cpA3),
+            List<Type>({Type(1), Type(-2.2)})
+        );
+
+        RectangularMatrix<Type> cpA4(A);
+        cpA4.shallowResize(1, 2);
+        cmp
+        (
+            "  Resize Matrix without reallocating storage (unsafe) = ",
+            flt(cpA4),
+            List<Type>({Type(1), Type(-2.2)})
+        );
+
+        RectangularMatrix<Type> smallA(labelPair(2, 3), Type(VSMALL));
+        smallA.round();
+        cmp
+        (
+            "  Round elements with mag smaller than tol (SMALL) to zero = ",
+            flt(smallA),
+            List<Type>(6, Zero)
+        );
+    }
+    {
+        Info<< "# Operations:" << nl;
+
+        cmp("  Transpose = ", flt((A.T()).T()), flt(A));
+
+        RectangularMatrix<complex> cA(labelPair(2, 2), Zero);
+        assignMatrix
+        (
+            cA,
+            {
+                complex(2, -1.2), complex(4.1, 0.4),
+                complex(8.1, -1.25), complex(7.3, -1.4)
+            }
+        );
+        RectangularMatrix<complex> cAT(labelPair(2, 2), Zero);
+        assignMatrix
+        (
+            cAT,
+            {
+                complex(2, 1.2), complex(8.1, 1.25),
+                complex(4.1, -0.4), complex(7.3, 1.4)
+            }
+        );
+        cmp("  Hermitian transpose = ", flt(cA.T()), flt(cAT));
+
+        RectangularMatrix<Type> B(3, 3, Zero);
+        assignMatrix
+        (
+            B,
+            {
+                Type(4.1), Type(12.5), Type(-16.3),
+                Type(-192.3), Type(-9.1), Type(-3.0),
+                Type(1.0), Type(5.02), Type(-4.4)
+            }
+        );
+        const RectangularMatrix<Type> cpB(B);
+        const List<Type> lst({Type(1), Type(2), Type(3)});
+        const Field<Type> out1(B*lst);
+        const Field<Type> out2(B.Amul(lst));
+        const Field<Type> out3(lst*B);
+        const Field<Type> out4(B.Tmul(lst));
+        const Field<Type> rsult1({Type(-19.8), Type(-219.5), Type(-2.16)});
+        const Field<Type> rsult2({Type(-377.5), Type(9.36), Type(-35.5)});
+        cmp
+        (
+            "  Right-multiply Matrix by a List (A * x) = ",
+            out1,
+            rsult1,
+            1e-4
+        );
+        cmp
+        (
+            "  Right-multiply Matrix by a column vector A.Amul(x) = ",
+            out1,
+            out2,
+            1e-4
+        );
+        cmp
+        (
+            "  Left-multiply Matrix by a List (x * A) = ",
+            out3,
+            rsult2,
+            1e-4
+        );
+        cmp
+        (
+            "  Left-multiply Matrix by a row vector A.Tmul(x) = ",
+            out4,
+            rsult2,
+            1e-4
+        );
+
+        List<Type> diagB1({Type(4.1), Type(-9.1), Type(-4.4)});
+        cmp
+        (
+            "  Extract the diagonal elements = ",
+            B.diag(),
+            diagB1
+        );
+
+        List<Type> diagB2({Type(-100), Type(-100), Type(-100)});
+        B.diag(diagB2);
+        cmp
+        (
+            "  Assign diagonal of Matrix = ",
+            B.diag(),
+            diagB2
+        );
+
+        B = cpB;
+        cmp("  Trace = ", B.trace(), Type(-9.4), 1e-4);
+        cmp
+        (
+            "  Return L2-Norm of chosen column = ",
+            B.columnNorm(0),
+            192.34630227794867,
+            1e-4
+        );
+        cmp
+        (
+            "  Return L2-Norm of chosen column (noSqrt=true) = ",
+            B.columnNorm(0, true),
+            36997.1,
+            1e-2
+        );
+        cmp
+        (
+            "  Return Frobenius norm of Matrix = ",
+            B.norm(),
+            193.7921835369012,
+            1e-4
+        );
+    }
+}
+
+
+// Execute each member operators of RectangularMatrix<Type>, and print output
+template<class Type>
+void test_member_opers(Type)
+{
+    RectangularMatrix<Type> A(labelPair(2, 4), I);
+    const RectangularMatrix<Type> cpA(A);
+
+    Info<< "# Operand: " << nl
+        << "  RectangularMatrix = " << A << endl;
+
+
+    A = Zero;
+    cmp("  Assign all elements to zero =", flt(A), List<Type>(8, Zero));
+    A = cpA;
+
+    A = Type(5);
+    cmp("  Assign all elements to value =", flt(A), List<Type>(8, Type(5)));
+    A = cpA;
+
+    const Type* a = A[1];
+    cmp
+    (
+        "  Return const pointer to data in the specified row = ",
+        *a,
+        Type(0)
+    );
+
+    Type* b = A[1];
+    cmp
+    (
+        "  Return pointer to data in the specified row = ",
+        *b,
+        Type(0)
+    );
+
+    const Type& c = A(1, 1);
+    cmp
+    (
+        "  (i, j) const element access operator = ",
+        c,
+        Type(1)
+    );
+
+    Type& d = A(1, 1);
+    cmp
+    (
+        "  (i, j) element access operator = ",
+        d,
+        Type(1)
+    );
+
+    //  ## Pending ##
+    //  Copy assignment
+    //  Move assignment
+    //  Assignment to a block of another Matrix
+    //  Assignment to a block of another Matrix
+    //  #############
+
+    A = Zero;
+    cmp
+    (
+        "  Assignment of all elements to zero = ",
+        flt(A),
+        flt(RectangularMatrix<Type>(2, 4, Zero))
+    );
+    A = cpA;
+
+    A = Type(-1.2);
+    cmp
+    (
+        "  Assignment of all elements to the given value = ",
+        flt(A),
+        flt(RectangularMatrix<Type>(2, 4, Type(-1.2)))
+    );
+    A = cpA;
+
+    A += cpA;
+    cmp
+    (
+        "  Matrix addition =",
+        flt(A),
+        flt(Type(2)*cpA)
+    );
+    A = cpA;
+
+    A -= cpA;
+    cmp
+    (
+        "  Matrix subtraction = ",
+        flt(A),
+        flt(RectangularMatrix<Type>(2, 4, Zero))
+    );
+    A = cpA;
+
+    A = Zero;
+    A += Type(5);
+    cmp
+    (
+        "  Matrix scalar addition = ",
+        flt(A),
+        flt(RectangularMatrix<Type>(2, 4, Type(5)))
+    );
+    A = cpA;
+
+    A = Zero;
+    A -= Type(5);
+    cmp
+    (
+        "  Matrix scalar subtraction = ",
+        flt(A),
+        flt(RectangularMatrix<Type>(2, 4, Type(-5)))
+    );
+    A = cpA;
+
+    A = Type(1);
+    A *= Type(5);
+    cmp
+    (
+        "  Matrix scalar multiplication = ",
+        flt(A),
+        flt(RectangularMatrix<Type>(2, 4, Type(5)))
+    );
+    A = cpA;
+
+    A = Type(1);
+    A /= Type(5);
+    cmp
+    (
+        "  Matrix scalar division = ",
+        flt(A),
+        flt(RectangularMatrix<Type>(2, 4, Type(0.2)))
+    );
+    A = cpA;
+
+    A(0,0) = Type(-10.5);
+    Type* i0 = A.begin();
+    cmp
+    (
+        "  Return an iterator to begin traversing a Matrix = ",
+        *i0,
+        Type(-10.5)
+    );
+
+    A(1,3) = Type(20);
+    Type* i1 = A.end();
+    cmp
+    (
+        "  Return an iterator to end traversing a Matrix = ",
+        *(--i1),
+        Type(20)
+    );
+
+    const Type* i2 = A.cbegin();
+    cmp
+    (
+        "  Return const iterator to begin traversing a Matrix = ",
+        *i2,
+        Type(-10.5)
+    );
+
+    const Type* i3 = A.cend();
+    cmp
+    (
+        "  Return const iterator to end traversing a Matrix = ",
+        *(--i3),
+        Type(20)
+    );
+
+    const Type* i4 = A.begin();
+    cmp
+    (
+        "  Return const iterator to begin traversing a Matrix = ",
+        *i4,
+        Type(-10.5)
+    );
+
+    const Type* i5 = A.end();
+    cmp
+    (
+        "  Return const iterator to end traversing a Matrix = ",
+        *(--i5),
+        Type(20)
+    );
+
+    //  ## Pending ##
+    //  Read Matrix from Istream, discarding existing contents
+    //  Write Matrix, with line-breaks in ASCII when length exceeds shortLen
+    //  #############
+}
+
+
+// Execute each friend function of RectangularMatrix<Type>, and print output
+template<class Type>
+void test_friend_funcs(Type)
+{
+    const Field<Type> F
+    ({
+        Type(1), Type(-2.2),
+        Type(10), Type(-0.1)
+    });
+
+    Info<< "# Operand: " << nl
+        << "  Field = " << F << endl;
+
+    {
+        RectangularMatrix<Type> A(labelPair(4, 4), Zero);
+        assignMatrix
+        (
+            A,
+            {
+                Type(1), Type(-2.2), Type(10), Type(-0.1),
+                Type(-2.2), Type(4.84), Type(-22), Type(0.22),
+                Type(10), Type(-22), Type(100), Type(-1),
+                Type(-0.1), Type(0.22), Type(-1), Type(0.01)
+            }
+        );
+        cmp
+        (
+            "  Return the outer product of Field-Field as RectangularMatrix = ",
+            flt(outer(F, F)),
+            flt(A),
+            1e-6
+        );
+    }
+}
+
+
+// Execute each global function of RectangularMatrix<Type>, and print output
+template<class Type>
+void test_global_funcs(Type)
+{
+    RectangularMatrix<Type> A(labelPair(2, 3), Zero);
+    assignMatrix
+    (
+        A,
+        {
+            Type(1), Type(-2.2), Type(-3.4),
+            Type(-0.35), Type(10.32), Type(5)
+        }
+    );
+    const RectangularMatrix<Type> cpA(A);
+
+    Info<< "# Operand: " << nl
+        << "  RectangularMatrix = " << A << endl;
+
+
+    //  ## Pending ##
+    //  cmp("  Find max value in Matrix = ", max(A), Type(10.32));
+    //  cmp("  Find min value in Matrix = ", min(A), Type(-3.4));
+    //  cmp
+    //  (
+    //      "  Find min-max value in Matrix = ",
+    //      minMax(A),
+    //      MinMax<Type>(10.32, -3.4)
+    //  );
+    //  #############
+}
+
+
+// Execute each global operators of RectangularMatrix<Type>, and print output
+template<class Type>
+void test_global_opers(Type)
+{
+    RectangularMatrix<Type> A(labelPair(2, 3), Zero);
+    assignMatrix
+    (
+        A,
+        {
+            Type(1), Type(-2.2), Type(-3.4),
+            Type(-0.35), Type(10.32), Type(5)
+        }
+    );
+    const RectangularMatrix<Type> cpA(A);
+
+    Info<< "# Operand: " << nl
+        << "  RectangularMatrix = " << A << endl;
+
+
+    // Matrix.C
+    cmp("  Matrix negation = ", flt(-A), flt(Type(-1)*A));
+    cmp("  Matrix addition = ", flt(A + A), flt(Type(2)*A));
+    cmp("  Matrix subtraction = ", flt(A - A), flt(Type(0)*A));
+    cmp("  Scalar multiplication = ", flt(Type(2)*A), flt(A + A));
+    cmp("  Scalar multiplication = ", flt(A*Type(2)), flt(A + A));
+    cmp
+    (
+        "  Scalar addition = ",
+        flt(Type(0)*A + Type(1)),
+        flt(RectangularMatrix<Type>(A.sizes(), Type(1)))
+    );
+    cmp
+    (
+        "  Scalar addition = ",
+        flt(Type(1) + Type(0)*A),
+        flt(RectangularMatrix<Type>(A.sizes(), Type(1)))
+    );
+    cmp
+    (
+        "  Scalar subtraction = ",
+        flt(Type(0)*A - Type(1)),
+        flt(RectangularMatrix<Type>(A.sizes(), Type(-1)))
+    );
+    cmp
+    (
+        "  Scalar subtraction = ",
+        flt(Type(1) - Type(0)*A),
+        flt(RectangularMatrix<Type>(A.sizes(), Type(1)))
+    );
+    cmp
+    (
+        "  Scalar division = ",
+        flt((Type(1) + Type(0)*A)/Type(2.5)),
+        flt(RectangularMatrix<Type>(A.sizes(), Type(0.4)))
+    );
+
+    RectangularMatrix<Type> innerA(2, 2, Zero);
+    assignMatrix
+    (
+        innerA,
+        {
+            Type(17.4), Type(-40.054),
+            Type(-40.054), Type(131.6249)
+        }
+    );
+    const RectangularMatrix<Type> A1(A);
+    const RectangularMatrix<Type> A2(A.T());
+    cmp
+    (
+        "  Matrix-Matrix multiplication using ikj-algorithm = ",
+        flt(A1*A2),
+        flt(innerA),
+        1e-1
+    );
+    cmp
+    (
+        "  Implicit A.T()*B = ",
+        flt(A2&A2),
+        flt(innerA),
+        1e-1
+    );
+
+    RectangularMatrix<Type> outerA(3, 3, Zero);
+    assignMatrix
+    (
+        outerA,
+        {
+            Type(1.1225), Type(-5.812), Type(-5.15),
+            Type(-5.812), Type(111.3424), Type(59.08),
+            Type(-5.15), Type(59.08), Type(36.56)
+        }
+    );
+    cmp
+    (
+        "  Implicit A*B.T() = ",
+        flt(A2^A2),
+        flt(outerA),
+        1e-1
+    );
+
+    // MatrixI.H
+    const List<Type> lst({Type(1), Type(2), Type(-3)});
+    const List<Type> out1(A*lst);
+    const List<Type> out2(lst*A.T());
+    const List<Type> rslt1({Type(6.8), Type(5.29)});
+    const List<Type> rslt2({Type(6.8), Type(5.29)});
+    cmp
+    (
+        "  Matrix-vector multiplication (A * x), where x is a column vector = ",
+        out1,
+        rslt1,
+        1e-1
+    );
+    cmp
+    (
+        "  Vector-matrix multiplication (x * A), where x is a row vector = ",
+        out2,
+        rslt2,
+        1e-1
+    );
+}
+
+
+// Do compile-time recursion over the given types
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I == sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
+
+
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I < sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+{
+    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
+    test_constructors(std::get<I>(types));
+
+    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
+    test_member_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test member opers: "<< typeID[I] <<" ##" << nl;
+    test_member_opers(std::get<I>(types));
+
+    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
+    test_global_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test global operators: "<< typeID[I] << " ##" << nl;
+    test_global_opers(std::get<I>(types));
+
+    Info<< nl << "    ## Test friend funcs: "<< typeID[I] <<" ##" << nl;
+    test_friend_funcs(std::get<I>(types));
+
+    run_tests<I + 1, Tp...>(types, typeID);
+}
+
+
+// * * * * * * * * * * * * * * * Main Program  * * * * * * * * * * * * * * * //
+
+int main()
+{
+    Info<< setprecision(15);
+
+    const std::tuple<floatScalar, doubleScalar, complex> types
+    (
+        std::make_tuple(Zero, Zero, Zero)
+    );
+
+    const List<word> typeID
+    ({
+        "RectangularMatrix<floatScalar>",
+        "RectangularMatrix<doubleScalar>",
+        "RectangularMatrix<complex>"
+    });
+
+    run_tests(types, typeID);
+
+
+    if (nFail_)
+    {
+        Info<< nl << "        #### "
+            << "Failed in " << nFail_ << " tests "
+            << "out of total " << nTest_ << " tests "
+            << "####\n" << endl;
+        return 1;
+    }
+
+    Info<< nl << "        #### Passed all " << nTest_ <<" tests ####\n" << endl;
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/matrices/SquareMatrix/Make/files b/applications/test/matrices/SquareMatrix/Make/files
new file mode 100644
index 0000000000..e64b858cd6
--- /dev/null
+++ b/applications/test/matrices/SquareMatrix/Make/files
@@ -0,0 +1,3 @@
+Test-SquareMatrix.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-SquareMatrix
diff --git a/applications/test/matrices/SquareMatrix/Make/options b/applications/test/matrices/SquareMatrix/Make/options
new file mode 100644
index 0000000000..b23590707c
--- /dev/null
+++ b/applications/test/matrices/SquareMatrix/Make/options
@@ -0,0 +1,2 @@
+EXE_INC = -I../../TestTools
+/* EXE_LIBS = -lfiniteVolume */
diff --git a/applications/test/matrices/SquareMatrix/Test-SquareMatrix.C b/applications/test/matrices/SquareMatrix/Test-SquareMatrix.C
new file mode 100644
index 0000000000..d114dd3963
--- /dev/null
+++ b/applications/test/matrices/SquareMatrix/Test-SquareMatrix.C
@@ -0,0 +1,1000 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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/>.
+
+Application
+    Test-SquareMatrix
+
+Description
+    Tests for \c SquareMatrix constructors, member functions, member
+    operators, global functions, global operators, and friend functions using
+    \c floatScalar, \c doubleScalar, and \c complex base types.
+
+    Cross-checks were obtained from 'NumPy 1.15.1' if no theoretical
+    cross-check exists (like eigendecomposition relations), and
+    were hard-coded for elementwise comparisons.
+
+    For \c complex base type, the cross-checks do only involve zero imag part.
+
+Note
+    Pending tests were tagged as "## Pending ##".
+
+\*---------------------------------------------------------------------------*/
+
+#include "scalarMatrices.H"
+#include "RectangularMatrix.H"
+#include "SquareMatrix.H"
+#include "floatScalar.H"
+#include "doubleScalar.H"
+#include "complex.H"
+#include "IOmanip.H"
+#include "TestTools.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Create each constructor of SquareMatrix<Type>, and print output
+template<class Type>
+void test_constructors(Type)
+{
+    {
+        Info<< "# Construct for given size (rows == cols):" << nl;
+        const SquareMatrix<Type> A(2);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct for given size (rows == cols) "
+            << "initializing all elements to zero:" << nl;
+        const SquareMatrix<Type> A(2, Zero);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct for given size (rows == cols) "
+            << "initializing all elements to a value:" << nl;
+        const SquareMatrix<Type> A(2, Type(3));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct for given size (rows == cols) "
+            << "initializing to the identity matrix:" << nl;
+        const SquareMatrix<Type> A(2, I);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct for given size (rows == cols) by using a labelPair"
+            << "initializing to the identity matrix:" << nl;
+        const SquareMatrix<Type> A(labelPair(2, 2), I);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "by using a label pair (checked to be equal):" << nl;
+        const SquareMatrix<Type> A(labelPair(2, 2));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "by using a label pair (checked to be equal) "
+            << "and initializing all elements to zero:" << nl;
+        const SquareMatrix<Type> A(labelPair(2, 2), Zero);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "by using a label pair (checked to be equal) "
+            << "and initializing all elements to the given value:" << nl;
+        const SquareMatrix<Type> A(labelPair(2, 2), Type(3));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct given number of rows/columns "
+            << "(checked to be equal) initializing all elements to zero" << nl;
+        const SquareMatrix<Type> A(2, 2, Zero);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct from const sub-matrix block:" << nl;
+        const SquareMatrix<Type> B(labelPair(3, 3), Type(3));
+        const SquareMatrix<Type> A(B.subMatrix(1, 1));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct from sub-matrix block:" << nl;
+        SquareMatrix<Type> B(labelPair(3, 3), Type(3));
+        const SquareMatrix<Type> A(B.subMatrix(1, 1));
+        Info<< A << endl;
+    }
+    {
+        Info<< "#: Construct as copy of a RectangularMatrix:" << nl;
+        const RectangularMatrix<Type> B(2, 2, Zero);
+        const SquareMatrix<Type> A(B);
+        Info<< A << endl;
+    }
+
+    //  ## Pending ##
+    //  Construct from Istream
+    //  Clone
+    //  #############
+}
+
+
+// Execute each member function of SquareMatrix<Type>, and print output
+template<class Type>
+void test_member_funcs(Type)
+{
+    SquareMatrix<Type> A(labelPair(3, 3), Zero);
+    assignMatrix
+    (
+        A,
+        {
+            Type(1), Type(-2.2), Type(-3.4),
+            Type(-0.35), Type(1), Type(5),
+            Type(-0.35), Type(1), Type(5)
+        }
+    );
+
+    Info<< "# Operand: " << nl
+        << "  SquareMatrix = " << A << endl;
+
+
+    {
+        Info<< "# Access:" << nl;
+
+        cmp("  The number of rows = ", Type(A.m()), Type(3));
+        cmp("  The number of columns = ", Type(A.n()), Type(3));
+        cmp("  The number of elements in Matrix = ", Type(A.size()), Type(9));
+        cmp("  Return row/column sizes = ", A.sizes(), labelPair(3, 3));
+        cmp("  Return true if Matrix is empty = ", A.empty(), false);
+        cmp
+        (
+            "  Return const pointer to the first data elem = ",
+            *(A.cdata()),
+            Type(1)
+        );
+        cmp
+        (
+            "  Return pointer to the first data elem = ",
+            *(A.data()),
+            Type(1)
+        );
+        cmp
+        (
+            "  Return const pointer to data in the specified row = ",
+            *(A.rowData(1)),
+            Type(-0.35)
+        );
+        cmp
+        (
+            "  Return pointer to data in the specified row = ",
+            *(A.rowData(1)),
+            Type(-0.35)
+        );
+        const Type& a = A.at(4);
+        cmp("  Linear addressing const element access = ", a, Type(1));
+        Type& b = A.at(4);
+        cmp("  Linear addressing element access = ", b, Type(1));
+    }
+    {
+        Info<< "# Block access (const):" << nl;
+
+        const RectangularMatrix<Type> Acol(A.subColumn(1));
+        cmp
+        (
+            "  Return const column or column's subset of Matrix = ",
+            flt(Acol),
+            List<Type>({Type(-2.2), Type(1), Type(1)})
+        );
+
+        const RectangularMatrix<Type> Arow(A.subRow(1));
+        cmp
+        (
+            "  Return const row or row's subset of Matrix = ",
+            flt(Arow),
+            List<Type>({Type(-0.35), Type(1), Type(5)})
+        );
+
+        const RectangularMatrix<Type> Amat(A.subMatrix(1, 1));
+        cmp
+        (
+            "  Return const sub-block of Matrix = ",
+            flt(Amat),
+            List<Type>({Type(1), Type(5), Type(1), Type(5)})
+        );
+    }
+    {
+        Info<< "# Block access (non-const):" << nl;
+
+        RectangularMatrix<Type> Acol(A.subColumn(1));
+        cmp
+        (
+            "  Return column or column's subset of Matrix = ",
+            flt(Acol),
+            List<Type>({Type(-2.2), Type(1), Type(1)})
+        );
+
+        RectangularMatrix<Type> Arow(A.subRow(1));
+        cmp
+        (
+            "  Return row or row's subset of Matrix = ",
+            flt(Arow),
+            List<Type>({Type(-0.35), Type(1), Type(5)})
+        );
+
+        RectangularMatrix<Type> Amat(A.subMatrix(1, 1));
+        cmp
+        (
+            "  Return sub-block of Matrix = ",
+            flt(Amat),
+            List<Type>({Type(1), Type(5), Type(1), Type(5)})
+        );
+    }
+    {
+        Info<< "# Check:" << nl;
+
+        A.checki(0);
+        A.checkj(1);
+        A.checkSize();
+        cmp("  Check all entries have identical values = ", A.uniform(), false);
+
+        {
+            Random rndGen(1234);
+            const label mRows = 10;
+            SquareMatrix<Type> B
+            (
+                makeRandomMatrix<SquareMatrix<Type>>(labelPair(mRows, mRows), rndGen)
+            );
+            // Symmetrise
+            for (label n = 0; n < B.n() - 1; ++n)
+            {
+                for (label m = B.m() - 1; n < m; --m)
+                {
+                    B(n, m) = B(m, n);
+                }
+            }
+            cmp
+            (
+                "  Return true if the square matrix is "
+                "effectively symmetric/Hermitian",
+                B.symmetric(),
+                true
+            );
+        }
+        //  ## Pending ##
+        //  Return true if the square matrix is reduced tridiagonal
+        //  #############
+    }
+    {
+        Info<< "# Edit:" << nl;
+
+        SquareMatrix<Type> cpA0(A);
+        cpA0.clear();
+        cmp("  Clear Matrix, i.e. set sizes to zero = ", cpA0.empty(), true);
+
+        SquareMatrix<Type> cpA1(A);
+        cmp
+        (
+            "  Release storage management of Matrix contents by transferring "
+            "management to a List = ",
+            (cpA1.release()),
+            List<Type>
+            ({
+                Type(1), Type(-2.2), Type(-3.4),
+                Type(-0.35), Type(1), Type(5),
+                Type(-0.35), Type(1), Type(5)
+            })
+        );
+
+        SquareMatrix<Type> cpA2(A);
+        cpA2.swap(cpA1);
+        cmp("  Swap contents = ", flt(cpA1), flt(A));
+
+        cpA2.transfer(cpA1);
+        cmp
+        (
+            "  Transfer the contents of the argument Matrix into this Matrix "
+            "and annul the argument MatrixSwap contents = ",
+            flt(cpA2),
+            flt(A)
+        );
+
+        cpA2.resize(2, 2);
+        cmp
+        (
+            "  Change Matrix dimensions, preserving the elements = ",
+            flt(cpA2),
+            List<Type>({Type(1), Type(-2.2), Type(-0.35), Type(1)})
+        );
+
+        cpA2.resize(1);
+        cmp
+        (
+            "  Resize the matrix preserving the elements = ",
+            flt(cpA2),
+            List<Type>({Type(1)})
+        );
+
+        SquareMatrix<Type> cpA3(A);
+        cpA3.setSize(2);
+        cmp
+        (
+            "  Resize the matrix preserving the elements = ",
+            flt(cpA3),
+            List<Type>({Type(1), Type(-2.2), Type(-0.35), Type(1)})
+        );
+
+        SquareMatrix<Type> cpA4(A);
+        cpA4.shallowResize(2);
+        cmp
+        (
+            "  Resize the matrix without reallocating storage (unsafe) = ",
+            flt(cpA4),
+            List<Type>({Type(1), Type(-2.2), Type(-3.4), Type(-0.35)})
+        );
+
+        SquareMatrix<Type> smallA(2, Type(VSMALL));
+        smallA.round();
+        cmp
+        (
+            "  Round elements with mag smaller than tol (SMALL) to zero = ",
+            flt(smallA),
+            List<Type>(4, Zero)
+        );
+    }
+    {
+        Info<< "# Sort:" << nl;
+
+        SquareMatrix<Type> cpA(A);
+        auto descend = [&](Type a, Type b){ return mag(a) > mag(b); };
+        const List<label> sortPermutation(cpA.sortPermutation(descend));
+        cmp
+        (
+            "  Return a sort permutation labelList according to "
+            "a given comparison on the diagonal entries",
+            sortPermutation,
+            List<label>({2, 0, 1})
+        );
+
+        SquareMatrix<Type> sortedA0(3, Zero);
+        assignMatrix
+        (
+            sortedA0,
+            {
+                Type(-3.4), Type(1),     Type(-2.2),
+                Type(5),    Type(-0.35), Type(1),
+                Type(5),    Type(-0.35), Type(1)
+            }
+        );
+        const SquareMatrix<Type> sortedA1(applyPermutation(A, sortPermutation));
+        cmp
+        (
+            "  Return Matrix column-reordered according to "
+            "a given permutation labelList",
+            flt(sortedA0),
+            flt(sortedA1)
+        );
+
+        cpA.applyPermutation(sortPermutation);
+        cmp
+        (
+            "  Column-reorder this Matrix according to "
+            "a given permutation labelList",
+            flt(sortedA0),
+            flt(cpA)
+        );
+    }
+    {
+        Info<< "# Operations:" << nl;
+
+        cmp("  Transpose = ", flt((A.T()).T()), flt(A));
+
+        SquareMatrix<complex> cA(labelPair(2, 2), Zero);
+        assignMatrix
+        (
+            cA,
+            {
+                complex(2, -1.2), complex(4.1, 0.4),
+                complex(8.1, -1.25), complex(7.3, -1.4)
+            }
+        );
+        SquareMatrix<complex> cAT(labelPair(2, 2), Zero);
+        assignMatrix
+        (
+            cAT,
+            {
+                complex(2, 1.2), complex(8.1, 1.25),
+                complex(4.1, -0.4), complex(7.3, 1.4)
+            }
+        );
+        cmp("  Hermitian transpose = ", flt(cA.T()), flt(cAT));
+
+        SquareMatrix<Type> B(3, 3, Zero);
+        assignMatrix
+        (
+            B,
+            {
+                Type(4.1), Type(12.5), Type(-16.3),
+                Type(-192.3), Type(-9.1), Type(-3.0),
+                Type(1.0), Type(5.02), Type(-4.4)
+            }
+        );
+        const SquareMatrix<Type> cpB(B);
+        const List<Type> lst({Type(1), Type(2), Type(3)});
+        const Field<Type> out1(B*lst);
+        const Field<Type> out2(B.Amul(lst));
+        const Field<Type> out3(lst*B);
+        const Field<Type> out4(B.Tmul(lst));
+        const Field<Type> rsult1({Type(-19.8), Type(-219.5), Type(-2.16)});
+        const Field<Type> rsult2({Type(-377.5), Type(9.36), Type(-35.5)});
+        cmp
+        (
+            "  Right-multiply Matrix by a List (A * x) = ",
+            out1,
+            rsult1,
+            1e-4
+        );
+        cmp
+        (
+            "  Right-multiply Matrix by a column vector A.Amul(x) = ",
+            out1,
+            out2,
+            1e-4
+        );
+        cmp
+        (
+            "  Left-multiply Matrix by a List (x * A) = ",
+            out3,
+            rsult2,
+            1e-4
+        );
+        cmp
+        (
+            "  Left-multiply Matrix by a row vector A.Tmul(x) = ",
+            out4,
+            rsult2,
+            1e-4
+        );
+
+        List<Type> diagB1({Type(4.1), Type(-9.1), Type(-4.4)});
+        cmp
+        (
+            "  Extract the diagonal elements = ",
+            B.diag(),
+            diagB1
+        );
+
+        List<Type> diagB2({Type(-100), Type(-100), Type(-100)});
+        B.diag(diagB2);
+        cmp
+        (
+            "  Assign diagonal of Matrix = ",
+            B.diag(),
+            diagB2
+        );
+
+        B = cpB;
+        cmp("  Trace = ", B.trace(), Type(-9.4), 1e-4);
+        cmp
+        (
+            "  Return L2-Norm of chosen column = ",
+            B.columnNorm(0),
+            192.34630227794867,
+            1e-4
+        );
+        cmp
+        (
+            "  Return L2-Norm of chosen column (noSqrt=true) = ",
+            B.columnNorm(0, true),
+            36997.1,
+            1e-2
+        );
+        cmp
+        (
+            "  Return Frobenius norm of Matrix = ",
+            B.norm(),
+            193.7921835369012,
+            1e-4
+        );
+
+
+    }
+}
+
+
+// Execute each member operators of SquareMatrix<Type>, and print output
+template<class Type>
+void test_member_opers(Type)
+{
+    SquareMatrix<Type> A(3, I);
+    const SquareMatrix<Type> cpA(A);
+
+    Info<< "# Operand: " << nl
+        << "  SquareMatrix = " << A << endl;
+
+
+    A = Zero;
+    cmp("  Assign all elements to zero =", flt(A), List<Type>(9, Zero));
+    A = cpA;
+
+    A = Type(5);
+    cmp("  Assign all elements to value =", flt(A), List<Type>(9, Type(5)));
+    A = cpA;
+
+    A = I;
+    cmp("  Set to identity matrix =", flt(A), flt(cpA));
+    A = cpA;
+
+    const Type* a = A[1];
+    cmp
+    (
+        "  Return const pointer to data in the specified row = ",
+        *a,
+        Type(0)
+    );
+
+    Type* b = A[1];
+    cmp
+    (
+        "  Return pointer to data in the specified row = ",
+        *b,
+        Type(0)
+    );
+
+    const Type& c = A(1, 1);
+    cmp
+    (
+        "  (i, j) const element access operator = ",
+        c,
+        Type(1)
+    );
+
+    Type& d = A(1, 1);
+    cmp
+    (
+        "  (i, j) element access operator = ",
+        d,
+        Type(1)
+    );
+
+    //  ## Pending ##
+    //  Copy assignment
+    //  Move assignment
+    //  Assignment to a block of another Matrix
+    //  Assignment to a block of another Matrix
+    //  #############
+
+    A = Zero;
+    cmp
+    (
+        "  Assignment of all elements to zero = ",
+        flt(A),
+        flt(SquareMatrix<Type>(3, Zero))
+    );
+    A = cpA;
+
+    A = Type(-1.2);
+    cmp
+    (
+        "  Assignment of all elements to the given value = ",
+        flt(A),
+        flt(SquareMatrix<Type>(3, Type(-1.2)))
+    );
+    A = cpA;
+
+    A += cpA;
+    cmp
+    (
+        "  Matrix addition =",
+        flt(A),
+        flt(Type(2)*cpA)
+    );
+    A = cpA;
+
+    A -= cpA;
+    cmp
+    (
+        "  Matrix subtraction = ",
+        flt(A),
+        flt(SquareMatrix<Type>(3, Zero))
+    );
+    A = cpA;
+
+    A = Zero;
+    A += Type(5);
+    cmp
+    (
+        "  Matrix scalar addition = ",
+        flt(A),
+        flt(SquareMatrix<Type>(3, Type(5)))
+    );
+    A = cpA;
+
+    A = Zero;
+    A -= Type(5);
+    cmp
+    (
+        "  Matrix scalar subtraction = ",
+        flt(A),
+        flt(SquareMatrix<Type>(3, Type(-5)))
+    );
+    A = cpA;
+
+    A = Type(1);
+    A *= Type(5);
+    cmp
+    (
+        "  Matrix scalar multiplication = ",
+        flt(A),
+        flt(SquareMatrix<Type>(3, Type(5)))
+    );
+    A = cpA;
+
+    A = Type(1);
+    A /= Type(5);
+    cmp
+    (
+        "  Matrix scalar division = ",
+        flt(A),
+        flt(SquareMatrix<Type>(3, Type(0.2)))
+    );
+    A = cpA;
+
+    A(0,0) = Type(-10.5);
+    Type* i0 = A.begin();
+    cmp
+    (
+        "  Return an iterator to begin traversing a Matrix = ",
+        *i0,
+        Type(-10.5)
+    );
+
+    A(2,2) = Type(20);
+    Type* i1 = A.end();
+    cmp
+    (
+        "  Return an iterator to end traversing a Matrix = ",
+        *(--i1),
+        Type(20)
+    );
+
+    const Type* i2 = A.cbegin();
+    cmp
+    (
+        "  Return const iterator to begin traversing a Matrix = ",
+        *i2,
+        Type(-10.5)
+    );
+
+    const Type* i3 = A.cend();
+    cmp
+    (
+        "  Return const iterator to end traversing a Matrix = ",
+        *(--i3),
+        Type(20)
+    );
+
+    const Type* i4 = A.begin();
+    cmp
+    (
+        "  Return const iterator to begin traversing a Matrix = ",
+        *i4,
+        Type(-10.5)
+    );
+
+    const Type* i5 = A.end();
+    cmp
+    (
+        "  Return const iterator to end traversing a Matrix = ",
+        *(--i5),
+        Type(20)
+    );
+
+    //  ## Pending ##
+    //  Read Matrix from Istream, discarding existing contents
+    //  Write Matrix, with line-breaks in ASCII when length exceeds shortLen
+    //  #############
+}
+
+
+// Execute each friend function of SquareMatrix<Type>, and print output
+template<class Type>
+void test_friend_funcs(Type)
+{
+    const Field<Type> F
+    ({
+        Type(1), Type(-2.2),
+        Type(10), Type(-0.1)
+    });
+
+    Info<< "# Operand: " << nl
+        << "  Field = " << F << endl;
+
+    {
+        SquareMatrix<Type> A(labelPair(4, 4), Zero);
+        assignMatrix
+        (
+            A,
+            {
+                Type(1), Type(-2.2), Type(10), Type(-0.1),
+                Type(-2.2), Type(4.84), Type(-22), Type(0.22),
+                Type(10), Type(-22), Type(100), Type(-1),
+                Type(-0.1), Type(0.22), Type(-1), Type(0.01)
+            }
+        );
+        cmp
+        (
+            "  Return the outer product of Field-Field as RectangularMatrix = ",
+            flt(outer(F, F)),
+            flt(A),
+            1e-6
+        );
+        cmp
+        (
+            "  Return the outer product of Field-Field as SquareMatrix = ",
+            flt(symmOuter(F, F)),
+            flt(A),
+            1e-6
+        );
+    }
+}
+
+
+// Execute each global function of SquareMatrix<Type>, and print output
+template<class Type>
+void test_global_funcs(Type)
+{
+    SquareMatrix<Type> A(3, Zero);
+    assignMatrix
+    (
+        A,
+        {
+            Type(1), Type(-2.2), Type(-3.4),
+            Type(-0.35), Type(10.32), Type(5),
+            Type(-0.35), Type(10.32), Type(-5)
+        }
+    );
+    const SquareMatrix<Type> cpA(A);
+
+    Info<< "# Operand: " << nl
+        << "  SquareMatrix = " << A << endl;
+
+    //  ## Pending ##: 'LUDecompose' does not operate with 'complex' base type
+    //  cmp
+    //  (
+    //      "  Return the determinant of SquareMatrix",
+    //      det(A),
+    //      -95.5
+    //  );
+    //  #############
+
+    //  ## Pending ##
+    //  cmp("  Find max value in Matrix = ", max(A), Type(10.32));
+    //  cmp("  Find min value in Matrix = ", min(A), Type(-3.4));
+    //  cmp
+    //  (
+    //      "  Find min-max value in Matrix = ",
+    //      minMax(A),
+    //      MinMax<Type>(10.32, -3.4)
+    //  );
+    //  #############
+}
+
+
+// Execute each global operators of SquareMatrix<Type>, and print output
+template<class Type>
+void test_global_opers(Type)
+{
+    SquareMatrix<Type> A(3, Zero);
+    assignMatrix
+    (
+        A,
+        {
+            Type(1), Type(-2.2), Type(-3.4),
+            Type(-0.35), Type(10.32), Type(5),
+            Type(-0.35), Type(10.32), Type(-5)
+        }
+    );
+    const SquareMatrix<Type> cpA(A);
+
+    Info<< "# Operand: " << nl
+        << "  SquareMatrix = " << A << endl;
+
+
+    cmp("  Matrix negation = ", flt(-A), flt(Type(-1)*A));
+    cmp("  Matrix addition = ", flt(A + A), flt(Type(2)*A));
+    cmp("  Matrix subtraction = ", flt(A - A), flt(Type(0)*A));
+    cmp("  Scalar multiplication = ", flt(Type(2)*A), flt(A + A));
+    cmp("  Scalar multiplication = ", flt(A*Type(2)), flt(A + A));
+    cmp
+    (
+        "  Scalar addition = ",
+        flt(Type(0)*A + Type(1)),
+        flt(SquareMatrix<Type>(A.sizes(), Type(1)))
+    );
+    cmp
+    (
+        "  Scalar addition = ",
+        flt(Type(1) + Type(0)*A),
+        flt(SquareMatrix<Type>(A.sizes(), Type(1)))
+    );
+    cmp
+    (
+        "  Scalar subtraction = ",
+        flt(Type(0)*A - Type(1)),
+        flt(SquareMatrix<Type>(A.sizes(), Type(-1)))
+    );
+    cmp
+    (
+        "  Scalar subtraction = ",
+        flt(Type(1) - Type(0)*A),
+        flt(SquareMatrix<Type>(A.sizes(), Type(1)))
+    );
+    cmp
+    (
+        "  Scalar division = ",
+        flt((Type(1) + Type(0)*A)/Type(2.5)),
+        flt(SquareMatrix<Type>(A.sizes(), Type(0.4)))
+    );
+
+    SquareMatrix<Type> A1(3, Zero);
+    assignMatrix
+    (
+        A1,
+        {
+            Type(2.9600), Type(-59.9920), Type(2.6000),
+            Type(-5.71199), Type(158.87239), Type(27.789997),
+            Type(-2.211999), Type(55.672393), Type(77.789993)
+        }
+    );
+    cmp
+    (
+        "  Matrix-Matrix multiplication using ikj-algorithm = ",
+        flt(A*A),
+        flt(A1),
+        1e-4
+    );
+    SquareMatrix<Type> A2(3, Zero);
+    assignMatrix
+    (
+        A2,
+        {
+            Type(1.245), Type(-9.424), Type(-3.4),
+            Type(-9.424), Type(217.8448), Type(7.47999),
+            Type(-3.4), Type(7.47999), Type(61.56)
+        }
+    );
+    cmp
+    (
+        "  Implicit A.T()*B = ",
+        flt(A&A),
+        flt(A2),
+        1e-4
+    );
+    SquareMatrix<Type> A3(3, Zero);
+    assignMatrix
+    (
+        A3,
+        {
+            Type(17.4), Type(-40.054), Type(-6.054),
+            Type(-40.054), Type(131.6249), Type(81.6249),
+            Type(-6.054), Type(81.6249), Type(131.6249)
+        }
+    );
+    cmp
+    (
+        "  Implicit A*B.T() = ",
+        flt(A^A),
+        flt(A3),
+        1e-4
+    );
+
+    const List<Type> lst({Type(1), Type(2), Type(-3)});
+    const List<Type> out1(A*lst);
+    const List<Type> out2(lst*A);
+    const List<Type> rslt1({Type(6.7999), Type(5.2900), Type(35.29)});
+    const List<Type> rslt2({Type(1.35), Type(-12.52), Type(21.6)});
+    cmp
+    (
+        "  Matrix-vector multiplication (A * x), where x is a column vector = ",
+        out1,
+        rslt1,
+        1e-2
+    );
+    cmp
+    (
+        "  Vector-matrix multiplication (x * A), where x is a row vector = ",
+        out2,
+        rslt2,
+        1e-4
+    );
+}
+
+
+// Do compile-time recursion over the given types
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I == sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
+
+
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I < sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+{
+    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
+    test_constructors(std::get<I>(types));
+
+    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
+    test_member_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test member opers: "<< typeID[I] <<" ##" << nl;
+    test_member_opers(std::get<I>(types));
+
+    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
+    test_global_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test global operators: "<< typeID[I] << " ##" << nl;
+    test_global_opers(std::get<I>(types));
+
+    Info<< nl << "    ## Test friend funcs: "<< typeID[I] <<" ##" << nl;
+    test_friend_funcs(std::get<I>(types));
+
+    run_tests<I + 1, Tp...>(types, typeID);
+}
+
+
+// * * * * * * * * * * * * * * * Main Program  * * * * * * * * * * * * * * * //
+
+int main()
+{
+    Info<< setprecision(15);
+
+    const std::tuple<floatScalar, doubleScalar, complex> types
+    (
+        std::make_tuple(Zero, Zero, Zero)
+    );
+
+    const List<word> typeID
+    ({
+        "SquareMatrix<floatScalar>",
+        "SquareMatrix<doubleScalar>",
+        "SquareMatrix<complex>"
+    });
+
+    run_tests(types, typeID);
+
+    if (nFail_)
+    {
+        Info<< nl << "        #### "
+            << "Failed in " << nFail_ << " tests "
+            << "out of total " << nTest_ << " tests "
+            << "####\n" << endl;
+        return 1;
+    }
+
+    Info<< nl << "        #### Passed all " << nTest_ <<" tests ####\n" << endl;
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/matrices/SymmetricSquareMatrix/Make/files b/applications/test/matrices/SymmetricSquareMatrix/Make/files
new file mode 100644
index 0000000000..da88933c24
--- /dev/null
+++ b/applications/test/matrices/SymmetricSquareMatrix/Make/files
@@ -0,0 +1,3 @@
+Test-SymmetricSquareMatrix.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-SymmetricSquareMatrix
diff --git a/applications/test/matrices/SymmetricSquareMatrix/Make/options b/applications/test/matrices/SymmetricSquareMatrix/Make/options
new file mode 100644
index 0000000000..b23590707c
--- /dev/null
+++ b/applications/test/matrices/SymmetricSquareMatrix/Make/options
@@ -0,0 +1,2 @@
+EXE_INC = -I../../TestTools
+/* EXE_LIBS = -lfiniteVolume */
diff --git a/applications/test/matrices/SymmetricSquareMatrix/Test-SymmetricSquareMatrix.C b/applications/test/matrices/SymmetricSquareMatrix/Test-SymmetricSquareMatrix.C
new file mode 100644
index 0000000000..c3d47e59b0
--- /dev/null
+++ b/applications/test/matrices/SymmetricSquareMatrix/Test-SymmetricSquareMatrix.C
@@ -0,0 +1,207 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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/>.
+
+Application
+    Test-SymmetricSquareMatrix
+
+Description
+    Tests for \c SymmetricSquareMatrix constructors, member functions, member
+    operators, global functions, global operators, and friend functions using
+    \c floatScalar, \c doubleScalar, and \c complex base types.
+
+    Cross-checks were obtained from 'NumPy 1.15.1' if no theoretical
+    cross-check exists (like eigendecomposition relations), and
+    were hard-coded for elementwise comparisons.
+
+    For \c complex base type, the cross-checks do only involve zero imag part.
+
+Note
+    Pending tests were tagged as "## Pending ##".
+
+\*---------------------------------------------------------------------------*/
+
+#include "scalarMatrices.H"
+#include "RectangularMatrix.H"
+#include "SquareMatrix.H"
+#include "SymmetricSquareMatrix.H"
+#include "floatScalar.H"
+#include "doubleScalar.H"
+#include "complex.H"
+#include "IOmanip.H"
+#include "Random.H"
+#include "TestTools.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Create each constructor of SymmetricSquareMatrix<Type>, and print output
+template<class Type>
+void test_constructors(Type)
+{
+    {
+        Info<< "# Construct for given size (rows == cols):" << nl;
+        const SymmetricSquareMatrix<Type> A(2);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct for given size (rows == cols) "
+            << "initializing all elements to zero:" << nl;
+        const SymmetricSquareMatrix<Type> A(2, Zero);
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct for given size (rows == cols) "
+            << "initializing all elements to a value:" << nl;
+        const SymmetricSquareMatrix<Type> A(2, Type(3));
+        Info<< A << endl;
+    }
+    {
+        Info<< "# Construct for given size (rows == cols) "
+            << "initializing to the identity matrix:" << nl;
+        const SymmetricSquareMatrix<Type> A(2, I);
+        Info<< A << endl;
+    }
+
+    //  ## Pending ##
+    //  Construct from Istream
+    //  Clone
+    //  #############
+}
+
+
+// Execute each member function of SymmetricSquareMatrix<Type>, and print output
+template<class Type>
+void test_member_funcs(Type)
+{
+    //  ## Pending ##
+    //  #############
+}
+
+
+// Execute each member operators of SymmetricSquareMatrix<Type>, and print output
+template<class Type>
+void test_member_opers(Type)
+{
+    //  ## Pending ##
+    //  #############
+}
+
+
+// Execute each friend function of SymmetricSquareMatrix<Type>, and print output
+template<class Type>
+void test_friend_funcs(Type)
+{
+    //  ## Pending ##
+    //  #############
+}
+
+
+// Execute each global function of SymmetricSquareMatrix<Type>, and print output
+template<class Type>
+void test_global_funcs(Type)
+{
+    //  ## Pending ##
+    //  #############
+}
+
+
+// Execute each global operators of SymmetricSquareMatrix<Type>, and print output
+template<class Type>
+void test_global_opers(Type)
+{
+    //  ## Pending ##
+    //  #############
+}
+
+
+// Do compile-time recursion over the given types
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I == sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID){}
+
+
+template<std::size_t I = 0, typename... Tp>
+inline typename std::enable_if<I < sizeof...(Tp), void>::type
+run_tests(const std::tuple<Tp...>& types, const List<word>& typeID)
+{
+    Info<< nl << "    ## Test constructors: "<< typeID[I] <<" ##" << nl;
+    test_constructors(std::get<I>(types));
+
+    Info<< nl << "    ## Test member functions: "<< typeID[I] <<" ##" << nl;
+    test_member_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test member opers: "<< typeID[I] <<" ##" << nl;
+    test_member_opers(std::get<I>(types));
+
+    Info<< nl << "    ## Test global functions: "<< typeID[I] << " ##" << nl;
+    test_global_funcs(std::get<I>(types));
+
+    Info<< nl << "    ## Test global operators: "<< typeID[I] << " ##" << nl;
+    test_global_opers(std::get<I>(types));
+
+    Info<< nl << "    ## Test friend funcs: "<< typeID[I] <<" ##" << nl;
+    test_friend_funcs(std::get<I>(types));
+
+    run_tests<I + 1, Tp...>(types, typeID);
+}
+
+
+// * * * * * * * * * * * * * * * Main Program  * * * * * * * * * * * * * * * //
+
+int main()
+{
+    Info<< setprecision(15);
+
+    const std::tuple<floatScalar, doubleScalar, complex> types
+    (
+        std::make_tuple(Zero, Zero, Zero)
+    );
+
+    const List<word> typeID
+    ({
+        "SymmetricSquareMatrix<floatScalar>",
+        "SymmetricSquareMatrix<doubleScalar>",
+        "SymmetricSquareMatrix<complex>"
+    });
+
+    run_tests(types, typeID);
+
+
+    if (nFail_)
+    {
+        Info<< nl << "        #### "
+            << "Failed in " << nFail_ << " tests "
+            << "out of total " << nTest_ << " tests "
+            << "####\n" << endl;
+        return 1;
+    }
+
+    Info<< nl << "        #### Passed all " << nTest_ <<" tests ####\n" << endl;
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.C b/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.C
index 26d92fba2f..1d5146b4b7 100644
--- a/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.C
+++ b/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,14 +28,7 @@ License
 
 #include "DiagonalMatrix.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-template<class Type>
-inline Foam::DiagonalMatrix<Type>::DiagonalMatrix()
-:
-    List<Type>()
-{}
-
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class Type>
 Foam::DiagonalMatrix<Type>::DiagonalMatrix(const label n)
@@ -74,8 +67,10 @@ Foam::DiagonalMatrix<Type>::DiagonalMatrix(const Matrix<Form, Type>& mat)
 }
 
 
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
 template<class Type>
-Foam::DiagonalMatrix<Type>& Foam::DiagonalMatrix<Type>::invert()
+void Foam::DiagonalMatrix<Type>::invert()
 {
     for (Type& val : *this)
     {
@@ -88,13 +83,75 @@ Foam::DiagonalMatrix<Type>& Foam::DiagonalMatrix<Type>::invert()
             val = Type(1)/val;
         }
     }
-
-    return this;
 }
 
 
 template<class Type>
-Foam::DiagonalMatrix<Type> Foam::inv(const DiagonalMatrix<Type>& mat)
+template<class CompOp>
+Foam::List<Foam::label> Foam::DiagonalMatrix<Type>::sortPermutation
+(
+    CompOp& compare
+) const
+{
+    List<label> p(this->size());
+    std::iota(p.begin(), p.end(), 0);
+    std::sort
+    (
+        p.begin(),
+        p.end(),
+        [&](label i, label j){ return compare((*this)[i], (*this)[j]); }
+    );
+
+    return p;
+}
+
+
+template<class Type>
+void Foam::DiagonalMatrix<Type>::applyPermutation(const List<label>& p)
+{
+    #ifdef FULLDEBUG
+    if (this->size() != p.size())
+    {
+        FatalErrorInFunction
+            << "Attempt to column-reorder according to an uneven list: " << nl
+            << "DiagonalMatrix diagonal size = " << this->size() << nl
+            << "Permutation list size = " << p.size() << nl
+            << abort(FatalError);
+    }
+    #endif
+
+    List<bool> pass(p.size(), false);
+
+    for (label i = 0; i < p.size(); ++i)
+    {
+        if (pass[i])
+        {
+            continue;
+        }
+        pass[i] = true;
+        label prev = i;
+        label j = p[i];
+        while (i != j)
+        {
+            Swap((*this)[prev], (*this)[j]);
+            pass[j] = true;
+            prev = j;
+            j = p[j];
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+//- Return the matrix inverse as a DiagonalMatrix if no elem is equal to zero
+template<class Type>
+DiagonalMatrix<Type> inv(const DiagonalMatrix<Type>& mat)
 {
     DiagonalMatrix<Type> Ainv(mat.size());
 
@@ -118,4 +175,41 @@ Foam::DiagonalMatrix<Type> Foam::inv(const DiagonalMatrix<Type>& mat)
 }
 
 
+//- Return Matrix column-reordered according to
+//- a given permutation labelList
+template<class Type>
+DiagonalMatrix<Type> applyPermutation
+(
+    const DiagonalMatrix<Type>& mat,
+    const List<label>& p
+)
+{
+    #ifdef FULLDEBUG
+    if (mat.size() != p.size())
+    {
+        FatalErrorInFunction
+            << "Attempt to column-reorder according to an uneven list: " << nl
+            << "DiagonalMatrix diagonal size = " << mat.size() << nl
+            << "Permutation list size = " << p.size() << nl
+            << abort(FatalError);
+    }
+    #endif
+
+    DiagonalMatrix<Type> reordered(mat.size());
+
+    label j = 0;
+    for (const label i : p)
+    {
+        reordered[j] = mat[i];
+        ++j;
+    }
+
+    return reordered;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.H b/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.H
index b8e29d8270..e08800bd77 100644
--- a/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.H
+++ b/src/OpenFOAM/matrices/DiagonalMatrix/DiagonalMatrix.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,7 +28,11 @@ Class
     Foam::DiagonalMatrix
 
 Description
-    A 2D diagonal matrix of objects of type \<Type\>, size (N x N)
+    A templated (N x N) diagonal matrix of objects of \<Type\>, effectively
+    containing N elements, derived from List.
+
+See also
+    Test-DiagonalMatrix.C
 
 SourceFiles
     DiagonalMatrix.C
@@ -39,6 +43,7 @@ SourceFiles
 #define DiagonalMatrix_H
 
 #include "List.H"
+#include <numeric>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -59,19 +64,27 @@ class DiagonalMatrix
 {
 public:
 
-    // Constructors
+    // Generated Methods
 
-        //- Construct null.
-        DiagonalMatrix<Type>();
+        //- Default construct
+        DiagonalMatrix() = default;
+
+        //- Copy construct
+        DiagonalMatrix(const DiagonalMatrix&) = default;
+
+        //- Copy assignment
+        DiagonalMatrix& operator=(const DiagonalMatrix&) = default;
+
+
+    // Constructors
 
         //- Construct empty from size
         explicit DiagonalMatrix<Type>(const label n);
 
-        //- Construct from size
-        //- initializing all elements to the given value
+        //- Construct from size and initialise all elems to zero
         DiagonalMatrix<Type>(const label n, const zero);
 
-        //- Construct from size and a value
+        //- Construct from size and initialise all elems to value
         DiagonalMatrix<Type>(const label n, const Type& val);
 
         //- Construct from the diagonal of a Matrix
@@ -81,19 +94,20 @@ public:
 
     // Member Functions
 
-        //- Invert the diagonal matrix and return itself
-        DiagonalMatrix<Type>& invert();
+        //- Return the matrix inverse into itself if no elem is equal to zero
+        void invert();
 
+        //- Return a sort permutation labelList according to
+        //- a given comparison on the diagonal entries
+        template<class CompOp>
+        List<label> sortPermutation(CompOp& compare) const;
+
+        //- Column-reorder this Matrix according to
+        //- a given permutation labelList
+        void applyPermutation(const List<label>& p);
 };
 
 
-// Global functions
-
-//- Return the diagonal Matrix inverse
-template<class Type>
-DiagonalMatrix<Type> inv(const DiagonalMatrix<Type>& mat);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/matrices/EigenMatrix/EigenMatrix.C b/src/OpenFOAM/matrices/EigenMatrix/EigenMatrix.C
new file mode 100644
index 0000000000..170a9777bd
--- /dev/null
+++ b/src/OpenFOAM/matrices/EigenMatrix/EigenMatrix.C
@@ -0,0 +1,1105 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Code created 2014-2018 by Alberto Passalacqua
+    Contributed 2018-07-31 to the OpenFOAM Foundation
+    Copyright (C) 2018 OpenFOAM Foundation
+    Copyright (C) 2019-2020 Alberto Passalacqua
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 "EigenMatrix.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class cmptType>
+void Foam::EigenMatrix<cmptType>::tridiagonaliseSymmMatrix()
+{
+    for (label j = 0; j < n_; ++j)
+    {
+        EValsRe_[j] = EVecs_[n_ - 1][j];
+    }
+
+    // Householder reduction to tridiagonal form
+    for (label i = n_ - 1; i > 0; --i)
+    {
+        // Scale to avoid under/overflow.
+        cmptType scale = Zero;
+        cmptType h = Zero;
+
+        for (label k = 0; k < i; ++k)
+        {
+            scale = scale + mag(EValsRe_[k]);
+        }
+
+        if (scale == 0.0)
+        {
+            EValsIm_[i] = EValsRe_[i - 1];
+
+            for (label j = 0; j < i; ++j)
+            {
+                EValsRe_[j] = EVecs_[i - 1][j];
+                EVecs_[i][j] = Zero;
+                EVecs_[j][i] = Zero;
+            }
+        }
+        else
+        {
+            // Generate Householder vector
+            for (label k = 0; k < i; ++k)
+            {
+                EValsRe_[k] /= scale;
+                h += EValsRe_[k]*EValsRe_[k];
+            }
+
+            cmptType f = EValsRe_[i - 1];
+            cmptType g = Foam::sqrt(h);
+
+            if (f > 0)
+            {
+                g = -g;
+            }
+
+            EValsIm_[i] = scale*g;
+            h -= f*g;
+            EValsRe_[i - 1] = f - g;
+
+            for (label j = 0; j < i; ++j)
+            {
+                EValsIm_[j] = Zero;
+            }
+
+            // Apply similarity transformation to remaining columns
+            for (label j = 0; j < i; ++j)
+            {
+                f = EValsRe_[j];
+                EVecs_[j][i] = f;
+                g = EValsIm_[j] + EVecs_[j][j]*f;
+
+                for (label k = j + 1; k <= i - 1; ++k)
+                {
+                    g += EVecs_[k][j]*EValsRe_[k];
+                    EValsIm_[k] += EVecs_[k][j]*f;
+                }
+
+                EValsIm_[j] = g;
+            }
+
+            f = Zero;
+
+            for (label j = 0; j < i; ++j)
+            {
+                EValsIm_[j] /= h;
+                f += EValsIm_[j]*EValsRe_[j];
+            }
+
+            cmptType hh = f/(2.0*h);
+
+            for (label j = 0; j < i; ++j)
+            {
+                EValsIm_[j] -= hh*EValsRe_[j];
+            }
+
+            for (label j = 0; j < i; ++j)
+            {
+                f = EValsRe_[j];
+                g = EValsIm_[j];
+
+                for (label k = j; k <= i - 1; ++k)
+                {
+                    EVecs_[k][j] -=
+                            (f*EValsIm_[k] + g*EValsRe_[k]);
+                }
+
+                EValsRe_[j] = EVecs_[i - 1][j];
+                EVecs_[i][j] = Zero;
+            }
+        }
+
+        EValsRe_[i] = h;
+    }
+
+    // Accumulate transformations
+    for (label i = 0; i < n_ - 1; ++i)
+    {
+        EVecs_[n_ - 1][i] = EVecs_[i][i];
+        EVecs_[i][i] = cmptType(1);
+        cmptType h = EValsRe_[i + 1];
+
+        if (h != 0.0)
+        {
+            for (label k = 0; k <= i; ++k)
+            {
+                EValsRe_[k] = EVecs_[k][i + 1]/h;
+            }
+
+            for (label j = 0; j <= i; ++j)
+            {
+                cmptType g = Zero;
+
+                for (label k = 0; k <= i; ++k)
+                {
+                    g += EVecs_[k][i + 1]*EVecs_[k][j];
+                }
+
+                for (label k = 0; k <= i; ++k)
+                {
+                    EVecs_[k][j] -= g*EValsRe_[k];
+                }
+            }
+        }
+
+        for (label k = 0; k <= i; ++k)
+        {
+            EVecs_[k][i + 1] = Zero;
+        }
+    }
+
+    for (label j = 0; j < n_; ++j)
+    {
+        EValsRe_[j] = EVecs_[n_ - 1][j];
+        EVecs_[n_ - 1][j] = Zero;
+    }
+
+    EVecs_[n_ - 1][n_ - 1] = cmptType(1);
+    EValsIm_[0] = Zero;
+}
+
+
+template<class cmptType>
+void Foam::EigenMatrix<cmptType>::symmTridiagonalQL()
+{
+    for (label i = 1; i < n_; ++i)
+    {
+        EValsIm_[i - 1] = EValsIm_[i];
+    }
+
+    EValsIm_[n_-1] = Zero;
+
+    cmptType f = Zero;
+    cmptType tst1 = Zero;
+    cmptType eps = pow(2.0, -52.0);
+
+    for (label l = 0; l < n_; l++)
+    {
+        // Find SMALL subdiagonal element
+        tst1 = max(tst1, mag(EValsRe_[l]) + mag(EValsIm_[l]));
+        label m = l;
+
+        // Original while-loop from Java code
+        while (m < n_)
+        {
+            if (mag(EValsIm_[m]) <= eps*tst1)
+            {
+                break;
+            }
+
+            ++m;
+        }
+
+        // If m == l, EValsRe_[l] is an eigenvalue, otherwise, iterate
+        if (m > l)
+        {
+            label iter = 0;
+
+            do
+            {
+                iter += 1;
+
+                // Compute implicit shift
+                cmptType g = EValsRe_[l];
+                cmptType p = (EValsRe_[l + 1] - g)/(2.0*EValsIm_[l]);
+                cmptType r = Foam::hypot(p, cmptType(1));
+
+                if (p < 0)
+                {
+                    r = -r;
+                }
+
+                EValsRe_[l] = EValsIm_[l]/(p + r);
+                EValsRe_[l + 1] = EValsIm_[l]*(p + r);
+                cmptType dl1 = EValsRe_[l + 1];
+                cmptType h = g - EValsRe_[l];
+
+                for (label i = l + 2; i < n_; ++i)
+                {
+                    EValsRe_[i] -= h;
+                }
+
+                f += h;
+
+                // Implicit QL transformation.
+                p = EValsRe_[m];
+                cmptType c = cmptType(1);
+                cmptType c2 = c;
+                cmptType c3 = c;
+                cmptType el1 = EValsIm_[l + 1];
+                cmptType s = Zero;
+                cmptType s2 = Zero;
+
+                for (label i = m - 1; i >= l; --i)
+                {
+                    c3 = c2;
+                    c2 = c;
+                    s2 = s;
+                    g = c*EValsIm_[i];
+                    h = c*p;
+                    r = std::hypot(p, EValsIm_[i]);
+                    EValsIm_[i + 1] = s*r;
+                    s = EValsIm_[i]/r;
+                    c = p/r;
+                    p = c*EValsRe_[i] - s*g;
+                    EValsRe_[i + 1] = h + s*(c*g + s*EValsRe_[i]);
+
+                    // Accumulate transformation
+                    for (label k = 0; k < n_; ++k)
+                    {
+                        h = EVecs_[k][i + 1];
+                        EVecs_[k][i + 1] = s*EVecs_[k][i] + c*h;
+                        EVecs_[k][i] = c*EVecs_[k][i] - s*h;
+                    }
+                }
+
+                p = -s*s2*c3*el1*EValsIm_[l]/dl1;
+                EValsIm_[l] = s*p;
+                EValsRe_[l] = c*p;
+            }
+            while (mag(EValsIm_[l]) > eps*tst1); // Convergence check
+        }
+
+        EValsRe_[l] = EValsRe_[l] + f;
+        EValsIm_[l] = Zero;
+    }
+
+    // Sorting eigenvalues and corresponding vectors
+    for (label i = 0; i < n_ - 1; ++i)
+    {
+        label k = i;
+        cmptType p = EValsRe_[i];
+
+        for (label j = i + 1; j < n_; ++j)
+        {
+            if (EValsRe_[j] < p)
+            {
+                k = j;
+                p = EValsRe_[j];
+            }
+        }
+
+        if (k != i)
+        {
+            EValsRe_[k] = EValsRe_[i];
+            EValsRe_[i] = p;
+
+            for (label j = 0; j < n_; ++j)
+            {
+                p = EVecs_[j][i];
+                EVecs_[j][i] = EVecs_[j][k];
+                EVecs_[j][k] = p;
+            }
+        }
+    }
+}
+
+
+template<class cmptType>
+void Foam::EigenMatrix<cmptType>::Hessenberg()
+{
+    DiagonalMatrix<cmptType> orth_(n_);
+
+    label low = 0;
+    label high = n_ - 1;
+
+    for (label m = low + 1; m <= high - 1; ++m)
+    {
+        // Scale column
+        cmptType scale = Zero;
+
+        for (label i = m; i <= high; ++i)
+        {
+            scale = scale + mag(H_[i][m - 1]);
+        }
+
+        if (scale != 0.0)
+        {
+            // Compute Householder transformation
+            cmptType h = Zero;
+
+            for (label i = high; i >= m; --i)
+            {
+                orth_[i] = H_[i][m - 1]/scale;
+                h += orth_[i]*orth_[i];
+            }
+
+            cmptType g = Foam::sqrt(h);
+
+            if (orth_[m] > 0)
+            {
+                g = -g;
+            }
+
+            h -= orth_[m]*g;
+            orth_[m] -= g;
+
+            // Apply Householder similarity transformation
+            // H = (I - u*u'/h)*H*(I - u*u')/h)
+            for (label j = m; j < n_; ++j)
+            {
+                cmptType f = Zero;
+
+                for (label i = high; i >= m; --i)
+                {
+                    f += orth_[i]*H_[i][j];
+                }
+
+                f /= h;
+
+                for (label i = m; i <= high; ++i)
+                {
+                    H_[i][j] -= f*orth_[i];
+                }
+            }
+
+            for (label i = 0; i <= high; ++i)
+            {
+                cmptType f = Zero;
+
+                for (label j = high; j >= m; --j)
+                {
+                    f += orth_[j]*H_[i][j];
+                }
+
+                f /= h;
+
+                for (label j = m; j <= high; ++j)
+                {
+                    H_[i][j] -= f*orth_[j];
+                }
+            }
+
+            orth_[m] = scale*orth_[m];
+            H_[m][m-1] = scale*g;
+        }
+    }
+
+    // Accumulate transformations
+    for (label i = 0; i < n_; ++i)
+    {
+        for (label j = 0; j < n_; ++j)
+        {
+            EVecs_[i][j] = (i == j ? 1.0 : 0.0);
+        }
+    }
+
+    for (label m = high - 1; m >= low + 1; --m)
+    {
+        if (H_[m][m - 1] != 0.0)
+        {
+            for (label i = m + 1; i <= high; ++i)
+            {
+                orth_[i] = H_[i][m - 1];
+            }
+
+            for (label j = m; j <= high; ++j)
+            {
+                cmptType g = Zero;
+
+                for (label i = m; i <= high; ++i)
+                {
+                    g += orth_[i]*EVecs_[i][j];
+                }
+
+                // Double division avoids possible underflow
+                g = (g/orth_[m])/H_[m][m - 1];
+
+                for (label i = m; i <= high; ++i)
+                {
+                    EVecs_[i][j] += g*orth_[i];
+                }
+            }
+        }
+    }
+}
+
+
+template<class cmptType>
+void Foam::EigenMatrix<cmptType>::realSchur()
+{
+    // Initialize
+    label nn = n_;
+    label n = nn - 1;
+    label low = 0;
+    label high = nn - 1;
+    cmptType eps = pow(2.0, -52.0);
+    cmptType exshift = Zero;
+    cmptType p = 0, q = 0, r = 0, s = 0, z = 0, t, w, x, y;
+
+    // Store roots isolated by balance and compute matrix norm
+    cmptType norm = Zero;
+
+    for (label i = 0; i < nn; ++i)
+    {
+        if ((i < low) || (i > high))
+        {
+            EValsRe_[i] = H_[i][i];
+            EValsIm_[i] = Zero;
+        }
+
+        for (label j = max(i - 1, 0); j < nn; ++j)
+        {
+            norm += mag(H_[i][j]);
+        }
+    }
+
+    label iter = 0;
+
+    while (n >= low)
+    {
+        // Look for single SMALL sub-diagonal element
+        label l = n;
+
+        while (l > low)
+        {
+            s = mag(H_[l - 1][l - 1]) + mag(H_[l][l]);
+
+            if (s == 0.0)
+            {
+                s = norm;
+            }
+
+            if (mag(H_[l][l - 1]) < eps*s)
+            {
+                break;
+            }
+
+            l--;
+        }
+
+        // Check for convergence
+        if (l == n)         // One root found
+        {
+            H_[n][n] = H_[n][n] + exshift;
+            EValsRe_[n] = H_[n][n];
+            EValsIm_[n] = Zero;
+            --n;
+            iter = 0;
+        }
+        else if (l == n - 1)  // Two roots found
+        {
+            w = H_[n][n - 1]*H_[n - 1][n];
+            p = (H_[n - 1][n - 1] - H_[n][n])/2.0;
+            q = p*p + w;
+            z = Foam::sqrt(mag(q));
+            H_[n][n] += exshift;
+            H_[n - 1][n - 1] += exshift;
+            x = H_[n][n];
+
+            // Scalar pair
+            if (q >= 0)
+            {
+                if (p >= 0)
+                {
+                    z = p + z;
+                }
+                else
+                {
+                    z = p - z;
+                }
+
+                EValsRe_[n - 1] = x + z;
+                EValsRe_[n] = EValsRe_[n - 1];
+
+                if (z != 0.0)
+                {
+                    EValsRe_[n] = x - w/z;
+                }
+
+                EValsIm_[n - 1] = Zero;
+                EValsIm_[n] = Zero;
+                x = H_[n][n - 1];
+                s = mag(x) + mag(z);
+                p = x/s;
+                q = z/s;
+                r = Foam::sqrt(p*p + q*q);
+                p /= r;
+                q /= r;
+
+                // Row modification
+                for (label j = n - 1; j < nn; ++j)
+                {
+                    z = H_[n - 1][j];
+                    H_[n - 1][j] = q*z + p*H_[n][j];
+                    H_[n][j] = q*H_[n][j] - p*z;
+                }
+
+                // Column modification
+                for (label i = 0; i <= n; ++i)
+                {
+                    z = H_[i][n - 1];
+                    H_[i][n - 1] = q*z + p*H_[i][n];
+                    H_[i][n] = q*H_[i][n] - p*z;
+                }
+
+                // Accumulate transformations
+                for (label i = low; i <= high; ++i)
+                {
+                    z = EVecs_[i][n - 1];
+                    EVecs_[i][n - 1] = q*z + p*EVecs_[i][n];
+                    EVecs_[i][n] = q*EVecs_[i][n] - p*z;
+                }
+            }
+            else         // Complex pair of roots
+            {
+                EValsRe_[n - 1] = x + p;
+                EValsRe_[n] = x + p;
+                EValsIm_[n - 1] = z;
+                EValsIm_[n] = -z;
+            }
+
+            n -= 2;
+            iter = 0;
+        }
+        else            // No convergence yet
+        {
+            // Form shift
+            x = H_[n][n];
+            y = Zero;
+            w = Zero;
+
+            if (l < n)
+            {
+                y = H_[n - 1][n - 1];
+                w = H_[n][n - 1]*H_[n - 1][n];
+            }
+
+            // Wilkinson's original ad-hoc shift
+            if (iter == 10)
+            {
+                exshift += x;
+                for (label i = low; i <= n; ++i)
+                {
+                    H_[i][i] -= x;
+                }
+
+                s = mag(H_[n][n - 1]) + mag(H_[n - 1][n - 2]);
+                x = 0.75*s;
+                y = 0.75*s;
+                w = -0.4375*s*s;
+            }
+
+            // New ad hoc shift
+            if (iter == 30)
+            {
+                s = (y - x)/2.0;
+                s = s*s + w;
+
+                if (s > 0)
+                {
+                    s = Foam::sqrt(s);
+
+                    if (y < x)
+                    {
+                        s = -s;
+                    }
+
+                    s = x - w/((y - x)/2.0 + s);
+
+                    for (label i = low; i <= n; ++i)
+                    {
+                        H_[i][i] -= s;
+                    }
+
+                    exshift += s;
+                    x = 0.964;
+                    y = 0.964;
+                    w = 0.964;
+                }
+            }
+
+            iter += 1;
+
+            // Look for two consecutive SMALL sub-diagonal elements
+            label m = n - 2;
+
+            while (m >= l)
+            {
+                z = H_[m][m];
+                r = x - z;
+                s = y - z;
+                p = (r*s - w)/H_[m + 1][m] + H_[m][m + 1];
+                q = H_[m + 1][m + 1] - z - r - s;
+                r = H_[m + 2][m + 1];
+                s = mag(p) + mag(q) + mag(r);
+                p /= s;
+                q /= s;
+                r /= s;
+
+                if (m == l)
+                {
+                    break;
+                }
+
+                if
+                (
+                    mag(H_[m][m - 1])*(mag(q) + mag(r))
+                            < eps*(mag(p)*(mag(H_[m - 1][m - 1])
+                                    + mag(z) + mag(H_[m + 1][m + 1])))
+                )
+                {
+                    break;
+                }
+
+                --m;
+            }
+
+            for (label i = m + 2; i <= n; ++i)
+            {
+                H_[i][i - 2] = Zero;
+
+                if (i > m + 2)
+                {
+                    H_[i][i - 3] = Zero;
+                }
+            }
+
+            // Double QR step involving rows l:n and columns m:n
+            for (label k = m; k <= n - 1; ++k)
+            {
+                label notlast = (k != n - 1);
+
+                if (k != m)
+                {
+                    p = H_[k][k - 1];
+                    q = H_[k + 1][k - 1];
+                    r = (notlast ? H_[k + 2][k - 1] : 0.0);
+                    x = mag(p) + mag(q) + mag(r);
+
+                    if (x != 0.0)
+                    {
+                        p /= x;
+                        q /= x;
+                        r /= x;
+                    }
+                }
+
+                if (x == 0.0)
+                {
+                    break;
+                }
+
+                s = Foam::sqrt(p*p + q*q + r*r);
+
+                if (p < 0)
+                {
+                    s = -s;
+                }
+
+                if (s != 0)
+                {
+                    if (k != m)
+                    {
+                        H_[k][k - 1] = -s*x;
+                    }
+                    else if (l != m)
+                    {
+                        H_[k][k - 1] = -H_[k][k - 1];
+                    }
+
+                    p = p + s;
+                    x = p/s;
+                    y = q/s;
+                    z = r/s;
+                    q /= p;
+                    r /= p;
+
+                    // Row modification
+                    for (label j = k; j < nn; ++j)
+                    {
+                        p = H_[k][j] + q*H_[k + 1][j];
+
+                        if (notlast)
+                        {
+                            p += r*H_[k + 2][j];
+                            H_[k + 2][j] -= p*z;
+                        }
+
+                        H_[k][j] -= p*x;
+                        H_[k + 1][j] -= p*y;
+                    }
+
+                    // Column modification
+                    for (label i = 0; i <= min(n, k + 3); ++i)
+                    {
+                        p = x*H_[i][k] + y*H_[i][k + 1];
+
+                        if (notlast)
+                        {
+                            p += z*H_[i][k + 2];
+                            H_[i][k + 2] -= p*r;
+                        }
+
+                        H_[i][k] -= p;
+                        H_[i][k + 1] -= p*q;
+                    }
+
+                    // Accumulate transformations
+                    for (label i = low; i <= high; ++i)
+                    {
+                        p = x*EVecs_[i][k] + y*EVecs_[i][k + 1];
+
+                        if (notlast)
+                        {
+                            p += z*EVecs_[i][k + 2];
+                            EVecs_[i][k + 2] -= p*r;
+                        }
+
+                        EVecs_[i][k] -= p;
+                        EVecs_[i][k + 1] -= p*q;
+                    }
+                }
+            }
+        }
+    }
+
+    // Backsubstitute to find vectors of upper triangular form
+    if (norm == 0.0)
+    {
+        return;
+    }
+
+    for (n = nn-1; n >= 0; --n)
+    {
+        p = EValsRe_[n];
+        q = EValsIm_[n];
+
+        // scalar vector
+        if (q == 0)
+        {
+            label l = n;
+            H_[n][n] = cmptType(1);
+
+            for (label i = n-1; i >= 0; --i)
+            {
+                w = H_[i][i] - p;
+                r = Zero;
+
+                for (label j = l; j <= n; ++j)
+                {
+                    r += H_[i][j]*H_[j][n];
+                }
+
+                if (EValsIm_[i] < 0.0)
+                {
+                    z = w;
+                    s = r;
+                }
+                else
+                {
+                    l = i;
+
+                    if (EValsIm_[i] == 0.0)
+                    {
+                        if (w != 0.0)
+                        {
+                            H_[i][n] = -r/w;
+                        }
+                        else
+                        {
+                            H_[i][n] = -r/(eps*norm);
+                        }
+                    }
+                    else // Solve real equations
+                    {
+                        x = H_[i][i + 1];
+                        y = H_[i + 1][i];
+                        q = (EValsRe_[i] - p)*(EValsRe_[i] - p)
+                                + EValsIm_[i]*EValsIm_[i];
+
+                        t = (x*s - z*r)/q;
+                        H_[i][n] = t;
+
+                        if (mag(x) > mag(z))
+                        {
+                            H_[i + 1][n] = (-r - w*t)/x;
+                        }
+                        else
+                        {
+                            H_[i + 1][n] = (-s - y*t)/z;
+                        }
+                    }
+
+                    // Overflow control
+                    t = mag(H_[i][n]);
+
+                    if ((eps*t)*t > 1)
+                    {
+                        for (label j = i; j <= n; ++j)
+                        {
+                            H_[j][n] /= t;
+                        }
+                    }
+                }
+            }
+        }
+        else if (q < 0) // Complex vector
+        {
+            label l = n - 1;
+
+            // Last vector component imaginary so matrix is triangular
+            if (mag(H_[n][n - 1]) > mag(H_[n - 1][n]))
+            {
+                H_[n - 1][n - 1] = q/H_[n][n - 1];
+                H_[n - 1][n] = -(H_[n][n] - p)/H_[n][n - 1];
+            }
+            else
+            {
+                complex cDiv = complex(0.0, -H_[n - 1][n])
+                        /complex(H_[n - 1][n-1]-p, q);
+
+                H_[n - 1][n - 1] = cDiv.Re();
+                H_[n - 1][n] = cDiv.Im();
+            }
+
+            H_[n][n - 1] = Zero;
+            H_[n][n] = cmptType(1);
+
+            for (label i = n - 2; i >= 0; --i)
+            {
+                cmptType ra, sa, vr, vi;
+                ra = Zero;
+                sa = Zero;
+
+                for (label j = l; j <= n; ++j)
+                {
+                    ra += H_[i][j]*H_[j][n-1];
+                    sa += H_[i][j]*H_[j][n];
+                }
+
+                w = H_[i][i] - p;
+
+                if (EValsIm_[i] < 0.0)
+                {
+                    z = w;
+                    r = ra;
+                    s = sa;
+                }
+                else
+                {
+                    l = i;
+
+                    if (EValsIm_[i] == 0)
+                    {
+                        complex cDiv = complex(-ra, -sa)/complex(w, q);
+                        H_[i][n - 1] = cDiv.Re();
+                        H_[i][n] = cDiv.Im();
+                    }
+                    else
+                    {
+                        // Solve complex equations
+                        x = H_[i][i + 1];
+                        y = H_[i + 1][i];
+                        vr = (EValsRe_[i] - p)*(EValsRe_[i] - p)
+                                + EValsIm_[i]*EValsIm_[i] - q*q;
+
+                        vi = 2.0*(EValsRe_[i] - p)*q;
+
+                        if ((vr == 0.0) && (vi == 0.0))
+                        {
+                            vr = eps*norm*(mag(w) + mag(q) + mag(x) + mag(y)
+                                    + mag(z));
+                        }
+
+                        complex cDiv =
+                                complex(x*r - z*ra + q*sa, x*s - z*sa - q*ra)
+                                    /complex(vr, vi);
+
+                        H_[i][n - 1] = cDiv.Re();
+                        H_[i][n] = cDiv.Im();
+
+                        if (mag(x) > (mag(z) + mag(q)))
+                        {
+                            H_[i + 1][n - 1] = (-ra - w*H_[i][n - 1]
+                                    + q*H_[i][n])/x;
+
+                            H_[i + 1][n] = (-sa - w*H_[i][n]
+                                    - q*H_[i][n - 1])/x;
+                        }
+                        else
+                        {
+                            complex cDiv = complex(-r - y*H_[i][n - 1], -s
+                                    - y*H_[i][n])/complex(z, q);
+
+                            H_[i + 1][n - 1] = cDiv.Re();
+                            H_[i + 1][n] = cDiv.Im();
+                        }
+                    }
+
+                    // Overflow control
+                    t = max(mag(H_[i][n - 1]), mag(H_[i][n]));
+
+                    if ((eps*t)*t > 1)
+                    {
+                        for (label j = i; j <= n; ++j)
+                        {
+                            H_[j][n - 1] /= t;
+                            H_[j][n] /= t;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Vectors of isolated roots
+    for (label i = 0; i < nn; ++i)
+    {
+        if (i < low || i > high)
+        {
+            for (label j = i; j < nn; ++j)
+            {
+                EVecs_[i][j] = H_[i][j];
+            }
+        }
+    }
+
+    // Back transformation to get eigenvectors of original matrix
+    for (label j = nn - 1; j >= low; --j)
+    {
+        for (label i = low; i <= high; ++i)
+        {
+            z = Zero;
+
+            for (label k = low; k <= min(j, high); ++k)
+            {
+                z = z + EVecs_[i][k]*H_[k][j];
+            }
+
+            EVecs_[i][j] = z;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class cmptType>
+Foam::EigenMatrix<cmptType>::EigenMatrix(const SquareMatrix<cmptType>& A)
+:
+    n_(A.n()),
+    EValsRe_(n_, Zero),
+    EValsIm_(n_, Zero),
+    EVecs_(n_, Zero),
+    H_()
+{
+    if (n_ <= 0)
+    {
+        FatalErrorInFunction
+            << "Input matrix has zero size."
+            << abort(FatalError);
+    }
+
+    if (A.symmetric())
+    {
+        EVecs_ = A;
+        tridiagonaliseSymmMatrix();
+        symmTridiagonalQL();
+    }
+    else
+    {
+        H_ = A;
+        Hessenberg();
+        realSchur();
+    }
+}
+
+
+template<class cmptType>
+Foam::EigenMatrix<cmptType>::EigenMatrix
+(
+    const SquareMatrix<cmptType>& A,
+    bool symmetric
+)
+:
+    n_(A.n()),
+    EValsRe_(n_, Zero),
+    EValsIm_(n_, Zero),
+    EVecs_(n_, Zero),
+    H_()
+{
+    if (n_ <= 0)
+    {
+        FatalErrorInFunction
+            << "Input matrix has zero size."
+            << abort(FatalError);
+    }
+
+    if (symmetric)
+    {
+        EVecs_ = A;
+        tridiagonaliseSymmMatrix();
+        symmTridiagonalQL();
+    }
+    else
+    {
+        H_ = A;
+        Hessenberg();
+        realSchur();
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class cmptType>
+const Foam::SquareMatrix<Foam::complex>
+Foam::EigenMatrix<cmptType>::complexEVecs() const
+{
+    SquareMatrix<complex> EVecs(EVecs_.n());
+
+    std::transform
+    (
+        EVecs_.cbegin(),
+        EVecs_.cend(),
+        EVecs.begin(),
+        [&](const cmptType& x){ return complex(x); }
+    );
+
+    for (label i = 0; i < EValsIm_.size(); ++i)
+    {
+        if (mag(EValsIm_[i]) > VSMALL)
+        {
+            for (label j = 0; j < EVecs.m(); ++j)
+            {
+                EVecs(j, i) = complex(EVecs_(j, i), EVecs_(j, i+1));
+                EVecs(j, i+1) = EVecs(j, i).conjugate();
+            }
+            ++i;
+        }
+    }
+
+    return EVecs;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/EigenMatrix/EigenMatrix.H b/src/OpenFOAM/matrices/EigenMatrix/EigenMatrix.H
new file mode 100644
index 0000000000..9a40843d4e
--- /dev/null
+++ b/src/OpenFOAM/matrices/EigenMatrix/EigenMatrix.H
@@ -0,0 +1,267 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Code created 2014-2018 by Alberto Passalacqua
+    Contributed 2018-07-31 to the OpenFOAM Foundation
+    Copyright (C) 2018 OpenFOAM Foundation
+    Copyright (C) 2019-2020 Alberto Passalacqua
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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::EigenMatrix
+
+Description
+    EigenMatrix (i.e. eigendecomposition or spectral decomposition) decomposes
+    a diagonalisable nonsymmetric real square matrix into its canonical form,
+    whereby the matrix is represented in terms of its eigenvalues and
+    eigenvectors.
+    
+    The eigenvalue equation (i.e. eigenvalue problem) is:
+
+    \f[
+        A v = \lambda v
+    \f]
+
+    where
+    \vartable
+      A       | a diagonalisable square matrix of dimension m-by-m
+      v       | a (non-zero) vector of dimension m (right eigenvector)
+      \lambda | a scalar corresponding to v (eigenvalue)
+    \endvartable
+
+
+    If \c A is symmetric, the following relation is satisfied:
+
+    \f[
+        A = v*D*v^T
+    \f]
+
+    where
+    \vartable
+      D | diagonal real eigenvalue matrix
+      v | orthogonal eigenvector matrix
+    \endvartable
+
+    If \c A is not symmetric, \c D becomes a block diagonal matrix wherein
+    the real eigenvalues are present on the diagonal within 1-by-1 blocks, and
+    complex eigenvalues within 2-by-2 blocks, i.e. \f$\lambda + i \mu\f$ with
+    \f$[\lambda, \mu; -\mu, \lambda]\f$.
+
+    The columns of \c v represent eigenvectors corresponding to eigenvalues,
+    satisfying the eigenvalue equation. Even though eigenvalues of a matrix
+    are unique, eigenvectors of the matrix are not. For the same eigenvalue,
+    the corresponding eigenvector can be real or complex with non-unique
+    entries. In addition, the validity of the equation \f$A = v*D*v^T\f$
+    depends on the condition number of \c v, which can be ill-conditioned,
+    or singular for invalidated equations.
+
+    References:
+    \verbatim
+        OpenFOAM-compatible implementation:
+            Passalacqua, A., Heylmun, J., Icardi, M.,
+            Madadi, E., Bachant, P., & Hu, X. (2019).
+            OpenQBMM 5.0.1 for OpenFOAM 7, Zenodo.
+            DOI:10.5281/zenodo.3471804
+
+        Implementations for the functions:
+        'tridiagonaliseSymmMatrix', 'symmTridiagonalQL',
+        'Hessenberg' and 'realSchur' (based on ALGOL-procedure:tred2):
+            Wilkinson, J. H., & Reinsch, C. (1971).
+            In Bauer, F. L. & Householder A. S. (Eds.),
+            Handbook for Automatic Computation: Volume II: Linear Algebra.
+            (Vol. 186), Springer-Verlag Berlin Heidelberg.
+            DOI: 10.1007/978-3-642-86940-2
+
+        Explanations on how real eigenvectors
+        can be unpacked into complex domain:
+            Moler, C. (1998).
+            Re: Eigenvectors.
+            Retrieved from https://bit.ly/3ao4Wat
+
+        TNT/JAMA implementation:
+            Pozo, R. (1997).
+            Template Numerical Toolkit for linear algebra:
+            High performance programming with C++
+            and the Standard Template Library.
+            The International Journal of Supercomputer Applications
+            and High Performance Computing, 11(3), 251-263.
+            DOI:10.1177/109434209701100307
+
+            (No particular order) Hicklin, J., Moler, C., Webb, P.,
+            Boisvert, R. F., Miller, B., Pozo, R., & Remington, K. (2012).
+            JAMA: A Java Matrix Package 1.0.3.
+            Retrived from https://math.nist.gov/javanumerics/jama/
+    \endverbatim
+
+Note
+    - This implementation is an integration of the \c OpenQBMM \c eigenSolver
+    class (2019) without any changes to its internal mechanisms. Therefore, no
+    differences between EigenMatrix and \c eigenSolver (2019) classes should be
+    expected in terms of input-process-output operations.
+    - The \c OpenQBMM \c eigenSolver class derives almost completely from the
+    \c TNT/JAMA implementation, a public-domain library developed by \c NIST
+    and \c MathWorks from 1998 to 2012, available at
+    http://math.nist.gov/tnt/index.html (Retrieved June 6, 2020). Their
+    implementation was based upon \c EISPACK.
+    - The \c tridiagonaliseSymmMatrix, \c symmTridiagonalQL, \c Hessenberg and
+    \c realSchur methods are based on the \c Algol procedures \c tred2 by
+    Bowdler, Martin, Reinsch, and Wilkinson, Handbook for Auto. Comp.,
+    Vol. II-Linear Algebra, and the corresponding \c FORTRAN subroutine
+    in \c EISPACK.
+
+See also
+    Test-EigenMatrix.C
+
+SourceFiles
+    EigenMatrix.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef EigenMatrix_H
+#define EigenMatrix_H
+
+#include "scalarMatrices.H"
+#include "DiagonalMatrix.H"
+#include "SquareMatrix.H"
+#include "complex.H"
+#include <algorithm>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class EigenMatrix Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class cmptType>
+class EigenMatrix
+{
+    static_assert
+    (
+        std::is_floating_point<cmptType>::value,
+        "EigenMatrix operates only with scalar base type."
+    );
+
+    // Private Data
+
+        //- Number of rows and columns in input matrix
+        const label n_;
+
+        //- Real eigenvalues or real part of complex eigenvalues
+        DiagonalMatrix<cmptType> EValsRe_;
+
+        //- Zero-matrix for real eigenvalues
+        //- or imaginary part of complex eigenvalues
+        DiagonalMatrix<cmptType> EValsIm_;
+
+        //- Right eigenvectors matrix where each column is
+        //- a right eigenvector that corresponds to an eigenvalue
+        SquareMatrix<cmptType> EVecs_;
+
+        //- Copy of nonsymmetric input matrix evolving to eigenvectors matrix
+        SquareMatrix<cmptType> H_;
+
+
+    // Private Member Functions
+
+        //- Householder transform of a symmetric matrix to tri-diagonal form
+        void tridiagonaliseSymmMatrix();
+
+        //- Symmetric tri-diagonal QL algorithm
+        void symmTridiagonalQL();
+
+        //- Reduce non-symmetric matrix to upper-Hessenberg form
+        void Hessenberg();
+
+        //- Reduce matrix from Hessenberg to real Schur form
+        void realSchur();
+
+
+public:
+
+    // Generated Methods
+
+        //- No default construct
+        EigenMatrix() = delete;
+
+        //- No copy construct
+        EigenMatrix(const EigenMatrix&) = delete;
+
+        //- No copy assignment
+        EigenMatrix& operator=(const EigenMatrix&) = delete;
+
+
+    // Constructors
+
+        //- Construct from a SquareMatrix<cmptType>
+        explicit EigenMatrix(const SquareMatrix<cmptType>& A);
+
+        //- Construct from a SquareMatrix<cmptType> and symmetry flag
+        //  Does not perform symmetric check
+        EigenMatrix(const SquareMatrix<cmptType>& A, bool symmetric);
+
+
+    // Access
+
+        //- Return real eigenvalues or real part of complex eigenvalues
+        const DiagonalMatrix<cmptType>& EValsRe() const
+        {
+            return EValsRe_;
+        }
+
+        //- Return zero-matrix for real eigenvalues
+        //- or imaginary part of complex eigenvalues
+        const DiagonalMatrix<cmptType>& EValsIm() const
+        {
+            return EValsIm_;
+        }
+
+        //- Return right eigenvectors matrix where each column is
+        //- a right eigenvector that corresponds to an eigenvalue
+        const SquareMatrix<cmptType>& EVecs() const
+        {
+            return EVecs_;
+        }
+
+        //- Return right eigenvectors in unpacked form
+        const SquareMatrix<complex> complexEVecs() const;
+
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "EigenMatrix.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/Matrix/Matrix.C b/src/OpenFOAM/matrices/Matrix/Matrix.C
index b5ea2e4519..03beb2c502 100644
--- a/src/OpenFOAM/matrices/Matrix/Matrix.C
+++ b/src/OpenFOAM/matrices/Matrix/Matrix.C
@@ -644,10 +644,16 @@ void Foam::Matrix<Form, Type>::operator/=(const Type& s)
 }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
 // * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * * //
 
+//- Find max value in Matrix
 template<class Form, class Type>
-const Type& Foam::max(const Matrix<Form, Type>& mat)
+const Type& max(const Matrix<Form, Type>& mat)
 {
     if (mat.empty())
     {
@@ -659,8 +665,9 @@ const Type& Foam::max(const Matrix<Form, Type>& mat)
 }
 
 
+//- Find min value in Matrix
 template<class Form, class Type>
-const Type& Foam::min(const Matrix<Form, Type>& mat)
+const Type& min(const Matrix<Form, Type>& mat)
 {
     if (mat.empty())
     {
@@ -672,8 +679,9 @@ const Type& Foam::min(const Matrix<Form, Type>& mat)
 }
 
 
+//- Find the min/max values of Matrix
 template<class Form, class Type>
-Foam::MinMax<Type> Foam::minMax(const Matrix<Form, Type>& mat)
+MinMax<Type> minMax(const Matrix<Form, Type>& mat)
 {
     MinMax<Type> result;
 
@@ -686,10 +694,12 @@ Foam::MinMax<Type> Foam::minMax(const Matrix<Form, Type>& mat)
 }
 
 
+
 // * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
 
+//- Matrix negation
 template<class Form, class Type>
-Form Foam::operator-(const Matrix<Form, Type>& mat)
+Form operator-(const Matrix<Form, Type>& mat)
 {
     Form result(mat.sizes());
 
@@ -705,8 +715,9 @@ Form Foam::operator-(const Matrix<Form, Type>& mat)
 }
 
 
+//- Matrix addition. Returns Matrix of the same form as the first parameter.
 template<class Form1, class Form2, class Type>
-Form1 Foam::operator+
+Form1 operator+
 (
     const Matrix<Form1, Type>& A,
     const Matrix<Form2, Type>& B
@@ -738,8 +749,9 @@ Form1 Foam::operator+
 }
 
 
+//- Matrix subtraction. Returns Matrix of the same form as the first parameter.
 template<class Form1, class Form2, class Type>
-Form1 Foam::operator-
+Form1 operator-
 (
     const Matrix<Form1, Type>& A,
     const Matrix<Form2, Type>& B
@@ -771,8 +783,9 @@ Form1 Foam::operator-
 }
 
 
+//- Scalar multiplication of Matrix
 template<class Form, class Type>
-Form Foam::operator*(const Type& s, const Matrix<Form, Type>& mat)
+Form operator*(const Type& s, const Matrix<Form, Type>& mat)
 {
     Form result(mat.sizes());
 
@@ -788,8 +801,17 @@ Form Foam::operator*(const Type& s, const Matrix<Form, Type>& mat)
 }
 
 
+//- Scalar multiplication of Matrix
 template<class Form, class Type>
-Form Foam::operator+(const Type& s, const Matrix<Form, Type>& mat)
+Form operator*(const Matrix<Form, Type>& mat, const Type& s)
+{
+    return s*mat;
+}
+
+
+//- Scalar addition of Matrix
+template<class Form, class Type>
+Form operator+(const Type& s, const Matrix<Form, Type>& mat)
 {
     Form result(mat.sizes());
 
@@ -805,8 +827,17 @@ Form Foam::operator+(const Type& s, const Matrix<Form, Type>& mat)
 }
 
 
+//- Scalar addition of Matrix
 template<class Form, class Type>
-Form Foam::operator-(const Type& s, const Matrix<Form, Type>& mat)
+Form operator+(const Matrix<Form, Type>& mat, const Type& s)
+{
+    return s + mat;
+}
+
+
+//- Scalar subtraction of Matrix
+template<class Form, class Type>
+Form operator-(const Type& s, const Matrix<Form, Type>& mat)
 {
     Form result(mat.sizes());
 
@@ -822,22 +853,9 @@ Form Foam::operator-(const Type& s, const Matrix<Form, Type>& mat)
 }
 
 
+//- Scalar subtraction of Matrix
 template<class Form, class Type>
-Form Foam::operator*(const Matrix<Form, Type>& mat, const Type& s)
-{
-    return s*mat;
-}
-
-
-template<class Form, class Type>
-Form Foam::operator+(const Matrix<Form, Type>& mat, const Type& s)
-{
-    return s + mat;
-}
-
-
-template<class Form, class Type>
-Form Foam::operator-(const Matrix<Form, Type>& mat, const Type& s)
+Form operator-(const Matrix<Form, Type>& mat, const Type& s)
 {
     Form result(mat.sizes());
 
@@ -853,8 +871,9 @@ Form Foam::operator-(const Matrix<Form, Type>& mat, const Type& s)
 }
 
 
+//- Scalar division of Matrix
 template<class Form, class Type>
-Form Foam::operator/(const Matrix<Form, Type>& mat, const Type& s)
+Form operator/(const Matrix<Form, Type>& mat, const Type& s)
 {
     Form result(mat.sizes());
 
@@ -870,9 +889,10 @@ Form Foam::operator/(const Matrix<Form, Type>& mat, const Type& s)
 }
 
 
+//- Matrix-Matrix multiplication using ikj-algorithm
 template<class Form1, class Form2, class Type>
-typename Foam::typeOfInnerProduct<Type, Form1, Form2>::type
-Foam::operator*
+typename typeOfInnerProduct<Type, Form1, Form2>::type
+operator*
 (
     const Matrix<Form1, Type>& A,
     const Matrix<Form2, Type>& B
@@ -912,9 +932,10 @@ Foam::operator*
 }
 
 
+//- Implicit inner product of Matrix-Matrix, equivalent to A.T()*B
 template<class Form1, class Form2, class Type>
-typename Foam::typeOfInnerProduct<Type, Form1, Form2>::type
-Foam::operator&
+typename typeOfInnerProduct<Type, Form1, Form2>::type
+operator&
 (
     const Matrix<Form1, Type>& AT,
     const Matrix<Form2, Type>& B
@@ -954,9 +975,10 @@ Foam::operator&
 }
 
 
+//- Implicit outer product of Matrix-Matrix, equivalent to A*B.T()
 template<class Form1, class Form2, class Type>
-typename Foam::typeOfInnerProduct<Type, Form1, Form2>::type
-Foam::operator^
+typename typeOfInnerProduct<Type, Form1, Form2>::type
+operator^
 (
     const Matrix<Form1, Type>& A,
     const Matrix<Form2, Type>& BT
@@ -996,7 +1018,11 @@ Foam::operator^
 }
 
 
-// * * * * * * * * * * * * * * * *  IOStream operators * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * IOStream operators  * * * * * * * * * * * * * //
 
 #include "MatrixIO.C"
 
diff --git a/src/OpenFOAM/matrices/Matrix/Matrix.H b/src/OpenFOAM/matrices/Matrix/Matrix.H
index bb66c5e5b7..673258a7c7 100644
--- a/src/OpenFOAM/matrices/Matrix/Matrix.H
+++ b/src/OpenFOAM/matrices/Matrix/Matrix.H
@@ -220,7 +220,6 @@ public:
         //  Subscript checking only with FULLDEBUG
         inline Type& at(const label idx);
 
-
     // Block Access (const)
 
         //- Return const column or column's subset of Matrix
@@ -265,7 +264,6 @@ public:
             const label colIndex
         ) const;
 
-
     // Block Access (non-const)
 
         //- Return column or column's subset of Matrix
@@ -301,7 +299,6 @@ public:
             const label colIndex
         );
 
-
     // Check
 
         //- Check index i is within valid range [0, m)
@@ -316,7 +313,6 @@ public:
         //- True if all entries have identical values, and Matrix is non-empty
         inline bool uniform() const;
 
-
     // Edit
 
         //- Clear Matrix, i.e. set sizes to zero
@@ -342,10 +338,9 @@ public:
         //- Resize Matrix without reallocating storage (unsafe)
         inline void shallowResize(const label m, const label n);
 
-        //- Round to zero elements with magnitude smaller than tol (SMALL)
+        //- Round elements with magnitude smaller than tol (SMALL) to zero
         void round(const scalar tol = SMALL);
 
-
     // Operations
 
         //- Return (conjugate) transpose of Matrix
@@ -386,7 +381,6 @@ public:
 
         //- Return Frobenius norm of Matrix
         //  Optional without sqrt for parallel usage.
-        //  https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm
         scalar norm(const bool noSqrt=false) const;
 
 
@@ -596,159 +590,6 @@ template<class Form, class Type>
 Ostream& operator<<(Ostream& os, const Matrix<Form, Type>& mat);
 
 
-// * * * * * * * * * * * * * * * Global Functions * * * * * * * * * * * * * * //
-
-//- Find max value in Matrix
-template<class Form, class Type>
-const Type& max(const Matrix<Form, Type>& mat);
-
-//- Find min value in Matrix
-template<class Form, class Type>
-const Type& min(const Matrix<Form, Type>& mat);
-
-//- Find the min/max values of Matrix
-template<class Form, class Type>
-MinMax<Type> minMax(const Matrix<Form, Type>& mat);
-
-
-// * * * * * * * * * * * * * * * Global Operators * * * * * * * * * * * * * * //
-
-//- Matrix negation
-template<class Form, class Type>
-Form operator-(const Matrix<Form, Type>& mat);
-
-//- Matrix addition. Returns Matrix of the same form as the first parameter.
-template<class Form1, class Form2, class Type>
-Form1 operator+
-(
-    const Matrix<Form1, Type>& A,
-    const Matrix<Form2, Type>& B
-);
-
-//- Matrix subtraction. Returns Matrix of the same form as the first parameter.
-template<class Form1, class Form2, class Type>
-Form1 operator-
-(
-    const Matrix<Form1, Type>& A,
-    const Matrix<Form2, Type>& B
-);
-
-//- Scalar multiplication of Matrix
-template<class Form, class Type>
-Form operator*
-(
-    const Type& s,
-    const Matrix<Form, Type>& mat
-);
-
-//- Scalar addition of Matrix
-template<class Form, class Type>
-Form operator+
-(
-    const Type& s,
-    const Matrix<Form, Type>& mat
-);
-
-//- Scalar subtraction of Matrix
-template<class Form, class Type>
-Form operator-
-(
-    const Type& s,
-    const Matrix<Form, Type>& mat
-);
-
-//- Scalar multiplication of Matrix
-template<class Form, class Type>
-Form operator*
-(
-    const Matrix<Form, Type>& mat,
-    const Type& s
-);
-
-//- Scalar addition of Matrix
-template<class Form, class Type>
-Form operator+
-(
-    const Matrix<Form, Type>& mat,
-    const Type& s
-);
-
-//- Scalar subtraction of Matrix
-template<class Form, class Type>
-Form operator-
-(
-    const Matrix<Form, Type>& mat,
-    const Type& s
-);
-
-//- Scalar division of Matrix
-template<class Form, class Type>
-Form operator/
-(
-    const Matrix<Form, Type>& mat,
-    const Type& s
-);
-
-//- Matrix-Matrix multiplication using ikj-algorithm
-template<class Form1, class Form2, class Type>
-typename typeOfInnerProduct<Type, Form1, Form2>::type
-operator*
-(
-    const Matrix<Form1, Type>& A,
-    const Matrix<Form2, Type>& B
-);
-
-//- Matrix-vector multiplication (A * x), where x is a column vector
-template<class Form, class Type>
-inline tmp<Field<Type>> operator*
-(
-    const Matrix<Form, Type>& mat,
-    const UList<Type>& x
-);
-
-//- Matrix-vector multiplication (A * x), where x is a column vector
-template<class Form, class Type, class Addr>
-inline tmp<Field<Type>> operator*
-(
-    const Matrix<Form, Type>& mat,
-    const IndirectListBase<Type, Addr>& x
-);
-
-//- Vector-Matrix multiplication (x * A), where x is a row vector
-template<class Form, class Type>
-inline tmp<Field<Type>> operator*
-(
-    const UList<Type>& x,
-    const Matrix<Form, Type>& mat
-);
-
-//- Vector-Matrix multiplication (x * A), where x is a row vector
-template<class Form, class Type, class Addr>
-inline tmp<Field<Type>> operator*
-(
-    const IndirectListBase<Type, Addr>& x,
-    const Matrix<Form, Type>& mat
-);
-
-//- Implicit inner product of Matrix-Matrix, equivalent to A.T()*B
-template<class Form1, class Form2, class Type>
-typename typeOfInnerProduct<Type, Form1, Form2>::type
-operator&
-(
-    const Matrix<Form1, Type>& ATranspose,
-    const Matrix<Form2, Type>& B
-);
-
-//- Implicit outer product of Matrix-Matrix, equivalent to A*B.T()
-template<class Form1, class Form2, class Type>
-typename typeOfInnerProduct<Type, Form1, Form2>::type
-operator^
-(
-    const Matrix<Form1, Type>& A,
-    const Matrix<Form2, Type>& BTranspose
-);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/matrices/Matrix/MatrixI.H b/src/OpenFOAM/matrices/Matrix/MatrixI.H
index 435b22b7c5..ab2909a673 100644
--- a/src/OpenFOAM/matrices/Matrix/MatrixI.H
+++ b/src/OpenFOAM/matrices/Matrix/MatrixI.H
@@ -242,7 +242,7 @@ inline const Type& Foam::Matrix<Form, Type>::at(const label idx) const
             << abort(FatalError);
     }
     #endif
-    return (v_ + idx);
+    return *(v_ + idx);
 }
 
 
@@ -257,7 +257,7 @@ inline Type& Foam::Matrix<Form, Type>::at(const label idx)
             << abort(FatalError);
     }
     #endif
-    return (v_ + idx);
+    return *(v_ + idx);
 }
 
 
@@ -608,8 +608,16 @@ inline Type* Foam::Matrix<Form, Type>::operator[](const label irow)
 }
 
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Global Operators  * * * * * * * * * * * * * //
+
+//- Matrix-vector multiplication (A * x), where x is a column vector
 template<class Form, class Type>
-inline Foam::tmp<Foam::Field<Type>> Foam::operator*
+inline tmp<Field<Type>> operator*
 (
     const Matrix<Form, Type>& mat,
     const UList<Type>& x
@@ -619,8 +627,9 @@ inline Foam::tmp<Foam::Field<Type>> Foam::operator*
 }
 
 
+//- Matrix-vector multiplication (A * x), where x is a column vector
 template<class Form, class Type, class Addr>
-inline Foam::tmp<Foam::Field<Type>> Foam::operator*
+inline tmp<Field<Type>> operator*
 (
     const Matrix<Form, Type>& mat,
     const IndirectListBase<Type, Addr>& x
@@ -630,8 +639,9 @@ inline Foam::tmp<Foam::Field<Type>> Foam::operator*
 }
 
 
+//- Vector-Matrix multiplication (x * A), where x is a row vector
 template<class Form, class Type>
-inline Foam::tmp<Foam::Field<Type>> Foam::operator*
+inline tmp<Field<Type>> operator*
 (
     const UList<Type>& x,
     const Matrix<Form, Type>& mat
@@ -641,8 +651,9 @@ inline Foam::tmp<Foam::Field<Type>> Foam::operator*
 }
 
 
+//- Vector-Matrix multiplication (x * A), where x is a row vector
 template<class Form, class Type, class Addr>
-inline Foam::tmp<Foam::Field<Type>> Foam::operator*
+inline tmp<Field<Type>> operator*
 (
     const IndirectListBase<Type, Addr>& x,
     const Matrix<Form, Type>& mat
@@ -651,5 +662,8 @@ inline Foam::tmp<Foam::Field<Type>> Foam::operator*
     return mat.Tmul(x);
 }
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
 
 // ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/MatrixBlock/MatrixBlock.C b/src/OpenFOAM/matrices/MatrixBlock/MatrixBlock.C
index 7b6ab90153..54b88b39ae 100644
--- a/src/OpenFOAM/matrices/MatrixBlock/MatrixBlock.C
+++ b/src/OpenFOAM/matrices/MatrixBlock/MatrixBlock.C
@@ -176,7 +176,7 @@ void Foam::MatrixBlock<MatrixType>::operator=
     const ConstMatrixBlock<MatrixType>& Mb
 )
 {
-    if (this != &Mb)
+    if (reinterpret_cast<const ConstMatrixBlock<MatrixType>*>(this) != &Mb)
     {
         if (mRows_ != Mb.m() || nCols_ != Mb.n())
         {
@@ -233,7 +233,7 @@ void Foam::MatrixBlock<MatrixType>::operator=
     const ConstMatrixBlock<MatrixType2>& Mb
 )
 {
-    if (this != &Mb)
+    if (reinterpret_cast<const ConstMatrixBlock<MatrixType2>*>(this) != &Mb)
     {
         if (mRows_ != Mb.m() || nCols_ != Mb.n())
         {
diff --git a/src/OpenFOAM/matrices/QRMatrix/QRMatrix.C b/src/OpenFOAM/matrices/QRMatrix/QRMatrix.C
index 4394700e0e..fa9f6833af 100644
--- a/src/OpenFOAM/matrices/QRMatrix/QRMatrix.C
+++ b/src/OpenFOAM/matrices/QRMatrix/QRMatrix.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -497,15 +497,17 @@ MatrixType Foam::pinv
 {
     typedef typename MatrixType::cmptType cmptType;
 
-    #if FULLDEBUG
     if (A.empty())
     {
         FatalErrorInFunction
-            << "Empty matrix." << abort(FatalError);
+            << "Empty matrix found."
+            << abort(FatalError);
     }
 
-    // Check if A is full-rank
-    #endif
+    if (A.size() == 1)
+    {
+        return MatrixType({1, 1}, cmptType(1.0)/(A(0,0) + cmptType(VSMALL)));
+    }
 
     QRMatrix<MatrixType> QRM
     (
@@ -534,9 +536,12 @@ MatrixType Foam::pinv
 
     if (firstZeroElemi == 0)
     {
-        FatalErrorInFunction
+        WarningInFunction
             << "The largest (magnitude) diagonal element is (almost) zero."
-            << abort(FatalError);
+            << nl << "Returning a zero matrix."
+            << endl;
+
+        return MatrixType(A.sizes(), Zero);
     }
 
     // Exclude the first (almost) zero diagonal row and the rows below
diff --git a/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrix.H b/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrix.H
index 5b09ea7568..b5394f017a 100644
--- a/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrix.H
+++ b/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrix.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,13 +28,14 @@ Class
     Foam::RectangularMatrix
 
 Description
-    A templated 2D rectangular m x n matrix of objects of \<Type\>.
+    A templated (M x N) rectangular matrix of objects of \<Type\>,
+    containing M*N elements, derived from Matrix.
 
-    The matrix dimensions are used for subscript bounds checking etc.
+See also
+    Test-RectangularMatrix.C
 
 SourceFiles
     RectangularMatrixI.H
-    RectangularMatrix.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -61,10 +62,19 @@ class RectangularMatrix
 
 public:
 
-    // Constructors
+    // Generated Methods
 
-        //- Construct null
-        inline RectangularMatrix();
+        //- Default construct
+        RectangularMatrix() = default;
+
+        //- Copy construct
+        RectangularMatrix(const RectangularMatrix&) = default;
+
+        //- Copy assignment
+        RectangularMatrix& operator=(const RectangularMatrix&) = default;
+
+
+    // Constructors
 
         //- Construct a square matrix (rows == columns)
         inline explicit RectangularMatrix(const label n);
@@ -85,15 +95,15 @@ public:
         template<class AnyType>
         inline RectangularMatrix(const labelPair& dims, const Identity<AnyType>);
 
-        //- Construct given number of rows/columns
+        //- Construct given number of rows/columns by using a label pair
         inline explicit RectangularMatrix(const labelPair& dims);
 
-        //- Construct given number of rows/columns
-        //- initializing all elements to zero
+        //- Construct given number of rows/columns by using a label pair
+        //- and initializing all elements to zero
         inline RectangularMatrix(const labelPair& dims, const zero);
 
-        //- Construct given number of rows/columns
-        //- initializing all elements to the given value
+        //- Construct given number of rows/columns by using a label pair
+        //- and initializing all elements to the given value
         inline RectangularMatrix(const labelPair& dims, const Type& val);
 
         //- Construct from a block of another matrix
@@ -107,7 +117,7 @@ public:
         //- Construct as copy of a square matrix
         inline RectangularMatrix(const SquareMatrix<Type>& mat);
 
-        //- Construct from Istream.
+        //- Construct from Istream
         inline explicit RectangularMatrix(Istream& is);
 
         //- Clone
@@ -124,41 +134,6 @@ public:
 };
 
 
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-class typeOfInnerProduct<Type, RectangularMatrix<Type>, RectangularMatrix<Type>>
-{
-public:
-
-    typedef RectangularMatrix<Type> type;
-};
-
-
-template<class Type>
-class typeOfInnerProduct<Type, RectangularMatrix<Type>, SquareMatrix<Type>>
-{
-public:
-
-    typedef RectangularMatrix<Type> type;
-};
-
-
-template<class Type>
-class typeOfInnerProduct<Type, SquareMatrix<Type>, RectangularMatrix<Type>>
-{
-public:
-
-    typedef RectangularMatrix<Type> type;
-};
-
-
-// * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-RectangularMatrix<Type> outer(const Field<Type>& f1, const Field<Type>& f2);
-
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrixI.H b/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrixI.H
index 7cef3593e7..9b98e72caa 100644
--- a/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrixI.H
+++ b/src/OpenFOAM/matrices/RectangularMatrix/RectangularMatrixI.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,13 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class Type>
-inline Foam::RectangularMatrix<Type>::RectangularMatrix()
-:
-    Matrix<RectangularMatrix<Type>, Type>()
-{}
-
-
 template<class Type>
 inline Foam::RectangularMatrix<Type>::RectangularMatrix
 (
@@ -197,8 +190,38 @@ inline void Foam::RectangularMatrix<Type>::operator=(const Type& val)
 namespace Foam
 {
 
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+class typeOfInnerProduct<Type, RectangularMatrix<Type>, RectangularMatrix<Type>>
+{
+public:
+
+    typedef RectangularMatrix<Type> type;
+};
+
+
+template<class Type>
+class typeOfInnerProduct<Type, RectangularMatrix<Type>, SquareMatrix<Type>>
+{
+public:
+
+    typedef RectangularMatrix<Type> type;
+};
+
+
+template<class Type>
+class typeOfInnerProduct<Type, SquareMatrix<Type>, RectangularMatrix<Type>>
+{
+public:
+
+    typedef RectangularMatrix<Type> type;
+};
+
+
 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 
+// Return the outer product of Field-Field as RectangularMatrix
 template<class Type>
 inline Foam::RectangularMatrix<Type> outer
 (
@@ -224,5 +247,4 @@ inline Foam::RectangularMatrix<Type> outer
 
 } // End namespace Foam
 
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.C b/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.C
index 4bc1f0f78f..1506cb9972 100644
--- a/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.C
+++ b/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,10 +30,80 @@ License
 #include "RectangularMatrix.H"
 #include "labelList.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class Type>
-Foam::scalar Foam::detDecomposed
+template<class CompOp>
+Foam::List<Foam::label> Foam::SquareMatrix<Type>::sortPermutation
+(
+    CompOp& compare
+) const
+{
+    List<label> p(this->m());
+    std::iota(p.begin(), p.end(), 0);
+    std::sort
+    (
+        p.begin(),
+        p.end(),
+        [&](label i, label j){ return compare((*this)(i,i), (*this)(j,j)); }
+    );
+
+    return p;
+}
+
+
+template<class Type>
+void Foam::SquareMatrix<Type>::applyPermutation(const List<label>& p)
+{
+    #ifdef FULLDEBUG
+    if (this->m() != p.size())
+    {
+        FatalErrorInFunction
+            << "Attempt to column-reorder according to an uneven list: " << nl
+            << "SquareMatrix diagonal size = " << this->m() << nl
+            << "Permutation list size = " << p.size() << nl
+            << abort(FatalError);
+    }
+    #endif
+
+    SquareMatrix<Type> reordered(this->sizes());
+
+    label j = 0;
+    for (const label i : p)
+    {
+        reordered.subColumn(j) = this->subColumn(i);
+        ++j;
+    }
+
+    this->transfer(reordered);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class Type>
+template<class AnyType>
+void Foam::SquareMatrix<Type>::operator=(const Identity<AnyType>)
+{
+    Matrix<SquareMatrix<Type>, Type>::operator=(Zero);
+
+    for (label i = 0; i < this->n(); ++i)
+    {
+        this->operator()(i, i) = pTraits<Type>::one;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
+
+//- Return the determinant of the LU decomposed SquareMatrix
+template<class Type>
+scalar detDecomposed
 (
     const SquareMatrix<Type>& matrix,
     const label sign
@@ -50,8 +120,9 @@ Foam::scalar Foam::detDecomposed
 }
 
 
+//- Return the determinant of SquareMatrix
 template<class Type>
-Foam::scalar Foam::det(const SquareMatrix<Type>& matrix)
+scalar det(const SquareMatrix<Type>& matrix)
 {
     SquareMatrix<Type> matrixTmp = matrix;
 
@@ -63,8 +134,9 @@ Foam::scalar Foam::det(const SquareMatrix<Type>& matrix)
 }
 
 
+//- Return the SquareMatrix det and the LU decomposition in the original matrix
 template<class Type>
-Foam::scalar Foam::det(SquareMatrix<Type>& matrix)
+scalar det(SquareMatrix<Type>& matrix)
 {
     labelList pivotIndices(matrix.m());
     label sign;
@@ -74,19 +146,52 @@ Foam::scalar Foam::det(SquareMatrix<Type>& matrix)
 }
 
 
-// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
-
+//- Return Matrix column-reordered according to
+//- a given permutation labelList
 template<class Type>
-template<class AnyType>
-void Foam::SquareMatrix<Type>::operator=(const Identity<AnyType>)
+SquareMatrix<Type> applyPermutation
+(
+    const SquareMatrix<Type>& mat,
+    const List<label>& p
+)
 {
-    Matrix<SquareMatrix<Type>, Type>::operator=(Zero);
-
-    for (label i=0; i < this->n(); ++i)
+    #ifdef FULLDEBUG
+    if (mat.m() != p.size())
     {
-        this->operator()(i, i) = pTraits<Type>::one;
+        FatalErrorInFunction
+            << "Attempt to column-reorder according to an uneven list: " << nl
+            << "SquareMatrix diagonal size = " << mat.m() << nl
+            << "Permutation list size = " << p.size() << nl
+            << abort(FatalError);
     }
+    #endif
+
+    SquareMatrix<Type> reordered(mat.sizes());
+
+    label j = 0;
+    for (const label i : p)
+    {
+        reordered.subColumn(j) = mat.subColumn(i);
+        ++j;
+    }
+
+    return reordered;
 }
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+class typeOfInnerProduct<Type, SquareMatrix<Type>, SquareMatrix<Type>>
+{
+public:
+
+    typedef SquareMatrix<Type> type;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.H b/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.H
index e404910e06..a79f2d9f42 100644
--- a/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.H
+++ b/src/OpenFOAM/matrices/SquareMatrix/SquareMatrix.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,8 +28,11 @@ Class
     Foam::SquareMatrix
 
 Description
-    A templated 2D square matrix of objects of \<T\>, where the n x n matrix
-    dimension is known and used for subscript bounds checking, etc.
+    A templated (N x N) square matrix of objects of \<Type\>,
+    containing N*N elements, derived from Matrix.
+
+See also
+    Test-SquareMatrix.C
 
 SourceFiles
     SquareMatrixI.H
@@ -42,6 +45,7 @@ SourceFiles
 
 #include "Matrix.H"
 #include "Identity.H"
+#include <numeric>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -64,10 +68,19 @@ class SquareMatrix
 
 public:
 
-    // Constructors
+    // Generated Methods
 
-        //- Construct null
-        inline SquareMatrix();
+        //- Default construct
+        SquareMatrix() = default;
+
+        //- Copy construct
+        SquareMatrix(const SquareMatrix&) = default;
+
+        //- Copy assignment
+        SquareMatrix& operator=(const SquareMatrix&) = default;
+
+
+    // Constructors
 
         //- Construct for given size (rows == cols)
         inline explicit SquareMatrix(const label n);
@@ -85,20 +98,25 @@ public:
         template<class AnyType>
         inline SquareMatrix(const label n, const Identity<AnyType>);
 
+        //- Construct for given size (rows == cols) by using a labelPair
+        //- initializing to the identity matrix
         template<class AnyType>
         inline SquareMatrix(const labelPair& dims, const Identity<AnyType>);
 
-        //- Construct given number of rows/columns (checked to be equal)
+        //- Construct given number of rows/columns
+        //- by using a labelPair (checked to be equal)
         //  For constructor consistency in rectangular matrices
         inline explicit SquareMatrix(const labelPair& dims);
 
-        //- Construct given number of rows/columns (checked to be equal)
-        //- initializing all elements to zero
+        //- Construct given number of rows/columns
+        //- by using a labelPair (checked to be equal)
+        //- and initializing all elements to zero
         //  For constructor consistency with rectangular matrices
         inline SquareMatrix(const labelPair& dims, const zero);
 
-        //- Construct given number of rows/columns (checked to be equal)
-        //- initializing all elements to the given value
+        //- Construct given number of rows/columns
+        //- by using a labelPair (checked to be equal)
+        //- and initializing all elements to the given value
         //  For constructor consistency with rectangular matrices
         inline SquareMatrix(const labelPair& dims, const Type& val);
 
@@ -106,7 +124,7 @@ public:
         //- initializing all elements to zero
         inline SquareMatrix(const label m, const label n, const zero);
 
-        //- Construct from sub-matrix block
+        //- Construct from const sub-matrix block
         template<class MatrixType>
         inline SquareMatrix(const ConstMatrixBlock<MatrixType>& mat);
 
@@ -149,6 +167,17 @@ public:
         //- Return true if the square matrix is reduced tridiagonal
         inline bool tridiagonal() const;
 
+    // Sort
+
+        //- Return a sort permutation labelList according to
+        //- a given comparison on the diagonal entries
+        template<class CompOp>
+        List<label> sortPermutation(CompOp& compare) const;
+
+        //- Column-reorder this Matrix according to
+        //- a given permutation labelList
+        void applyPermutation(const List<label>& p);
+
 
     // Member Operators
 
@@ -164,28 +193,6 @@ public:
 };
 
 
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
-
-//- Return the LU decomposed SquareMatrix det
-template<class Type>
-scalar detDecomposed(const SquareMatrix<Type>&, const label sign);
-
-//- Return the SquareMatrix det
-template<class Type>
-scalar det(const SquareMatrix<Type>&);
-
-//- Return the SquareMatrix det and the LU decomposition in the original matrix
-template<class Type>
-scalar det(SquareMatrix<Type>&);
-
-template<class Type>
-class typeOfInnerProduct<Type, SquareMatrix<Type>, SquareMatrix<Type>>
-{
-public:
-
-    typedef SquareMatrix<Type> type;
-};
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/matrices/SquareMatrix/SquareMatrixI.H b/src/OpenFOAM/matrices/SquareMatrix/SquareMatrixI.H
index 75e893e068..61933881e1 100644
--- a/src/OpenFOAM/matrices/SquareMatrix/SquareMatrixI.H
+++ b/src/OpenFOAM/matrices/SquareMatrix/SquareMatrixI.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,13 +37,6 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class Type>
-inline Foam::SquareMatrix<Type>::SquareMatrix()
-:
-    Matrix<SquareMatrix<Type>, Type>()
-{}
-
-
 template<class Type>
 inline Foam::SquareMatrix<Type>::SquareMatrix(const label n)
 :
@@ -83,7 +76,7 @@ inline Foam::SquareMatrix<Type>::SquareMatrix
 :
     Matrix<SquareMatrix<Type>, Type>(n, n, Zero)
 {
-    for (label i=0; i < n; ++i)
+    for (label i = 0; i < n; ++i)
     {
         this->operator()(i, i) = pTraits<Type>::one;
     }
@@ -318,6 +311,7 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * //
 
+// Return the outer product of Field-Field as SquareMatrix
 template<class Type>
 inline Foam::SquareMatrix<Type> symmOuter
 (
diff --git a/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.C b/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.C
index de6291e361..b50a96e7b1 100644
--- a/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.C
+++ b/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.C
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -126,4 +126,4 @@ void Foam::SymmetricSquareMatrix<Type>::operator=(const Identity<AnyType>)
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// ************************************************************************* //
diff --git a/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.H b/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.H
index 49af9fae42..c04ec0c855 100644
--- a/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.H
+++ b/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrix.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -28,8 +28,11 @@ Class
     Foam::SymmetricSquareMatrix
 
 Description
-    A templated 2D square symmetric matrix of objects of \<T\>, where the
-    n x n matrix dimension is known and used for subscript bounds checking, etc.
+    A templated (N x N) square matrix of objects of \<Type\>,
+    containing N*N elements, derived from Matrix.
+
+See also
+    Test-SymmetricSquareMatrix.C
 
 SourceFiles
     SymmetricSquareMatrixI.H
@@ -59,10 +62,19 @@ class SymmetricSquareMatrix
 
 public:
 
-    // Constructors
+    // Generated Methods
 
-        //- Construct null
-        inline SymmetricSquareMatrix();
+        //- Default construct
+        SymmetricSquareMatrix() = default;
+
+        //- Copy construct
+        SymmetricSquareMatrix(const SymmetricSquareMatrix&) = default;
+
+        //- Copy assignment
+        SymmetricSquareMatrix& operator=(const SymmetricSquareMatrix&) = default;
+
+
+    // Constructors
 
         //- Construct for given size (rows == cols)
         inline explicit SymmetricSquareMatrix(const label n);
@@ -76,7 +88,7 @@ public:
         inline SymmetricSquareMatrix(const label n, const Type& val);
 
         //- Construct for given size (rows == cols)
-        //- setting the diagonal to one and off-diagonals to zero
+        //- initializing to the identity matrix
         template<class AnyType>
         inline SymmetricSquareMatrix(const label n, const Identity<AnyType>);
 
diff --git a/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrixI.H b/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrixI.H
index 79c6b2a05e..31eff60765 100644
--- a/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrixI.H
+++ b/src/OpenFOAM/matrices/SymmetricSquareMatrix/SymmetricSquareMatrixI.H
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2019 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -37,13 +37,6 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class Type>
-inline Foam::SymmetricSquareMatrix<Type>::SymmetricSquareMatrix()
-:
-    Matrix<SymmetricSquareMatrix<Type>, Type>()
-{}
-
-
 template<class Type>
 inline Foam::SymmetricSquareMatrix<Type>::SymmetricSquareMatrix(const label n)
 :
diff --git a/src/functionObjects/field/Make/files b/src/functionObjects/field/Make/files
index 649176d1f4..580d9a3340 100644
--- a/src/functionObjects/field/Make/files
+++ b/src/functionObjects/field/Make/files
@@ -118,4 +118,6 @@ stabilityBlendingFactor/stabilityBlendingFactor.C
 
 interfaceHeight/interfaceHeight.C
 
+STDMD/STDMD.C
+
 LIB = $(FOAM_LIBBIN)/libfieldFunctionObjects
diff --git a/src/functionObjects/field/Make/options b/src/functionObjects/field/Make/options
index c24acfb632..5d3d5f11d6 100644
--- a/src/functionObjects/field/Make/options
+++ b/src/functionObjects/field/Make/options
@@ -1,4 +1,5 @@
 EXE_INC = \
+    -I$(LIB_SRC)/OpenFOAM/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/fileFormats/lnInclude \
     -I$(LIB_SRC)/surfMesh/lnInclude \
@@ -22,6 +23,7 @@ EXE_INC = \
     -I$(LIB_SRC)/phaseSystemModels/reactingEulerFoam/phaseSystems/lnInclude
 
 LIB_LIBS = \
+    -lOpenFOAM \
     -lfiniteVolume \
     -lfileFormats \
     -lsurfMesh \
diff --git a/src/functionObjects/field/STDMD/STDMD.C b/src/functionObjects/field/STDMD/STDMD.C
new file mode 100644
index 0000000000..d550a4cefb
--- /dev/null
+++ b/src/functionObjects/field/STDMD/STDMD.C
@@ -0,0 +1,1280 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 "STDMD.H"
+#include "addToRunTimeSelectionTable.H"
+
+using namespace Foam::constant::mathematical;
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+    defineTypeNameAndDebug(STDMD, 0);
+    addToRunTimeSelectionTable(functionObject, STDMD, dictionary);
+}
+}
+
+
+const Foam::Enum
+<
+    Foam::functionObjects::STDMD::modeSorterType
+>
+Foam::functionObjects::STDMD::modeSorterTypeNames
+({
+    { modeSorterType::KIEWAT , "kiewat" },
+    { modeSorterType::KOU_ZHANG , "kouZhang" },
+    { modeSorterType::FIRST_SNAPSHOT, "firstSnap" }
+});
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::scalar Foam::functionObjects::STDMD::parnorm
+(
+    const RMatrix& colVector
+) const
+{
+    #ifdef FULLDEBUG
+    // Check if the given RectangularMatrix is effectively a column vector
+    if (colVector.n() != 1)
+    {
+        FatalErrorInFunction
+            << "  # Input matrix is not a column vector. #"
+            << abort(FatalError);
+    }
+    #endif
+    const bool noSqrt = true;
+    scalar result(colVector.columnNorm(0, noSqrt));
+    reduce(result, sumOp<scalar>());
+
+    // Heuristic addition to avoid very small or zero norm
+    return max(SMALL, Foam::sqrt(result));
+}
+
+
+void Foam::functionObjects::STDMD::snapshot()
+{
+    bool processed = false;
+    processed = processed || getSnapshotType<scalar>();
+    processed = processed || getSnapshotType<vector>();
+    processed = processed || getSnapshotType<sphericalTensor>();
+    processed = processed || getSnapshotType<symmTensor>();
+    processed = processed || getSnapshotType<tensor>();
+
+    if (!processed)
+    {
+        FatalErrorInFunction
+            << "  # Unknown type of input field during snapshot loading = "
+            << fieldName_ << " #" << nl
+            << "  # Do you execute required functionObjects "
+            << "before executing STDMD, e.g. mapFields?"
+            << abort(FatalError);
+    }
+}
+
+
+void Foam::functionObjects::STDMD::init()
+{
+    bool processed = false;
+    processed = processed || getComps<scalar>();
+    processed = processed || getComps<vector>();
+    processed = processed || getComps<sphericalTensor>();
+    processed = processed || getComps<symmTensor>();
+    processed = processed || getComps<tensor>();
+
+    if (!processed)
+    {
+        FatalErrorInFunction
+            << "  # Unknown type of input field during initialisation = "
+            << fieldName_ << " #" << nl
+            << "  # Do you execute required functionObjects "
+            << "before executing STDMD, e.g. mapFields?"
+            << abort(FatalError);
+    }
+
+    nSnap_ = nComps_*mesh_.nCells();
+
+    if (nSnap_ <= 0)
+    {
+        FatalErrorInFunction
+            << "  # Zero-size input field = " << fieldName_ << " #"
+            << abort(FatalError);
+    }
+
+    currIndex_ = 0;
+    zNorm_ = 0;
+    ezNorm_ = 0;
+
+    z_ = RMatrix(2*nSnap_, 1, Zero);
+    ez_ = z_;
+    X1_ = RMatrix(nSnap_, 1, Zero);
+    Qz_ = z_;
+    Gz_ = SMatrix(1);
+
+    RxInv_.clear();
+    Ap_.clear();
+    oEVecs_.clear();
+    oEVals_.clear();
+    oAmps_.clear();
+    oFreqs_.clear();
+    iFreqs_.clear();
+    oMags_.clear();
+    iMags_.clear();
+
+    initialised_ = true;
+}
+
+
+void Foam::functionObjects::STDMD::initBasis()
+{
+    std::copy(z_.cbegin(), z_.cbegin() + nSnap_, X1_.begin());
+
+    zNorm_ = parnorm(z_);
+    Qz_ = z_/zNorm_;
+    Gz_(0,0) = sqr(zNorm_);
+}
+
+
+void Foam::functionObjects::STDMD::GramSchmidt()
+{
+    ez_ = z_;
+    RMatrix dz(Qz_.n(), 1, Zero);
+
+    for (label i = 0; i < nGramSchmidt_; ++i)
+    {
+        dz = Qz_ & ez_;
+        reduce(dz, sumOp<RMatrix>());
+        ez_ -= Qz_*dz;
+    }
+}
+
+
+void Foam::functionObjects::STDMD::expandBasis()
+{
+    Log<< tab << "# " << name() << ":"
+        << " Expanding orthonormal basis for field = " << fieldName_ << " #"
+        << endl;
+
+    // Stack a column (ez_/ezNorm_) to Qz_
+    Qz_.resize(Qz_.m(), Qz_.n() + 1);
+    Qz_.subColumn(Qz_.n() - 1) = ez_/ezNorm_;
+
+    // Stack a row (Zero) and column (Zero) to Gz_
+    Gz_.resize(Gz_.m() + 1);
+}
+
+
+void Foam::functionObjects::STDMD::updateGz()
+{
+    RMatrix zTilde(Qz_ & z_);
+    reduce(zTilde, sumOp<RMatrix>());
+
+    const SMatrix zTildes(zTilde^zTilde);
+
+    Gz_ += zTildes;
+}
+
+
+void Foam::functionObjects::STDMD::compressBasis()
+{
+    Log<< tab << "# " << name() << ":"
+        << " Compressing orthonormal basis for field = " << fieldName_ << " #"
+        << endl;
+
+    RMatrix qz;
+
+    if (Pstream::master())
+    {
+        const bool symmetric = true;
+        const EigenMatrix<scalar> EM(Gz_, symmetric);
+        const SquareMatrix<scalar>& EVecs = EM.EVecs();
+        DiagonalMatrix<scalar> EVals(EM.EValsRe());
+
+        if (testEigen_)
+        {
+            testEigenvalues(Gz_, EVals);
+            testEigenvectors(Gz_, EVals, EVecs);
+        }
+
+        // Sort eigenvalues in descending order, and track indices
+        const auto descend = [&](scalar a, scalar b){ return a > b; };
+        const List<label> permut(EVals.sortPermutation(descend));
+        EVals.applyPermutation(permut);
+        EVals.resize(EVals.size() - 1);
+
+        // Update Gz_
+        Gz_ = SMatrix(maxRank_, Zero);
+        Gz_.diag(EVals);
+
+        qz.resize(Qz_.n(), maxRank_);
+        for (label i = 0; i < maxRank_; ++i)
+        {
+            qz.subColumn(i) = EVecs.subColumn(permut[i]);
+        }
+    }
+    Pstream::scatter(Gz_);
+    Pstream::scatter(qz);
+
+    // Update Qz_
+    Qz_ = Qz_*qz;
+}
+
+
+void Foam::functionObjects::STDMD::calcAp()
+{
+    Log<< tab << "# " << name() << ": Computing Ap matrix #" << endl;
+
+    Log<< tab << "# " << name() << ": Computing local Rx #" << endl;
+    RMatrix Rx;
+    {
+        QRMatrix<RMatrix> QRM
+        (
+            QzUH_,
+            QRMatrix<RMatrix>::outputTypes::REDUCED_R,
+            QRMatrix<RMatrix>::colPivoting::FALSE
+        );
+        Rx = QRM.R();
+    }
+    Rx.round();
+
+    RMatrix A1; // Convenience objects A1, A2, A3 to compute Ap
+    if (Pstream::parRun())
+    {
+        // Parallel direct tall-skinny QR decomposition
+        // (BGD:Fig. 5) & (DGHL:Fig. 2)
+        // Tests revealed that the distribution of Qz_ does not affect
+        // the final outcome of TSQR decomposition up to sign
+
+        Log<< tab << "# " << name() << ": Gathering all local Rx #" << endl;
+        List<RMatrix> RxList(Pstream::nProcs());
+        RxList[Pstream::myProcNo()] = Rx;
+        Pstream::gatherList(RxList);
+        Pstream::scatterList(RxList);
+
+        // Create a global object Rx
+        if (Pstream::master())
+        {
+            // Determine the row size of the global Rx
+            label mRowSum = 0;
+            forAll(RxList, i)
+            {
+                mRowSum += RxList[i].m();
+            }
+
+            Rx.resize(mRowSum, Rx.n());
+
+            Log<< tab << "# " << name()
+                << ": Populating the global Rx #" << endl;
+            label m = 0;
+            for (label i = 0; i < Pstream::nProcs(); ++i)
+            {
+                label mRows = RxList[i].m();
+
+                Rx.subMatrix(m, 0, mRows) = RxList[i];
+
+                m += mRows;
+            }
+
+            Log<< tab << "# " << name()
+                << ": Computing the parallel-direct tall-skinny QR decomp. #"
+                << endl;
+            QRMatrix<RMatrix> QRM
+            (
+                Rx,
+                QRMatrix<RMatrix>::outputTypes::REDUCED_R,
+                QRMatrix<RMatrix>::storeMethods::IN_PLACE,
+                QRMatrix<RMatrix>::colPivoting::FALSE
+            );
+            Rx.round();
+
+            Log<< tab << "# " << name()
+                << ": Computing Moore-Penrose pseudo-inverse of Rx #"
+                << endl;
+            RxInv_ = pinv(Rx);
+
+            Log<< tab << "# " << name() << ": Computing Gx #" << endl;
+            const RMatrix Gx(Rx*(Gz_^Rx));
+
+            Log<< tab << "# " << name()
+                << ": Computing Moore-Penrose pseudo-inverse of Gx #"
+                << endl;
+            const RMatrix GxInv(pinv(Gx));
+
+            Log<< tab << "# " << name() << ": Computing A1 #" << endl;
+            A1 = RxInv_*GxInv;
+        }
+        Pstream::scatter(RxInv_);
+        Pstream::scatter(A1);
+
+        Log<< tab << "# " << name() << ": Computing A2 #" << endl;
+        SMatrix A2(QzUH_ & QzUH_);
+        reduce(A2, sumOp<SMatrix>());
+
+        Log<< tab << "# " << name() << ": Computing A3 #" << endl;
+        SMatrix A3(QzUH_ & QzLH_);
+        reduce(A3, sumOp<SMatrix>());
+
+        Log<< tab << "# " << name() << ": Computing Ap #" << endl;
+        // by optimized matrix chain multiplication
+        // obtained by dynamic programming memoisation
+        Ap_ = SMatrix(RxInv_ & ((A3*(Gz_*A2))*A1));
+    }
+    else
+    {
+        {
+            Log<< tab << "# " << name()
+                << ": Computing Moore-Penrose pseudo-inverse of Rx #"
+                << endl;
+            RxInv_ = pinv(Rx);
+
+            Log<< tab << "# " << name() << ": Computing Gx #" << endl;
+            const RMatrix Gx(Rx*(Gz_^Rx));
+
+            Log<< tab << "# " << name()
+                << ": Computing Moore-Penrose pseudo-inverse of Gx #"
+                << endl;
+            const RMatrix GxInv(pinv(Gx));
+
+            Log<< tab << "# " << name() << ": Computing A1 #" << endl;
+            A1 = RxInv_*GxInv;
+        }
+
+        Log<< tab << "# " << name() << ": Computing A2 #" << endl;
+        SMatrix A2(QzUH_ & QzUH_);
+
+        Log<< tab << "# " << name() << ": Computing A3 #" << endl;
+        SMatrix A3(QzUH_ & QzLH_);
+
+        Log<< tab << "# " << name() << ": Computing Ap #" << endl;
+        // by optimized matrix chain multiplication
+        // obtained by dynamic programming memoisation
+        Ap_ = SMatrix(RxInv_ & ((A3*(Gz_*A2))*A1));
+    }
+}
+
+
+void Foam::functionObjects::STDMD::calcEigen()
+{
+    Log<< tab << "# " << name() << ": Computing eigendecomposition #" << endl;
+
+    // Compute eigenvalues, and clip eigenvalues with values < minMagEVal_
+    if (Pstream::master())
+    {
+        // Replace Ap by eigenvalues (in-place eigendecomposition)
+        const EigenMatrix<scalar> EM(Ap_);
+        const DiagonalMatrix<scalar>& evalsRe = EM.EValsRe();
+        const DiagonalMatrix<scalar>& evalsIm = EM.EValsIm();
+
+        oEVals_.resize(evalsRe.size());
+        oEVecs_ = RectangularMatrix<complex>(EM.complexEVecs());
+
+        // Convert scalar eigenvalue pairs to complex eigenvalues
+        label i = 0;
+        for (auto& eval : oEVals_)
+        {
+            eval = complex(evalsRe[i], evalsIm[i]);
+            ++i;
+        }
+
+        if (testEigen_)
+        {
+            testEigenvalues(Ap_, evalsRe);
+            testEigenvectors(Ap_, oEVals_, oEVecs_);
+        }
+    }
+}
+
+
+bool Foam::functionObjects::STDMD::close
+(
+    const scalar s1,
+    const scalar s2,
+    const scalar absTol,
+    const scalar relTol
+) const
+{
+    if (s1 == s2) return true;
+
+    return (mag(s1 - s2) <= max(relTol*max(mag(s1), mag(s2)), absTol));
+}
+
+
+void Foam::functionObjects::STDMD::testEigenvalues
+(
+    const SquareMatrix<scalar>& A,
+    const DiagonalMatrix<scalar>& EValsRe
+) const
+{
+    const scalar trace = A.trace();
+    // Imaginary part of complex conjugates cancel each other
+    const scalar EValsSum = sum(EValsRe);
+
+    const bool clse = close(EValsSum - trace, 0, absTol_, relTol_);
+
+    if (clse)
+    {
+        Info<< tab
+            << "  ## PASS: Eigenvalues ##" << endl;
+    }
+    else
+    {
+        Info<< tab
+            << "  ## INCONCLUSIVE: Eigenvalues ##" << nl
+            << "  # sum(eigenvalues) = " << EValsSum << nl
+            << "  # trace(A) = " << trace << nl
+            << "  # sum(eigenvalues) - trace(A) ~ 0 ?= "
+            << EValsSum - trace << nl
+            << "  #######################"
+            << endl;
+
+        if (dumpEigen_)
+        {
+            Info<< tab
+                << "  ## Operands ##" << nl
+                << "  # eigenvalues:" << nl << EValsRe << nl
+                << "  # input matrix A:" << nl << A << nl
+                << "  ##############"
+                << endl;
+        }
+    }
+}
+
+
+void Foam::functionObjects::STDMD::testEigenvectors
+(
+    const SquareMatrix<scalar>& A,
+    const DiagonalMatrix<scalar>& EValsRe,
+    const SquareMatrix<scalar>& EVecs
+) const
+{
+    unsigned nInconclusive = 0;
+
+    for (label i = 0; i < A.n(); ++i)
+    {
+        const RectangularMatrix<scalar> EVec(EVecs.subColumn(i));
+        const scalar EVal = EValsRe[i];
+        const RectangularMatrix<scalar> leftSide(A*EVec);
+        const RectangularMatrix<scalar> rightSide(EVal*EVec);
+        const scalar rslt = (leftSide - rightSide).norm();
+
+        const bool clse = close(rslt, 0, absTol_, relTol_);
+
+        if (!clse)
+        {
+            Info<< tab
+                << "  ## INCONCLUSIVE: Eigenvector ##" << nl
+                << "  # (A & EVec - EVal*EVec).norm() ~ 0 ?= " << rslt << nl
+                << "  ##################################"
+                << endl;
+
+            if (dumpEigen_)
+            {
+                Info<< tab
+                    << "  ## Operands ##" << nl
+                    << "  # eigenvalue:" << nl << EVal << nl
+                    << "  # input matrix A:" << nl << A << nl
+                    << "  # eigenvector:" << nl << EVec << nl
+                    << "  # (A & EVec):" << nl << leftSide << nl
+                    << "  # (EVal*EVec):" << nl << rightSide << nl
+                    << "  ##############"
+                    << endl;
+            }
+
+            ++nInconclusive;
+        }
+    }
+
+    if (!nInconclusive)
+    {
+        Info<< tab
+            << "  ## PASS: Eigenvectors ##" << endl;
+    }
+}
+
+
+void Foam::functionObjects::STDMD::testEigenvectors
+(
+    const SquareMatrix<scalar>& A,
+    const List<complex>& EVals,
+    const RectangularMatrix<complex>& EVecs
+) const
+{
+    SquareMatrix<complex> B(A.m());
+    auto convertToComplex = [&](const scalar& val) { return complex(val); };
+    std::transform
+    (
+        A.cbegin(),
+        A.cend(),
+        B.begin(),
+        convertToComplex
+    );
+
+    unsigned nInconclusive = 0;
+
+    for (label i = 0; i < B.n(); ++i)
+    {
+        const RectangularMatrix<complex> EVec(EVecs.subColumn(i));
+        const complex EVal = EVals[i];
+        const RectangularMatrix<complex> leftSide(B*EVec);
+        const RectangularMatrix<complex> rightSide(EVal*EVec);
+        const scalar rslt = (leftSide - rightSide).norm();
+
+        const bool clse = close(rslt, 0, absTol_, relTol_);
+
+        if (!clse)
+        {
+            Info<< tab
+                << "  ## INCONCLUSIVE: Eigenvector ##" << nl
+                << "  # (A & EVec - EVal*EVec).norm() ~ 0 ?= " << rslt << nl
+                << "  ##################################"
+                << endl;
+
+            if (dumpEigen_)
+            {
+                Info<< tab
+                    << "  ## Operands ##" << nl
+                    << "  # eigenvalue:" << nl << EVal << nl
+                    << "  # input matrix A:" << nl << A << nl
+                    << "  # eigenvector:" << nl << EVec << nl
+                    << "  # (A & EVec):" << nl << leftSide << nl
+                    << "  # (EVal*EVec):" << nl << rightSide << nl
+                    << "  ##############"
+                    << endl;
+            }
+
+            ++nInconclusive;
+        }
+    }
+
+    if (!nInconclusive)
+    {
+        Info<< tab
+            << "  ## PASS: Eigenvectors ##" << endl;
+    }
+}
+
+
+void Foam::functionObjects::STDMD::filterEVals()
+{
+    Log<< tab << "# " << name() << ": Filtering eigenvalues #" << endl;
+
+    if (Pstream::master())
+    {
+        List<complex> cpEVals(oEVals_.size());
+        auto it =
+            std::copy_if
+            (
+                oEVals_.cbegin(),
+                oEVals_.cend(),
+                cpEVals.begin(),
+                [&](const complex& x){ return minMagEVal_ < mag(x); }
+            );
+        cpEVals.resize(std::distance(cpEVals.begin(), it));
+
+        if (cpEVals.size() == 0)
+        {
+            WarningInFunction
+                << "No eigenvalue with mag(eigenvalue) larger than "
+                << "minMagEVal_ = " << minMagEVal_ << " was found."
+                << endl;
+        }
+        else
+        {
+            oEVals_ = cpEVals;
+        }
+    }
+    Pstream::scatter(oEVals_);
+    Pstream::scatter(oEVecs_);
+}
+
+
+void Foam::functionObjects::STDMD::calcFreqs()
+{
+    Log<< tab << "# " << name() << ": Computing frequencies #" << endl;
+
+    if (Pstream::master())
+    {
+        oFreqs_.resize(oEVals_.size());
+
+        // Frequency equation (K:Eq. 81)
+        auto fEq =
+            [&](const complex& EVal)
+            {
+                return Foam::log(max(EVal, complex(SMALL))).imag()/(twoPi*dt_);
+            };
+
+        // Compute frequencies
+        std::transform(oEVals_.cbegin(), oEVals_.cend(), oFreqs_.begin(), fEq);
+    }
+}
+
+
+void Foam::functionObjects::STDMD::calcFreqI()
+{
+    Log<< tab << "# " << name() << ": Computing frequency indices #" << endl;
+
+    if (Pstream::master())
+    {
+        // Initialise iterator by the first search
+        auto margin = [&](const scalar& x){ return (fMin_ <= x && x < fMax_); };
+
+        auto it = std::find_if(oFreqs_.cbegin(), oFreqs_.cend(), margin);
+
+        while (it != oFreqs_.end())
+        {
+            iFreqs_.append(std::distance(oFreqs_.cbegin(), it));
+            it = std::find_if(std::next(it), oFreqs_.cend(), margin);
+        }
+    }
+    Pstream::scatter(oFreqs_);
+    Pstream::scatter(iFreqs_);
+}
+
+
+void Foam::functionObjects::STDMD::calcAmps()
+{
+    Log<< tab << "# " << name() << ": Computing amplitudes #" << endl;
+
+    RMatrix temp((RxInv_.T()^QzUH_)*X1_);
+    reduce(temp, sumOp<RMatrix>());
+
+    if (Pstream::master())
+    {
+        oAmps_.resize(temp.m());
+        const RCMatrix pinvEVecs(pinv(oEVecs_));
+
+        // oAmps_ = pinvEVecs*temp;
+        for (label i = 0; i < oAmps_.size(); ++i)
+        {
+            for (label k = 0; k < temp.m(); ++k)
+            {
+                oAmps_[i] += pinvEVecs(i, k)*temp(k, 0);
+            }
+        }
+    }
+    Pstream::scatter(oAmps_);
+}
+
+
+void Foam::functionObjects::STDMD::calcMags()
+{
+    Log<< tab << "# " << name() << ": Computing magnitudes #" << endl;
+
+    if (Pstream::master())
+    {
+        oMags_.resize(oAmps_.size());
+
+        Log<< tab << "# " << name() << ": Sorting modes with ";
+
+        switch (modeSorter_)
+        {
+            case modeSorterType::FIRST_SNAPSHOT:
+            {
+                Log<< "method of first snapshot #" << endl;
+
+                std::transform
+                (
+                    oAmps_.cbegin(),
+                    oAmps_.cend(),
+                    oMags_.begin(),
+                    [&](const complex& val){ return mag(val); }
+                );
+                break;
+            }
+
+            case modeSorterType::KIEWAT:
+            {
+                Log<< "modified weighted amplitude scaling method #" << endl;
+
+                //  Eigendecomposition returns eigenvectors with
+                //  the unity norm, hence modeNorm = 1
+                const scalar modeNorm = 1;
+                const scalar pr = 1;
+                List<scalar> w(currIndex_);
+                std::iota(w.begin(), w.end(), 1);
+                w = sin(twoPi/currIndex_*(w - 1 - 0.25*currIndex_))*pr + pr;
+
+                label i = 0;
+                for (const auto& amp : oAmps_)
+                {
+                    oMags_[i] = sorter(w, amp, oEVals_[i], modeNorm);
+                    ++i;
+                }
+                break;
+            }
+
+            case modeSorterType::KOU_ZHANG:
+            {
+                Log<< "weighted amplitude scaling method #" << endl;
+
+                const scalar modeNorm = 1;
+                const List<scalar> w(currIndex_, 1.0);
+                label i = 0;
+                for (const auto& amp : oAmps_)
+                {
+                    oMags_[i] = sorter(w, amp, oEVals_[i], modeNorm);
+                    ++i;
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+}
+
+
+void Foam::functionObjects::STDMD::calcMagI()
+{
+    Log<< tab << "# " << name() << ": Computing magnitude indices #" << endl;
+
+    if (Pstream::master())
+    {
+        iMags_ = iFreqs_;
+
+        auto descend =
+            [&](const label i1, const label i2)
+            {
+                return !(oMags_[i1] < oMags_[i2]);
+            };
+
+        std::sort(iMags_.begin(), iMags_.end(), descend);
+    }
+    Pstream::scatter(oMags_);
+    Pstream::scatter(iMags_);
+}
+
+
+void Foam::functionObjects::STDMD::calcModes()
+{
+    Log<< tab << "# " << name() << ": Computing modes #" << endl;
+
+    // Resize the number of output variables to nModes_, if need be
+    if (nModes_ < iMags_.size())
+    {
+        iMags_.resize(nModes_);
+    }
+
+    // Compute and write out modes one by one
+    label oModeI = 0;
+    const RMatrix temp(QzUH_*RxInv_);
+
+    for (const auto& i : iMags_)
+    {
+        List<complex> mode(temp.m(), Zero);
+
+        // mode = temp*oEVecs_.subColumn(i);
+        for (label p = 0; p < mode.size(); ++p)
+        {
+            for (label q = 0; q < oEVecs_.m(); ++q)
+            {
+                mode[p] += temp(p, q)*oEVecs_(q, i);
+            }
+        }
+
+        volVectorField modeReal
+        (
+            IOobject
+            (
+                "modeReal" + std::to_string(oModeI) + fieldName_ + "_" + name(),
+                time_.timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh_,
+            dimensionedVector(dimless, Zero)
+        );
+
+        volVectorField modeImag
+        (
+            IOobject
+            (
+                "modeImag" + std::to_string(oModeI) + fieldName_ + "_" + name(),
+                time_.timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh_,
+            dimensionedVector(dimless, Zero)
+        );
+
+        label s = 0;
+        for (label k = 0; k < nComps_; ++k)
+        {
+            for (label j = 0; j < modeReal.size(); ++j)
+            {
+                const complex& m = mode[s];
+                modeReal[j].replace(k, m.real());
+                modeImag[j].replace(k, m.imag());
+                ++s;
+            }
+        }
+
+        modeReal.write();
+        modeImag.write();
+
+        ++oModeI;
+    }
+}
+
+
+Foam::scalar Foam::functionObjects::STDMD::sorter
+(
+    const List<scalar>& weight,
+    const complex& amplitude,
+    const complex& eval,
+    const scalar modeNorm
+) const
+{
+    // Omit eigenvalues with very large or very small magnitudes
+    if (!(mag(eval) < GREAT && mag(eval) > VSMALL))
+    {
+        Info<< "  Returning zero magnitude for mag(eval) = " << mag(eval)
+            << endl;
+
+        return 0.0;
+    }
+
+    // Omit eigenvalue-STDMD step combinations that pose a risk of overflow
+    if (mag(eval)*currIndex_ > sortLimiter_)
+    {
+        Info<< "  Returning zero magnitude for"
+            << " mag(eval) = " << mag(eval)
+            << " currIndex = " << currIndex_
+            << " sortLimiter = " << sortLimiter_
+            << endl;
+
+        return 0.0;
+    }
+
+    scalar magnitude = 0;
+
+    for (label j = 0; j < currIndex_; ++j)
+    {
+        magnitude += weight[j]*modeNorm*mag(amplitude*pow(eval, j + 1));
+    }
+
+    return magnitude;
+}
+
+
+void Foam::functionObjects::STDMD::writeFileHeader(Ostream& os) const
+{
+    writeHeader(os, "STDMD output");
+    writeCommented(os, "Frequency");
+    writeTabbed(os, "Magnitude");
+    writeTabbed(os, "Amplitude (real)");
+    writeTabbed(os, "Amplitude (imag)");
+    writeTabbed(os, "Eigenvalue (real)");
+    writeTabbed(os, "Eigenvalue (imag)");
+    os  << endl;
+}
+
+
+void Foam::functionObjects::STDMD::filterOutput()
+{
+    Log<< tab << "# " << name() << ": Filtering text output #" << endl;
+
+    if (Pstream::master())
+    {
+        // Filter objects according to iMags
+        filterIndexed(oEVals_, iMags_);
+        filterIndexed(oEVecs_, iMags_);
+        filterIndexed(oFreqs_, iMags_);
+        filterIndexed(oAmps_, iMags_);
+        filterIndexed(oMags_, iMags_);
+
+        // Clip objects if need be (assuming objects have the same len)
+        if (nModes_ < oFreqs_.size())
+        {
+            oEVals_.resize(nModes_);
+            oEVecs_.resize(oEVecs_.m(), nModes_);
+            oFreqs_.resize(nModes_);
+            oAmps_.resize(nModes_);
+            oMags_.resize(nModes_);
+        }
+    }
+}
+
+
+void Foam::functionObjects::STDMD::writeOutput(OFstream& os) const
+{
+    Log<< tab << "# " << name() << ": Writing text output #" << endl;
+
+    writeFileHeader(os);
+
+    for (const auto& i : labelRange(0, oFreqs_.size()))
+    {
+        os  << oFreqs_[i] << tab
+            << oMags_[i] << tab
+            << oAmps_[i].real() << tab
+            << oAmps_[i].imag() << tab
+            << oEVals_[i].real() << tab
+            << oEVals_[i].imag() << endl;
+    }
+}
+
+
+void Foam::functionObjects::STDMD::calcOutput()
+{
+    Log<< tab << "# " << name() << ":"
+        << " Starts output processing for field = " << fieldName_ << " #"
+        << endl;
+
+    // Move upper and lower halves of Qz_ to new containers
+    QzUH_ = Qz_.subMatrix(0, 0, nSnap_);
+    QzLH_ = Qz_.subMatrix(nSnap_, 0, nSnap_);
+    Qz_.clear();
+
+    calcAp();
+
+    QzLH_.clear();
+    Gz_.clear();
+
+    calcEigen();
+
+    filterEVals();
+
+    Ap_.clear();
+
+    calcFreqs();
+
+    calcFreqI();
+
+    calcAmps();
+
+    calcMags();
+
+    calcMagI();
+
+    calcModes();
+
+    // Write out unfiltered data
+    if (Pstream::master() && writeToFile_)
+    {
+        autoPtr<OFstream> osPtr =
+            createFile("uSTDMD" + fieldName_, mesh_.time().timeOutputValue());
+        OFstream& os = osPtr.ref();
+
+        writeOutput(os);
+    }
+
+    filterOutput();
+
+    // Write out filtered data
+    if (Pstream::master() && writeToFile_)
+    {
+        autoPtr<OFstream> osPtr =
+            createFile("STDMD" + fieldName_, mesh_.time().timeOutputValue());
+        OFstream& os = osPtr.ref();
+
+        writeOutput(os);
+    }
+
+    Log<< tab << "# " << name() << ":"
+        << " Ends output processing for field = " << fieldName_ << " #"
+        << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::functionObjects::STDMD::STDMD
+(
+    const word& name,
+    const Time& runTime,
+    const dictionary& dict
+)
+:
+    fvMeshFunctionObject(name, runTime, dict),
+    writeFile(mesh_, name, typeName, dict, false),
+    modeSorter_
+    (
+        modeSorterTypeNames.getOrDefault
+        (
+            "modeSorter",
+            dict,
+            modeSorterType::FIRST_SNAPSHOT
+        )
+    ),
+    fieldName_(dict.get<word>("field")),
+    initialised_(false),
+    testEigen_(false),
+    dumpEigen_(false),
+    nModes_
+    (
+        dict.getCheckOrDefault<label>
+        (
+            "nModes",
+            pTraits<label>::max,
+            labelMinMax::ge(1)
+        )
+    ),
+    maxRank_
+    (
+        dict.getCheckOrDefault<label>
+        (
+            "maxRank",
+            pTraits<label>::max,
+            labelMinMax::ge(1)
+        )
+    ),
+    nGramSchmidt_
+    (
+        dict.getCheckOrDefault<label>
+        (
+            "nGramSchmidt",
+            5,
+            labelMinMax::ge(1)
+        )
+    ),
+    fMin_
+    (
+        dict.getCheckOrDefault<label>
+        (
+            "fMin",
+            0,
+            labelMinMax::ge(0)
+        )
+    ),
+    fMax_
+    (
+        dict.getCheckOrDefault<label>
+        (
+            "fMax",
+            pTraits<label>::max,
+            labelMinMax::ge(fMin_ + 1)
+        )
+    ),
+    nComps_(Zero),
+    nSnap_(Zero),
+    currIndex_(Zero),
+    sortLimiter_(500),
+    absTol_(1e-2),
+    relTol_(1e-3),
+    minBasis_(Zero),
+    dt_(Zero),
+    minMagEVal_(Zero),
+    zNorm_(Zero),
+    ezNorm_(Zero),
+    z_(),
+    ez_(),
+    X1_(),
+    Qz_(),
+    Gz_(),
+    QzUH_(),
+    QzLH_(),
+    RxInv_(),
+    Ap_(),
+    oEVecs_(),
+    oEVals_(),
+    oAmps_(),
+    oFreqs_(),
+    iFreqs_(),
+    oMags_(),
+    iMags_()
+{
+    Info<< nl
+        << "    ### This STDMD release is the beta release ###" << nl
+        << "    Therefore small-to-medium changes in input/output interfaces "
+        << "and internal structures should be expected in the next versions."
+        << endl;
+
+    // Check if varying or fixed time-step computation
+    if (runTime.isAdjustTimeStep())
+    {
+        WarningInFunction
+            << "  # STDMD: Viable only for fixed time-step computations. #"
+            << endl;
+    }
+
+    // Check if mesh topology changing
+    if (mesh_.topoChanging())
+    {
+        FatalErrorInFunction
+            << "  # STDMD: Available only for non-changing mesh topology. #"
+            << abort(FatalError);
+    }
+
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::functionObjects::STDMD::read(const dictionary& dict)
+{
+    fvMeshFunctionObject::read(dict);
+
+    testEigen_ = dict.getOrDefault<bool>("testEigen", false);
+
+    if (testEigen_)
+    {
+        dumpEigen_ = dict.getOrDefault<bool>("dumpEigen", false);
+    }
+
+    sortLimiter_ =
+        dict.getCheckOrDefault<scalar>
+        (
+            "sortLimiter",
+            500,
+            scalarMinMax::ge(1)
+        );
+
+    absTol_ =
+        dict.getCheckOrDefault<scalar>
+        (
+            "absTol",
+            1e-2,
+            scalarMinMax::ge(0)
+        );
+
+    relTol_ =
+        dict.getCheckOrDefault<scalar>
+        (
+            "relTol",
+            1e-3,
+            scalarMinMax::ge(0)
+        );
+
+    minBasis_ =
+        dict.getCheckOrDefault<scalar>
+        (
+            "minBasis",
+            1e-8,
+            scalarMinMax::ge(0)
+        );
+
+    dt_ =
+        dict.getCheckOrDefault<scalar>
+        (
+            "stdmdInterval",
+            (
+                dict.getCheck<label>("executeInterval", labelMinMax::ge(1))
+               *mesh_.time().deltaT().value()
+            ),
+            scalarMinMax::ge(0)
+        );
+
+    minMagEVal_ =
+        dict.getCheckOrDefault<scalar>
+        (
+            "minEVal",
+            1e-8,
+            scalarMinMax::ge(0)
+        );
+
+    writeToFile_ = dict.getOrDefault<bool>("writeToFile", true);
+
+    Info<< nl << name() << ":" << nl
+        << tab << "# Input is read for field = "
+        << fieldName_  << " #" << nl << endl;
+
+    return true;
+}
+
+
+bool Foam::functionObjects::STDMD::execute()
+{
+    Log << type() << " " << name() << " execute:" << endl;
+
+    // STDMD incremental orthonormal basis update (K:Fig. 15)
+    snapshot();
+
+    if (currIndex_ == 1)
+    {
+        initBasis();
+    }
+
+    if (1 < currIndex_)
+    {
+        GramSchmidt();
+
+        // Check basis for z_ and, if necessary, expand Qz_ and Gz_
+        zNorm_ = parnorm(z_);
+        ezNorm_ = parnorm(ez_);
+
+        if (minBasis_ < ezNorm_/zNorm_)
+        {
+            expandBasis();
+        }
+
+        updateGz();
+
+        // Compress the orthonormal basis if required
+        if (maxRank_ < Qz_.n())
+        {
+            compressBasis();
+        }
+    }
+    ++currIndex_;
+
+    Log<< tab << "# " << name() << ":"
+        << " Execution index = " << currIndex_
+        << " for field = " << fieldName_ << " #"
+        << endl;
+
+    return true;
+}
+
+
+bool Foam::functionObjects::STDMD::write()
+{
+    Log << type() << " " << name() << " write:" << endl;
+
+    if (currIndex_ < 2)
+    {
+        WarningInFunction
+            << "  # STDMD needs at least three snapshots to produce output #"
+            << nl
+            << "  # Only " << currIndex_ + 1 << " snapshots are available #"
+            << nl
+            << "  # Skipping STDMD output calculation and write #"
+            << endl;
+
+        return false;
+    }
+
+    // STDMD mode evaluation (K:Fig. 16)
+    calcOutput();
+
+    // Restart STDMD incremental orthonormal basis update
+    initialised_ = false;
+
+    mesh_.time().printExecutionTime(Info);
+
+    return true;
+}
+
+
+// ************************************************************************* //
diff --git a/src/functionObjects/field/STDMD/STDMD.H b/src/functionObjects/field/STDMD/STDMD.H
new file mode 100644
index 0000000000..8133004baf
--- /dev/null
+++ b/src/functionObjects/field/STDMD/STDMD.H
@@ -0,0 +1,644 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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::functionObjects::STDMD
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    (Beta Release) STDMD (i.e. Streaming Total Dynamic Mode Decomposition) is
+    a variant of a data-driven dimensionality reduction method.
+
+    STDMD is being used as a mathematical post-processing tool to compute
+    a set of dominant modes out of a given flow (or dataset) each of which is
+    associated with a constant frequency and decay rate, so that dynamic
+    features of a given flow may become interpretable, and tractable.
+    Among other Dynamic Mode Decomposition (DMD) variants, STDMD is presumed
+    to provide the general DMD method capabilities alongside economised and
+    feasible memory and CPU usage.
+
+    The code implementation corresponds to Figs. 15-16 of the first citation
+    below, more broadly to Section 2.4.
+
+    References:
+    \verbatim
+    STDMD and mode-sorting algorithms (tags:K, HRDC, KZ, HWR):
+        Kiewat, M. (2019).
+        Streaming modal decomposition approaches for vehicle aerodynamics.
+        PhD thesis. Munich: Technical University of Munich.
+        URL:mediatum.ub.tum.de/doc/1482652/1482652.pdf
+
+        Hemati, M. S., Rowley, C. W., Deem, E. A., & Cattafesta, L. N. (2017).
+        De-biasing the dynamic mode decomposition for applied Koopman
+        spectral analysis of noisy datasets.
+        Theoretical and Computational Fluid Dynamics, 31(4), 349-368.
+        DOI:10.1007/s00162-017-0432-2
+
+        Kou, J., & Zhang, W. (2017).
+        An improved criterion to select dominant modes from dynamic mode
+        decomposition.
+        European Journal of Mechanics-B/Fluids, 62, 109-129.
+        DOI:10.1016/j.euromechflu.2016.11.015
+
+        Hemati, M. S., Williams, M. O., & Rowley, C. W. (2014).
+        Dynamic mode decomposition for large and streaming datasets.
+        Physics of Fluids, 26(11), 111701.
+        DOI:10.1063/1.4901016
+
+    Parallel classical Gram-Schmidt process (tag:Ka):
+        Katagiri, T. (2003).
+        Performance evaluation of parallel Gram-Schmidt re-orthogonalization
+        methods.
+        In: Palma J. M. L. M., Sousa A. A., Dongarra J., Hernández V. (eds)
+        High Performance Computing for Computational Science — VECPAR 2002.
+        Lecture Notes in Computer Science, vol 2565, p. 302-314.
+        Berlin, Heidelberg: Springer.
+        DOI:10.1007/3-540-36569-9_19
+
+    Parallel direct tall-skinny QR decomposition (tags:BGD, DGHL):
+        Benson, A. R., Gleich, D. F., & Demmel, J. (2013).
+        Direct QR factorizations for tall-and-skinny matrices in MapReduce
+        architectures.
+        2013 IEEE International Conference on Big Data.
+        DOI:10.1109/bigdata.2013.6691583
+
+        Demmel, J., Grigori, L., Hoemmen, M., & Langou, J. (2012).
+        Communication-optimal parallel and sequential QR and LU
+        factorizations.
+        SIAM Journal on Scientific Computing, 34(1), A206-A239.
+        DOI:10.1137/080731992
+
+    DMD properties:
+        Brunton S. L. (2018).
+        Dynamic mode decomposition overview.
+        Seattle, Washington: University of Washington.
+        youtu.be/sQvrK8AGCAo (Retrieved:24-04-20)
+    \endverbatim
+
+    Operands:
+    \table
+      Operand      | Type              | Location
+      input        | {vol,surface}\<Type\>Field <!--
+               --> | $FOAM_CASE/\<time\>/\<inpField\>
+      output file  | dat                        <!--
+               --> | $FOAM_CASE/postProcessing/\<FO\>/\<time\>/\<file\>(s)
+      output field | volScalarField(s) | $FOAM_CASE/\<time\>/\<outField\>(s)
+    \endtable
+
+    where Type={Scalar,SphericalTensor,SymmTensor,Tensor}.
+
+    Output fields:
+    \verbatim
+      modeReal<modeIndex><field> | Real part of a mode field
+      modeImag<modeIndex><field> | Imaginary part of a mode field
+    \endverbatim
+
+    Output files:
+    \verbatim
+      uSTDMD.dat                 | Unfiltered STDMD output
+      STDMD.dat                  | Filtered STDMD output
+    \endverbatim
+
+    wherein for each mode, the following quantities are output into files:
+    \verbatim
+      Frequency
+      Magnitude
+      Amplitude (real part)
+      Amplitude (imaginary part)
+      Eigenvalue (real part)
+      Eigenvalue (imaginary part)
+    \endverbatim
+
+Note
+    Operations on boundary fields, e.g. \c wallShearStress, are currently not
+    available.
+
+Usage
+    Minimal example by using \c system/controlDict.functions:
+    \verbatim
+    STDMD1
+    {
+        // Mandatory entries (unmodifiable)
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               <inpField>;
+
+        // Conditional mandatory entries (unmodifiable)
+        // either of the below
+        stdmdInterval       5.5;
+        executeInterval     10;
+
+        // Optional entries (unmodifiable)
+        modeSorter          kiewat;
+        nModes              50;
+        maxRank             50;
+        nGramSchmidt        5;
+        fMin                0;
+        fMax                1000000000;
+
+        // Optional entries (run-time modifiable, yet not recommended)
+        testEigen           false;
+        dumpEigen           false;
+        minBasis            0.00000001;
+        minEVal             0.00000001;
+        absTol              0.001;
+        relTol              0.0001;
+        sortLimiter         500;
+
+        // Optional (inherited) entries
+        ...
+    }
+    \endverbatim
+
+    where the entries mean:
+    \table
+      Property     | Description                        | Type | Req'd | Dflt
+      type         | Type name: STDMD                   | word |  yes  | -
+      libs         | Library name: fieldFunctionObjects | word |  yes  | -
+      field        | Name of the operand field          | word |  yes  | -
+      stdmdInterval | STDMD time-step size [s]   | scalar| conditional | <!--
+                  --> executeInterval*(current time-step of the simulation)
+      modeSorter   | Mode-sorting algorithm variant     | word | no  | firstSnap
+      nModes | Number of output modes in input freq range | label | no | GREAT
+      maxRank  | Max columns in accumulated matrices      | label | no | GREAT
+      nGramSchmidt | Number of Gram-Schmidt iterations    | label | no | 5
+      fMin         | Min (non-negative) output frequency  | label | no | 0
+      fMax         | Max output frequency                 | label | no | GREAT
+      testEigen    | Flag to verify eigendecompositions   | bool  | no | false
+      dumpEigen    | Flag to log operands of eigendecomps | bool  | no | false
+      minBasis | Orthogonal basis expansion threshold     | scalar| no | 1e-8
+      minEVal  | Min EVal for below EVals are omitted     | scalar| no | 1e-8
+      absTol   | Min abs tol in eigendecomposition tests  | scalar| no | 1e-4
+      relTol   | Relative tol in eigendecomposition tests | scalar| no | 1e-6
+      sortLimiter | Maximum allowable magnitude for <!--
+               -->  mag(eigenvalue)*(number of STDMD steps) to be used in <!--
+               -->  modeSorter={kiewat,kouZhang} to avoid overflow errors <!--
+               -->                                        | scalar | no | 500.0
+    \endtable
+
+    Options for the \c modeSorter entry:
+    \verbatim
+      kiewat    | Modified weighted amplitude scaling method
+      kouZhang  | Weighted amplitude scaling method
+      firstSnap | Method of first snapshot amplitude magnitude
+    \endverbatim
+
+    The inherited entries are elaborated in:
+     - \link functionObject.H \endlink
+     - \link writeFile.H \endlink
+
+    Usage by \c postProcess utility is not available.
+
+Note
+    - To specify the STDMD time-step size (not necessarily equal to the
+    time step of the simulation), entries of either \c stdmdInterval or
+    \c executeInterval must be available (highest to lowest precedence). While
+    \c stdmdInterval allows users to directly specify the STDMD time-step size
+    in seconds, in absence of \c stdmdInterval, for convenience,
+    \c executeInterval allows users to compute the STDMD time-step internally
+    by multiplying itself with the current time-step size of the simulation.
+    - Limitation: Restart is currently not available since intermediate writing
+    of STDMD matrices are not supported.
+    - Limitation: Non-physical input (e.g. full-zero fields) may upset STDMD.
+    - Warning: DMD is an active research area at the time of writing; therefore,
+    there would be cases whereat oddities might be encountered.
+    - Warning: This STDMD release is the \b beta release; therefore,
+    small-to-medium changes in input/output interfaces and internal structures
+    should be expected in the next versions.
+    - Warning: In \c modeSorter algorithms of \c kiewat and \c kouZhang, there
+    exists a function of \f$power(x,y)\f$ where \c x is the magnitude of an
+    eigenvalue, and \c y is the number of STDMD snapshots. This function poses
+    a risk of overflow errors since, for example, if \c x ends up above 1.5 with
+    500 snapshots or more, this function automatically throws the floating point
+    error meaning overflow. Therefore, the domain-range of this function is
+    heuristically constrained by the optional entry \c sortLimiter which skips
+    the evaluation of this function for a given
+    mag(eigenvalue)*(no. of STDMD steps), i.e. x*y, whose magnitude is larger
+    than \c sortLimiter.
+
+See also
+    - Foam::functionObjects::fvMeshFunctionObject
+    - Foam::functionObjects::writeFile
+    - ExtendedCodeGuide::functionObjects::field::STDMD
+
+SourceFiles
+    STDMD.C
+    STDMDTemplates.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef functionObjects_STDMD_H
+#define functionObjects_STDMD_H
+
+#include "fvMeshFunctionObject.H"
+#include "writeFile.H"
+#include "EigenMatrix.H"
+#include "QRMatrix.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+
+/*---------------------------------------------------------------------------*\
+                              Class STDMD Declaration
+\*---------------------------------------------------------------------------*/
+
+class STDMD
+:
+    public fvMeshFunctionObject,
+    public writeFile
+{
+
+    typedef SquareMatrix<scalar> SMatrix;
+    typedef SquareMatrix<complex> SCMatrix;
+    typedef RectangularMatrix<scalar> RMatrix;
+    typedef RectangularMatrix<complex> RCMatrix;
+
+
+    // Private Enumerations
+
+        //- Options for the mode-sorting algorithm
+        enum modeSorterType
+        {
+            KIEWAT,          //!< "Modified weighted amplitude scaling method"
+            KOU_ZHANG,       //!< "Weighted amplitude scaling method"
+            FIRST_SNAPSHOT   //!< "Method of first snapshot amplitude magnitude"
+        };
+
+        //- Names for modeSorterType
+        static const Enum<modeSorterType> modeSorterTypeNames;
+
+
+    // Private Data
+
+        //- Mode-sorting algorithm (default=modeSorterType::FIRST_SNAPSHOT)
+        const enum modeSorterType modeSorter_;
+
+        //- Name of the operand volume or surface field
+        const word fieldName_;
+
+        //- Flag: First execution-step initialisation
+        bool initialised_;
+
+        //- Flag: Verify eigendecompositions by using theoretical relations
+        bool testEigen_;
+
+        //- Flag: Write operands of eigendecompositions to log
+        //  To activate it, testEigen=true
+        bool dumpEigen_;
+
+        //- Number of output modes within input frequency range
+        //- starting from the most energetic mode
+        const label nModes_;
+
+        //- Maximum allowable matrix column for Qz_ and Gz_
+        //  Qz_ is assumed to always have full-rank, thus Qz_.n() = rank
+        const label maxRank_;
+
+        //- Number of maximum iterations of the classical Gram-Schmidt procedure
+        const label nGramSchmidt_;
+
+        //- Min frequency: Output only entries corresponding to freqs >= fMin
+        const label fMin_;
+
+        //- Max frequency: Output only entries corresponding to freqs <= fMax
+        const label fMax_;
+
+        //- Number of base components of input field, e.g. 3 for vector
+        label nComps_;
+
+        //- Number of elements in a snapshot
+        //  A snapshot is an input dataset to be processed per execution-step
+        label nSnap_;
+
+        //- Current execution-step index of STDMD,
+        //- not necessarily that of the simulation
+        label currIndex_;
+
+        //- Maximum allowable magnitude for mag(eigenvalue)*(number of
+        //- STDMD steps) to be used in modeSorter={kiewat,kouZhang} to avoid
+        //- overflow errors
+        scalar sortLimiter_;
+
+        //- Min absolute tolerance being used in eigendecomposition tests
+        scalar absTol_;
+
+        //- Relative tolerance being used in eigendecomposition tests
+        scalar relTol_;
+
+        //- Min value to execute orthogonal basis expansion of Qz_ and Gz_
+        scalar minBasis_;
+
+        //- STDMD time-step size that equals to
+        //- (executeInterval of STDMD)*(deltaT of simulation) [s]
+        scalar dt_;
+
+        //- Min EVal magnitude threshold below where EVals are omitted
+        scalar minMagEVal_;
+
+        //- L2-norm of column vector z_
+        scalar zNorm_;
+
+        //- L2-norm of column vector ez_
+        scalar ezNorm_;
+
+        //- Augmented snapshot matrix (effectively a column vector) (K:Eq. 60)
+        //  Upper half z_ = current-time snapshot slot
+        //  Lower half z_ = previous-time snapshot slot
+        RMatrix z_;
+
+        //- Working copy of the augmented snapshot matrix z_
+        //- being used in the classical Gram-Schmidt process
+        RMatrix ez_;
+
+        //- First-processed snapshot required by the mode-sorting
+        //- algorithms at the final output computations (K:p. 43)
+        RMatrix X1_;
+
+        //- Accumulated-in-time unitary similarity matrix produced by the
+        //- orthonormal decomposition of the augmented snapshot matrix z_
+        //  (K:Eq. 60)
+        RMatrix Qz_;
+
+        //- Accumulated-in-time (squared) upper triangular matrix produced by
+        //- the orthonormal decomposition of the augmented snapshot matrix z_
+        //  (K:Eq. 64)
+        SMatrix Gz_;
+
+        //- Upper half of Qz_
+        RMatrix QzUH_;
+
+        //- Lower half of Qz_
+        RMatrix QzLH_;
+
+        //- Moore-Penrose pseudo-inverse of R produced by
+        //- the QR decomposition of the last time-step QzUH_
+        RMatrix RxInv_;
+
+        //- Projected STDMD operator (K:Eq. 78)
+        SMatrix Ap_;
+
+        //- Output eigenvectors
+        RCMatrix oEVecs_;
+
+        //- Output eigenvalues
+        List<complex> oEVals_;
+
+        //- Output amplitudes
+        List<complex> oAmps_;
+
+        //- Output (non-negative) frequencies
+        List<scalar> oFreqs_;
+
+        //- Indices of oFreqs_ where freqs are
+        //- non-negative and within [fMin_, fMax_]
+        DynamicList<label> iFreqs_;
+
+        //- Output (descending) magnitudes of (complex) amplitudes
+        List<scalar> oMags_;
+
+        //- Indices of oMags_
+        List<label> iMags_;
+
+
+    // Private Member Functions
+
+        // Process
+
+        //- Move previous-time snapshot into previous-time slot in z_
+        //- and copy new current-time snapshot into current-time slot in z_
+        template<class GeoFieldType>
+        bool getSnapshot();
+
+        //- Get the input field type to be processed by snapshot()
+        template<class Type>
+        bool getSnapshotType();
+
+        //- Get the number of base components of input field
+        template<class GeoFieldType>
+        bool getComps();
+
+        //- Return (parallel) L2-norm of a given column vector
+        scalar parnorm(const RMatrix& colVector) const;
+
+        //- Move the current-time snapshot into the previous-time snapshot in z_
+        //- and copy the new field into the current-time snapshot
+        void snapshot();
+
+        //- Initialise all working matrices at the first execution-step
+        void init();
+
+        //- Initialise Qz_, Gz_ (both require the first two snapshots) and X1_
+        void initBasis();
+
+        //- Execute (parallel) classical Gram-Schmidt
+        //- process to orthonormalise ez_ (Ka:Fig. 5)
+        void GramSchmidt();
+
+        //- Expand orthonormal bases Qz_ and Gz_ by stacking a column
+        //- (ez_/ezNorm_) to Qz_, and a row (Zero) and column (Zero)
+        //- to Gz_ if (minBasis_ < ezNorm_/zNorm_)
+        void expandBasis();
+
+        //- Update Gz_ before the potential orthonormal basis compression
+        void updateGz();
+
+        //- Compress orthonormal basis for Qz_ and Gz_ if (maxRank_ < Qz_.n())
+        void compressBasis();
+
+
+        // Postprocess
+
+        //- Return a new List containing elems of List at indices
+        template<class Type>
+        void filterIndexed
+        (
+            List<Type>& lst,
+            const UList<label>& indices
+        );
+
+        //- Return a new Matrix containing columns of Matrix at indices
+        template<class MatrixType>
+        void filterIndexed
+        (
+            MatrixType& lst,
+            const UList<label>& indices
+        );
+
+        //- Compute global Ap (K:Eq. 78)
+        void calcAp();
+
+        //- Compute eigenvalues and eigenvectors
+        void calcEigen();
+
+        //- Weak-type floating-point comparison
+        //  bit.ly/2Trdbgs (Eq. 2), and PEP-485
+        bool close
+        (
+            const scalar s1,
+            const scalar s2,
+            const scalar absTol = 0,   //<! comparisons near zero
+            const scalar relTol = 1e-8 //<! e.g. vals the same within 8 decimals
+        ) const;
+
+        //- Test real/complex eigenvalues by using
+        //- the theoretical relation: (sum(eigenvalues) - trace(A) ~ 0)
+        void testEigenvalues
+        (
+            const SquareMatrix<scalar>& A,
+            const DiagonalMatrix<scalar>& EValsRe
+        ) const;
+
+        //- Test real eigenvectors by using the theoretical relation:
+        //- ((A & EVec - EVal*EVec).norm() ~ 0)
+        void testEigenvectors
+        (
+            const SquareMatrix<scalar>& A,
+            const DiagonalMatrix<scalar>& EValsRe,
+            const SquareMatrix<scalar>& EVecs
+        ) const;
+
+        //- Test complex eigenvectors by using the theoretical relation:
+        //- ((A & EVec - EVal*EVec).norm() ~ 0)
+        void testEigenvectors
+        (
+            const SquareMatrix<scalar>& A,
+            const List<complex>& EVals,
+            const RectangularMatrix<complex>& EVecs
+        ) const;
+
+        //- Remove any eigenvalues whose magnitude is smaller than
+        //- minMagEVal_ while keeping the order of elements the same
+        void filterEVals();
+
+        //- Compute and filter frequencies (K:Eq. 81)
+        void calcFreqs();
+
+        //- Compute frequency indices
+        //  Locate indices where oFreqs_ are
+        //  in [fMin_, fMax_], and store them in iFreqs_ indices
+        void calcFreqI();
+
+        //- Compute amplitudes
+        void calcAmps();
+
+        //- Compute magnitudes
+        //  Includes advanced sorting methods using
+        //  the chosen weighted amplitude scaling method
+        void calcMags();
+
+        //- Compute the ordered magnitude indices
+        void calcMagI();
+
+        //- Compute modes
+        void calcModes();
+
+        //- Eigenvalue weighted amplitude scaling (KZ:Eq. 33)
+        //- Modified eigenvalue weighted amplitude scaling (K)
+        scalar sorter
+        (
+            const List<scalar>& weight,
+            const complex& amplitude,
+            const complex& eval,
+            const scalar modeNorm
+        ) const;
+
+        //- Output file header information
+        virtual void writeFileHeader(Ostream& os) const;
+
+        //- Filter objects according to iFreqs_ and iMags_
+        void filterOutput();
+
+        //- Write unfiltered/filtered data
+        void writeOutput(OFstream& os) const;
+
+        //- Compute STDMD output
+        void calcOutput();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("STDMD");
+
+
+    // Constructors
+
+        //- No default construct
+        STDMD() = delete;
+
+        //- Construct from Time and dictionary
+        STDMD
+        (
+            const word& name,
+            const Time& runTime,
+            const dictionary& dict
+        );
+
+        //- No copy construct
+        STDMD(const STDMD&) = delete;
+
+        //- No copy assignment
+        void operator=(const STDMD&) = delete;
+
+
+    //- Destructor
+    virtual ~STDMD() = default;
+
+
+    // Member Functions
+
+        //- Read STDMD settings
+        virtual bool read(const dictionary&);
+
+        //- Execute STDMD
+        virtual bool execute();
+
+        //- Write STDMD output
+        virtual bool write();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace functionObjects
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "STDMDTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/functionObjects/field/STDMD/STDMDTemplates.C b/src/functionObjects/field/STDMD/STDMDTemplates.C
new file mode 100644
index 0000000000..e32bb2ddc3
--- /dev/null
+++ b/src/functionObjects/field/STDMD/STDMDTemplates.C
@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+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 "volFields.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class GeoFieldType>
+bool Foam::functionObjects::STDMD::getSnapshot()
+{
+    if (!initialised_)
+    {
+        init();
+    }
+
+    // Move previous-time snapshot into previous-time slot in z_
+    // Effectively moves the lower half of z_ to its upper half
+    std::rotate(z_.begin(), z_.begin() + nSnap_, z_.end());
+
+    // Copy new current-time snapshot into current-time slot in z_
+    // Effectively copies the new field elements into the lower half of z_
+    const GeoFieldType& Field = lookupObject<GeoFieldType>(fieldName_);
+    const label nField = Field.size();
+
+    for (direction dir = 0; dir < nComps_; ++dir)
+    {
+        z_.subColumn(0, nSnap_ + dir*nField, nField) = Field.component(dir);
+    }
+
+    return true;
+}
+
+
+template<class Type>
+bool Foam::functionObjects::STDMD::getSnapshotType()
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> SurfaceFieldType;
+
+    if (foundObject<VolFieldType>(fieldName_))
+    {
+        return getSnapshot<VolFieldType>();
+    }
+    else if (foundObject<SurfaceFieldType>(fieldName_))
+    {
+        return getSnapshot<SurfaceFieldType>();
+    }
+
+    return false;
+}
+
+
+template<class Type>
+bool Foam::functionObjects::STDMD::getComps()
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> SurfaceFieldType;
+
+    if (foundObject<VolFieldType>(fieldName_))
+    {
+        nComps_ = pTraits<typename VolFieldType::value_type>::nComponents;
+        return true;
+    }
+    else if (foundObject<SurfaceFieldType>(fieldName_))
+    {
+        nComps_ = pTraits<typename SurfaceFieldType::value_type>::nComponents;
+        return true;
+    }
+
+    return false;
+}
+
+
+template<class Type>
+void Foam::functionObjects::STDMD::filterIndexed
+(
+    List<Type>& lst,
+    const UList<label>& indices
+)
+{
+    // Elems within [a, b]
+    List<Type> lstWithin(indices.size());
+
+    // Copy if frequency of elem is within [a, b]
+    label j = 0;
+    for (const auto& i : indices)
+    {
+        lstWithin[j] = lst[i];
+        ++j;
+    }
+    lst.transfer(lstWithin);
+}
+
+
+template<class MatrixType>
+void Foam::functionObjects::STDMD::filterIndexed
+(
+    MatrixType& mat,
+    const UList<label>& indices
+)
+{
+    // Elems within [a, b]
+    MatrixType matWithin(labelPair(mat.m(), indices.size()));
+
+    // Copy if frequency of elem is within [a, b]
+    label j = 0;
+    for (const auto& i : indices)
+    {
+        matWithin.subColumn(j) = mat.subColumn(i);
+        ++j;
+    }
+    mat.transfer(matWithin);
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/0.orig/U b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/0.orig/U
new file mode 100644
index 0000000000..6e2a24d9fa
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/0.orig/U
@@ -0,0 +1,51 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volVectorField;
+    object      U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0.012984 0 0);
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           $internalField;
+    }
+
+    outlet
+    {
+        type            zeroGradient;
+    }
+
+    topAndBottom
+    {
+        type            symmetry;
+    }
+
+    "left|right"
+    {
+        type            empty;
+    }
+
+    cylinder
+    {
+        type            noSlip;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/0.orig/p b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/0.orig/p
new file mode 100644
index 0000000000..1b6348bf3d
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/0.orig/p
@@ -0,0 +1,51 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            zeroGradient;
+    }
+
+    outlet
+    {
+        type            fixedValue;
+        value           $internalField;
+    }
+
+    topAndBottom
+    {
+        type            symmetry;
+    }
+
+    "left|right"
+    {
+        type            empty;
+    }
+
+    cylinder
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allclean b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allclean
new file mode 100755
index 0000000000..41459e3ce5
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allclean
@@ -0,0 +1,12 @@
+#!/bin/sh
+cd "${0%/*}" || exit                                # Run from this directory
+. ${WM_PROJECT_DIR:?}/bin/tools/CleanFunctions      # Tutorial clean functions
+#------------------------------------------------------------------------------
+
+cleanCase0
+
+rm -rf dynamicCode
+rm -rf constant/coarseMesh
+rm -f system/coarseMesh/decomposeParDict
+
+#------------------------------------------------------------------------------
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allrun b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allrun
new file mode 100755
index 0000000000..0307797569
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allrun
@@ -0,0 +1,25 @@
+#!/bin/sh
+cd "${0%/*}" || exit                                # Run from this directory
+. ${WM_PROJECT_DIR:?}/bin/tools/RunFunctions        # Tutorial run functions
+#------------------------------------------------------------------------------
+
+./Allrun.pre
+
+runApplication decomposePar
+
+runParallel renumberMesh -overwrite
+
+cp -f system/decomposeParDict system/coarseMesh
+
+runApplication -s coarseMesh decomposePar -region coarseMesh
+
+runParallel -s coarseMesh renumberMesh -overwrite -region coarseMesh
+
+runParallel $(getApplication)
+
+runParallel -s main redistributePar -reconstruct -latestTime
+
+runParallel -s coarseMesh redistributePar -reconstruct \
+    -region coarseMesh -time '50,100,200'
+
+#------------------------------------------------------------------------------
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allrun.pre b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allrun.pre
new file mode 100755
index 0000000000..bc21f038db
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/Allrun.pre
@@ -0,0 +1,20 @@
+#!/bin/sh
+cd "${0%/*}" || exit                                # Run from this directory
+. ${WM_PROJECT_DIR:?}/bin/tools/RunFunctions        # Tutorial run functions
+#------------------------------------------------------------------------------
+
+runApplication -s coarseMesh blockMesh -dict system/blockMeshDict.coarse
+
+runApplication snappyHexMesh -overwrite
+
+mkdir -p constant/coarseMesh
+
+mv -f constant/polyMesh constant/coarseMesh
+
+runApplication -s main blockMesh -dict system/blockMeshDict.main
+
+runApplication mirrorMesh -overwrite
+
+restore0Dir
+
+#------------------------------------------------------------------------------
\ No newline at end of file
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/constant/transportProperties b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/constant/transportProperties
new file mode 100644
index 0000000000..ae22a9bc6d
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/constant/transportProperties
@@ -0,0 +1,23 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      transportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+transportModel  Newtonian;
+
+nu              1.558e-5;
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/constant/turbulenceProperties b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/constant/turbulenceProperties
new file mode 100644
index 0000000000..e0b42c8d7d
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/constant/turbulenceProperties
@@ -0,0 +1,21 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType laminar;
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/blockMeshDict.coarse b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/blockMeshDict.coarse
new file mode 100644
index 0000000000..794d0060d2
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/blockMeshDict.coarse
@@ -0,0 +1,74 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+scale    1;
+
+x0       -0.16;
+x1       0.8;
+y0       -0.24;
+y1       0.24;
+z0       -0.00375;
+z1       0.00375;
+
+nx       90;
+ny       60;
+nz       1;
+
+vertices
+(
+    ($x0 $y0 $z0)
+    ($x1 $y0 $z0)
+    ($x1 $y1 $z0)
+    ($x0 $y1 $z0)
+    ($x0 $y0 $z1)
+    ($x1 $y0 $z1)
+    ($x1 $y1 $z1)
+    ($x0 $y1 $z1)
+);
+
+blocks
+(
+    hex (0 1 2 3 4 5 6 7) ($nx $ny $nz) simpleGrading (1 1 1)
+);
+
+edges
+(
+);
+
+boundary
+(
+    allPatches
+    {
+        type     empty;
+        inGroups (allPatches);
+        faces
+        (
+            (3 7 6 2)
+            (1 5 4 0)
+            (0 4 7 3)
+            (2 6 5 1)
+            (0 3 2 1)
+            (4 5 6 7)
+        );
+    }
+);
+
+mergePatchPairs
+(
+);
+
+// ************************************************************************* //
+
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/blockMeshDict.main b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/blockMeshDict.main
new file mode 100644
index 0000000000..1ea36be199
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/blockMeshDict.main
@@ -0,0 +1,277 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+scale     1;
+
+R         0.06; // Cylinder radius
+x0        #eval{ 0.5*$R };
+x2        #eval{ 2.38732*$R };
+x3        #eval{ 10.0*$R };
+xOutlet   #eval{ 18.6667*$R };
+xInlet    #eval{ -10.125*$R };
+
+RsinPi8   #eval{ $R*sin(0.125*pi()) };
+RsinPi8n  #eval{ -$RsinPi8 };
+RcosPi8   #eval{ $R*cos(0.125*pi()) };
+RcosPi8n  #eval{ -$RcosPi8 };
+RsinPi4   #eval{ $R*sin(0.25*pi()) };
+
+x2sinPi8  #eval{ $x2*sin(0.125*pi()) };
+x2sinPi8n #eval{ -$x2sinPi8 };
+x2cosPi8  #eval{ $x2*cos(0.125*pi()) };
+x2cosPi8n #eval{ -$x2cosPi8 };
+x2sinPi4  #eval{ $x2*sin(0.25*pi()) };
+
+z0        -0.0075;
+z1        0.0075;
+nz        1;
+
+
+vertices #codeStream
+{
+    codeInclude
+    #{
+        #include "pointField.H"
+    #};
+
+    code
+    #{
+        pointField points(19);
+        points[0] = point($R, 0, $z0);
+        points[1] = point($x2, 0, $z0);
+        points[2] = point($x3, 0, $z0);
+        points[3] = point($x3, $x2sinPi4, $z0);
+        points[4] = point($x2sinPi4, $x2sinPi4, $z0);
+        points[5] = point($RsinPi4, $RsinPi4, $z0);
+        points[6] = point($x3, $x3, $z0);
+        points[7] = point($x2sinPi4, $x3, $z0);
+
+        // Mirror +x points to -x side
+        points[11] = point(-points[0].x(), points[0].y(), points[0].z());
+        points[12] = point(-points[1].x(), points[1].y(), points[1].z());
+        points[13] = point(-points[2].x(), points[2].y(), points[2].z());
+        points[14] = point(-points[3].x(), points[3].y(), points[3].z());
+        points[15] = point(-points[4].x(), points[4].y(), points[4].z());
+        points[16] = point(-points[5].x(), points[5].y(), points[5].z());
+        points[17] = point(-points[6].x(), points[6].y(), points[6].z());
+        points[18] = point(-points[7].x(), points[7].y(), points[7].z());
+
+        // Points on the y-z-plane
+        points[8] = point(0, $x3, $z0);
+        points[9] = point(0, $x2, $z0);
+        points[10] = point(0, $R, $z0);
+
+        // Mirror -z points to +z side
+        label sz = points.size();
+        points.setSize(2*sz);
+        for (label i = 0; i < sz; ++i)
+        {
+            const point& pt = points[i];
+            points[i + sz] = point(pt.x(), pt.y(), $z1);
+        }
+
+        // Add an inner cylinder
+        sz = points.size();
+        label nAdd = 6;
+        points.setSize(sz + nAdd);
+
+        // Points within the inner cylinder
+        points[sz] = point(0, 0, $z0);
+        points[sz + 1] = point(0, $x0, $z0);
+        points[sz + 2] = point($x0, $x0, $z0);
+        points[sz + 3] = point($x0, 0, $z0);
+
+        // Mirror points from +x side to -x side
+        points[sz + 4] =
+            point(-points[sz + 2].x(), points[sz + 2].y(), points[sz + 2].z());
+        points[sz + 5] =
+            point(-points[sz + 3].x(), points[sz + 3].y(), points[sz + 3].z());
+
+        // Mirror -z points to +z side
+        sz = points.size();
+        points.setSize(sz + nAdd);
+        for (label i = 0; i < nAdd; ++i)
+        {
+            const point& pt = points[i+sz-nAdd];
+            points[i+sz] = point(pt.x(), pt.y(), $z1);
+        }
+
+        // Add downstream and upstream blocks
+        sz = points.size();
+        nAdd = 6;
+        points.setSize(sz + nAdd);
+
+        // Points on outlet
+        points[sz] = point($xOutlet, 0, $z0);
+        points[sz + 1] = point($xOutlet, $x3, $z0);
+        points[sz + 4] = point($xOutlet, $x2sinPi4, $z0);
+
+        // Points on inlet
+        points[sz + 2] = point($xInlet, 0, $z0);
+        points[sz + 3] = point($xInlet, $x3, $z0);
+        points[sz + 5] = point($xInlet, $x2sinPi4, $z0);
+
+        // Mirror -z points to +z side
+        sz = points.size();
+        points.setSize(sz + nAdd);
+        for (label i = 0; i < nAdd; ++i)
+        {
+            const point& pt = points[i + sz - nAdd];
+            points[i + sz] = point(pt.x(), pt.y(), $z1);
+        }
+
+        os  << points;
+    #};
+};
+
+
+blocks
+(
+    hex ( 5  4  9 10 24 23 28 29) (16 15 $nz) simpleGrading (1.6 1 1)
+    hex ( 0  1  4  5 19 20 23 24) (16 15 $nz) simpleGrading (1.6 1 1)
+    hex ( 1  2  3  4 20 21 22 23) (61 15 $nz) simpleGrading (1 1 1)
+    hex ( 4  3  6  7 23 22 25 26) (61 61 $nz) simpleGrading (1 1 1)
+    hex ( 9  4  7  8 28 23 26 27) (15 61 $nz) simpleGrading (1 1 1)
+    hex (15 16 10  9 34 35 29 28) (16 15 $nz) simpleGrading (0.625 1 1)
+    hex (12 11 16 15 31 30 35 34) (16 15 $nz) simpleGrading (0.625 1 1)
+    hex (13 12 15 14 32 31 34 33) (61 15 $nz) simpleGrading (1 1 1)
+    hex (14 15 18 17 33 34 37 36) (61 61 $nz) simpleGrading (1 1 1)
+    hex (15  9  8 18 34 28 27 37) (15 61 $nz) simpleGrading (1 1 1)
+    hex (2 50 54 3 21 56 60 22)  (69 15 $nz) simpleGrading (1 1 1) // downstream
+    hex (3 54 51 6 22 60 57 25)  (69 61 $nz) simpleGrading (1 1 1)
+    hex (52 13 14 55 58 32 33 61)  (1 15 $nz) simpleGrading (1 1 1) // upstream
+    hex (55 14 17 53 61 33 36 59)  (1 61 $nz) simpleGrading (1 1 1)
+);
+
+edges
+(
+    arc  0  5 ($RcosPi8   $RsinPi8  $z0)
+    arc  5 10 ($RsinPi8   $RcosPi8  $z0)
+    arc  1  4 ($x2cosPi8  $x2sinPi8 $z0)
+    arc  4  9 ($x2sinPi8  $x2cosPi8 $z0)
+    arc 19 24 ($RcosPi8   $RsinPi8  $z1)
+    arc 24 29 ($RsinPi8   $RcosPi8  $z1)
+    arc 20 23 ($x2cosPi8  $x2sinPi8 $z1)
+    arc 23 28 ($x2sinPi8  $x2cosPi8 $z1)
+    arc 11 16 ($RcosPi8n  $RsinPi8  $z0)
+    arc 16 10 ($RsinPi8n  $RcosPi8  $z0)
+    arc 12 15 ($x2cosPi8n $x2sinPi8 $z0)
+    arc 15  9 ($x2sinPi8n $x2cosPi8 $z0)
+    arc 30 35 ($RcosPi8n  $RsinPi8  $z1)
+    arc 35 29 ($RsinPi8n  $RcosPi8  $z1)
+    arc 31 34 ($x2cosPi8n $x2sinPi8 $z1)
+    arc 34 28 ($x2sinPi8n $x2cosPi8 $z1)
+);
+
+boundary
+(
+    inlet
+    {
+        type patch;
+        faces
+        (
+            (53 59 61 55)
+            (55 61 58 52)
+        );
+    }
+    outlet
+    {
+        type patch;
+        faces
+        (
+            (60 57 51 54)
+            (56 60 54 50)
+        );
+    }
+    topAndBottom
+    {
+        type symmetry;
+        faces
+        (
+            (59 53 17 36)
+            (36 17 18 37)
+            (37 18  8 27)
+            (27  8  7 26)
+            (26  7  6 25)
+            (25  6 51 57)
+            (52 58 32 13)
+            (13 32 31 12)
+            (12 31 30 11)
+            (0 19 20 1)
+            (1 20 21 2)
+            (2 21 56 50)
+        );
+    }
+    left
+    {
+        type empty;
+        faces
+        (
+            (55 52 13 14)
+            (53 55 14 17)
+            (13 12 15 14)
+            (14 15 18 17)
+            (15 9 8 18)
+            (12 11 16 15)
+            (15 16 10 9)
+            (9 10 5 4)
+            (5 0 1 4)
+            (9 4 7 8)
+            (4 3 6 7)
+            (1 2 3 4)
+            (3 2 50 54)
+            (6 3 54 51)
+        );
+    }
+    right
+    {
+        type empty;
+        faces
+        (
+            (59 36 33 61)
+            (61 33 32 58)
+            (36 37 34 33)
+            (33 34 31 32)
+            (37 27 28 34)
+            (27 26 23 28)
+            (26 25 22 23)
+            (23 22 21 20)
+            (25 57 60 22)
+            (22 60 56 21)
+            (24 23 20 19)
+            (28 23 24 29)
+            (34 28 29 35)
+            (31 34 35 30)
+        );
+    }
+    cylinder
+    {
+        type wall;
+        faces
+        (
+            (29 24 5 10)
+            (24 19 0 5)
+            (30 35 16 11)
+            (35 29 10 16)
+        );
+    }
+);
+
+mergePatchPairs
+();
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/coarseMesh/fvSchemes b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/coarseMesh/fvSchemes
new file mode 100644
index 0000000000..172e4c34ad
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/coarseMesh/fvSchemes
@@ -0,0 +1,47 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+}
+
+gradSchemes
+{
+}
+
+divSchemes
+{
+}
+
+laplacianSchemes
+{
+}
+
+interpolationSchemes
+{
+}
+
+snGradSchemes
+{
+}
+
+fluxRequired
+{
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/coarseMesh/fvSolution b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/coarseMesh/fvSolution
new file mode 100644
index 0000000000..133f1e3bf7
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/coarseMesh/fvSolution
@@ -0,0 +1,27 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+}
+
+PIMPLE
+{
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/controlDict b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/controlDict
new file mode 100644
index 0000000000..5ef1852478
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/controlDict
@@ -0,0 +1,229 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     pimpleFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         200;
+
+deltaT          0.05;
+
+writeControl    runTime;
+
+writeInterval   50;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  16;
+
+timeFormat      general;
+
+timePrecision   8;
+
+runTimeModifiable false;
+
+
+functions
+{
+    mapFields1
+    {
+        type            mapFields;
+        libs            (fieldFunctionObjects);
+        mapRegion       coarseMesh;
+        mapMethod       cellVolumeWeight;
+        consistent      no;
+        patchMap        ();
+        cuttingPatches  ();
+        fields          ( U p );
+
+        timeStart       10;
+        timeEnd         2000;
+
+        executeControl  timeStep;
+        executeInterval 10;
+
+        writeControl    timeStep;
+        writeInterval   50;
+    }
+
+    STDMD1U
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               U;
+
+        // Optional entries
+        modeSorter          firstSnap;
+
+        // Optional (inherited) entries
+        region              coarseMesh;  // mapFields must be executed before.
+        timeStart           10;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        onEnd;
+    }
+
+    STDMD1p
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               p;
+
+        // Optional entries
+        modeSorter          firstSnap;
+
+        // Optional (inherited) entries
+        region              coarseMesh;
+        timeStart           10;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        onEnd;
+    }
+
+    STDMD2U
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               U;
+
+        // Optional entries
+        modeSorter          firstSnap;
+        nModes              2;
+        maxRank             2;
+        nGramSchmidt        5;
+        fMin                0;
+        fMax                1000000000;
+        testEigen           true;
+        dumpEigen           true;
+        minBasis            0.00000001;
+        minEVal             0.00000001;
+        absTol              0.001;
+        relTol              0.0001;
+
+        // Optional (inherited) entries
+        timeStart           50;
+        timeEnd             2000;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        onEnd;
+    }
+
+    STDMD3U
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               U;
+
+        // Optional entries
+        modeSorter          firstSnap;
+
+        // Optional (inherited) entries
+        region              coarseMesh;
+        timeStart           10;
+        timeEnd             150;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        runTime;
+        writeInterval       50;
+    }
+
+    STDMD4U
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               U;
+
+        // Optional entries
+        modeSorter          kiewat;
+
+        // Optional (inherited) entries
+        region              coarseMesh;
+        timeStart           10;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        onEnd;
+    }
+
+    STDMD4p
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               p;
+
+        // Optional entries
+        modeSorter          kiewat;
+
+        // Optional (inherited) entries
+        region              coarseMesh;
+        timeStart           10;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        onEnd;
+    }
+
+    STDMD5U
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               U;
+
+        // Optional entries
+        modeSorter          kouZhang;
+
+        // Optional (inherited) entries
+        region              coarseMesh;
+        timeStart           10;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        onEnd;
+    }
+
+    STDMD5p
+    {
+        // Mandatory entries
+        type                STDMD;
+        libs                (fieldFunctionObjects);
+        field               p;
+
+        // Optional entries
+        modeSorter          kouZhang;
+
+        // Optional (inherited) entries
+        region              coarseMesh;
+        timeStart           10;
+        executeControl      timeStep;
+        executeInterval     10;
+        writeControl        onEnd;
+    }
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/decomposeParDict b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/decomposeParDict
new file mode 100644
index 0000000000..5c92caa799
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/decomposeParDict
@@ -0,0 +1,28 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      decomposeParDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+numberOfSubdomains  8;
+
+method              hierarchical;
+
+coeffs
+{
+    n               (8 1 1);
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/fvSchemes b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/fvSchemes
new file mode 100644
index 0000000000..45794b927c
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/fvSchemes
@@ -0,0 +1,56 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+    default         Euler;
+}
+
+gradSchemes
+{
+    default         Gauss linear;
+}
+
+divSchemes
+{
+    default         Gauss linear;
+    div((nuEff*dev(T(grad(U))))) Gauss linear;
+}
+
+laplacianSchemes
+{
+    default         Gauss linear corrected;
+}
+
+interpolationSchemes
+{
+    default         linear;
+}
+
+snGradSchemes
+{
+    default         corrected;
+}
+
+fluxRequired
+{
+    default         no;
+    p               ;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/fvSolution b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/fvSolution
new file mode 100644
index 0000000000..e76425bfb1
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/fvSolution
@@ -0,0 +1,56 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    p
+    {
+        solver           GAMG;
+        smoother         DICGaussSeidel;
+        tolerance        1e-6;
+        relTol           0.01;
+    }
+
+    pFinal
+    {
+        $p;
+        relTol          0;
+    }
+
+    U
+    {
+        solver          smoothSolver;
+        smoother        symGaussSeidel;
+        tolerance       1e-05;
+        relTol          0.1;
+    }
+
+    UFinal
+    {
+        $U;
+        relTol          0;
+    }
+}
+
+PIMPLE
+{
+    nNonOrthogonalCorrectors 0;
+    nCorrectors         2;
+}
+
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/mirrorMeshDict b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/mirrorMeshDict
new file mode 100644
index 0000000000..7b48e324c7
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/mirrorMeshDict
@@ -0,0 +1,27 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      mirrorMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+planeType           pointAndNormal;
+
+pointAndNormalDict
+{
+    point   (0 0 0);
+    normal  (0 -1 0);
+}
+
+planeTolerance      1e-3;
+
+// ************************************************************************* //
diff --git a/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/snappyHexMeshDict b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/snappyHexMeshDict
new file mode 100644
index 0000000000..268920eab9
--- /dev/null
+++ b/tutorials/incompressible/pimpleFoam/laminar/cylinder2D/system/snappyHexMeshDict
@@ -0,0 +1,83 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  v1912                                 |
+|   \\  /    A nd           | Website:  www.openfoam.com                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      snappyHexMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+castellatedMesh true;
+snap            false;
+addLayers       false;
+
+geometry
+{
+    cylinder
+    {
+        type    searchableCylinder;
+        point1  (0 0 -0.00375);
+        point2  (0 0 0.00375);
+        radius  0.06;
+    }
+}
+
+
+castellatedMeshControls
+{
+    maxLocalCells       100000;
+    maxGlobalCells      100000000;
+    minRefinementCells  10;
+    maxLoadUnbalance    0.10;
+    nCellsBetweenLevels 1;
+    resolveFeatureAngle 30;
+    allowFreeStandingZoneFaces true;
+    features
+    ();
+    refinementSurfaces
+    {
+        cylinder
+        {
+            level (0 0);
+            patchInfo
+            {
+                type     empty;
+                inGroups (allPatches);
+            }
+        }
+    };
+    refinementRegions{};
+    locationInMesh (-0.1 -0.2 0);
+}
+
+
+snapControls
+{
+    nSmoothPatch    3;
+    tolerance       2.0;
+    nSolveIter      100;
+    nRelaxIter      5;
+}
+
+
+addLayersControls
+{}
+
+
+meshQualityControls
+{
+    #includeEtc "caseDicts/meshQualityDict"
+}
+
+debug 0;
+mergeTolerance 1e-6;
+
+
+// ************************************************************************* //