Add the OpenFOAM source tree

Allwmake

+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+wmakeCheckPwd "$WM_PROJECT_DIR" || {
+    echo "Error: Current directory is not \$WM_PROJECT_DIR"
+    echo "    The environment variables are inconsistent with the installation."
+    echo "    Check the OpenFOAM entries in your dot-files and source them."
+    exit 1
+}
+
+[ -n "$FOAM_EXT_LIBBIN" ] || {
+    echo "Error: FOAM_EXT_LIBBIN not set"
+    echo "    Check the OpenFOAM entries in your dot-files and source them."
+    exit 1
+}
+
+# wmake is required for subsequent targets
+( cd wmake/src && make )
+
+# build ThirdParty sources
+if [ -d "$WM_THIRD_PARTY_DIR" ]
+then
+    $WM_THIRD_PARTY_DIR/Allwmake
+else
+    echo "no ThirdParty sources found - skipping"
+fi
+
+# build OpenFOAM libraries and applications
+src/Allwmake $*
+applications/Allwmake $*
+
+if [ "$1" = doc ]
+then
+    doc/Allwmake $*
+fi
+
+# ----------------------------------------------------------------- end-of-file

applications/Allwmake

+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+
+wmakeCheckPwd "$WM_PROJECT_DIR/applications" || {
+    echo "Error: Current directory is not \$WM_PROJECT_DIR/applications"
+    echo "    The environment variables are inconsistent with the installation."
+    echo "    Check the OpenFOAM entries in your dot-files and source them."
+    exit 1
+}
+
+[ -n "$FOAM_EXT_LIBBIN" ] || {
+    echo "Error: FOAM_EXT_LIBBIN not set"
+    echo "    Check the OpenFOAM entries in your dot-files and source them."
+    exit 1
+}
+
+set -x
+
+wmake all utilities $*
+wmake all solvers $*
+
+# ----------------------------------------------------------------- end-of-file

applications/solvers/DNS/dnsFoam/Make/files

+dnsFoam.C
+
+EXE = $(FOAM_APPBIN)/dnsFoam

applications/solvers/DNS/dnsFoam/Make/options

+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/randomProcesses/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lrandomProcesses

applications/solvers/DNS/dnsFoam/createFields.H

+    Info<< "Reading field p\n" << endl;
+    volScalarField p
+    (
+        IOobject
+        (
+            "p",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    Info<< "Reading field U\n" << endl;
+    volVectorField U
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    #include "createPhi.H"

applications/solvers/DNS/dnsFoam/dnsFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    dnsFoam
+
+Description
+    Direct numerical simulation solver for boxes of isotropic turbulence
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "Kmesh.H"
+#include "UOprocess.H"
+#include "fft.H"
+#include "calcEk.H"
+#include "graph.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+
+    #include "createTime.H"
+    #include "createMeshNoClear.H"
+    #include "readTransportProperties.H"
+    #include "createFields.H"
+    #include "readTurbulenceProperties.H"
+    #include "initContinuityErrs.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< nl << "Starting time loop" << endl;
+
+    while (runTime.loop())
+    {
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        #include "readPISOControls.H"
+
+        force.internalField() = ReImSum
+        (
+            fft::reverseTransform
+            (
+                K/(mag(K) + 1.0e-6) ^ forceGen.newField(), K.nn()
+            )
+        );
+
+        #include "globalProperties.H"
+
+        fvVectorMatrix UEqn
+        (
+            fvm::ddt(U)
+          + fvm::div(phi, U)
+          - fvm::laplacian(nu, U)
+         ==
+            force
+        );
+
+        solve(UEqn == -fvc::grad(p));
+
+
+        // --- PISO loop
+
+        for (int corr=1; corr<=1; corr++)
+        {
+            volScalarField rAU(1.0/UEqn.A());
+            surfaceScalarField rAUf("rAUf", fvc::interpolate(rAU));
+            volVectorField HbyA("HbyA", U);
+            HbyA = rAU*UEqn.H();
+
+            surfaceScalarField phiHbyA
+            (
+                "phiHbyA",
+                (fvc::interpolate(HbyA) & mesh.Sf())
+              + rAUf*fvc::ddtCorr(U, phi)
+            );
+
+            fvScalarMatrix pEqn
+            (
+                fvm::laplacian(rAUf, p) == fvc::div(phiHbyA)
+            );
+
+            pEqn.solve();
+
+            phi = phiHbyA - pEqn.flux();
+
+            #include "continuityErrs.H"
+
+            U = HbyA - rAU*fvc::grad(p);
+            U.correctBoundaryConditions();
+        }
+
+        runTime.write();
+
+        if (runTime.outputTime())
+        {
+            calcEk(U, K).write
+            (
+                runTime.path()/"graphs"/runTime.timeName(),
+                "Ek",
+                runTime.graphFormat()
+            );
+        }
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/DNS/dnsFoam/globalProperties.H

+        Info<< "k("
+             << runTime.timeName()
+             << ") = "
+             << 3.0/2.0*average(magSqr(U)).value() << endl;
+
+        Info<< "epsilon("
+             << runTime.timeName()
+             << ") = "
+             << (
+                     0.5*nu*average
+                     (
+                         magSqr(fvc::grad(U) + fvc::grad(U)().T())
+                     )
+                ).value() << endl;
+
+        Info<< "U.f("
+             << runTime.timeName()
+             << ") = "
+             << 181.0*average(U & force).value() << endl;
+

applications/solvers/DNS/dnsFoam/readTransportProperties.H

+    Info<< "Reading transportProperties\n" << endl;
+
+    IOdictionary transportProperties
+    (
+        IOobject
+        (
+            "transportProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::NO_WRITE
+        )
+    );
+
+    dimensionedScalar nu
+    (
+        transportProperties.lookup("nu")
+    );

applications/solvers/DNS/dnsFoam/readTurbulenceProperties.H

+    Info<< "Reading turbulenceProperties\n" << endl;
+
+    IOdictionary turbulenceProperties
+    (
+        IOobject
+        (
+            "turbulenceProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::NO_WRITE
+        )
+    );
+
+    volVectorField force
+    (
+        U/dimensionedScalar("dt", dimTime, runTime.deltaTValue())
+    );
+
+    Kmesh K(mesh);
+    UOprocess forceGen(K, runTime.deltaTValue(), turbulenceProperties);

applications/solvers/basic/laplacianFoam/Make/files

+laplacianFoam.C
+
+EXE = $(FOAM_APPBIN)/laplacianFoam

applications/solvers/basic/laplacianFoam/Make/options

+EXE_INC = -I$(LIB_SRC)/finiteVolume/lnInclude
+
+EXE_LIBS = -lfiniteVolume

applications/solvers/basic/laplacianFoam/createFields.H

+    Info<< "Reading field T\n" << endl;
+
+    volScalarField T
+    (
+        IOobject
+        (
+            "T",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+
+    Info<< "Reading transportProperties\n" << endl;
+
+    IOdictionary transportProperties
+    (
+        IOobject
+        (
+            "transportProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::NO_WRITE
+        )
+    );
+
+
+    Info<< "Reading diffusivity DT\n" << endl;
+
+    dimensionedScalar DT
+    (
+        transportProperties.lookup("DT")
+    );

applications/solvers/basic/laplacianFoam/laplacianFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    laplacianFoam
+
+Description
+    Solves a simple Laplace equation, e.g. for thermal diffusion in a solid.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "simpleControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createFields.H"
+
+    simpleControl simple(mesh);
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nCalculating temperature distribution\n" << endl;
+
+    while (simple.loop())
+    {
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        while (simple.correctNonOrthogonal())
+        {
+            solve
+            (
+                fvm::ddt(T) - fvm::laplacian(DT, T)
+            );
+        }
+
+        #include "write.H"
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/basic/laplacianFoam/write.H

+    if (runTime.outputTime())
+    {
+        volVectorField gradT(fvc::grad(T));
+
+        volScalarField gradTx
+        (
+            IOobject
+            (
+                "gradTx",
+                runTime.timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            gradT.component(vector::X)
+        );
+
+        volScalarField gradTy
+        (
+            IOobject
+            (
+                "gradTy",
+                runTime.timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            gradT.component(vector::Y)
+        );
+
+        volScalarField gradTz
+        (
+            IOobject
+            (
+                "gradTz",
+                runTime.timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::AUTO_WRITE
+            ),
+            gradT.component(vector::Z)
+        );
+
+
+        runTime.write();
+    }

applications/solvers/basic/potentialFoam/Make/files

+potentialFoam.C
+
+EXE = $(FOAM_APPBIN)/potentialFoam

applications/solvers/basic/potentialFoam/Make/options

+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/fvOptions/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lfvOptions \
+    -lsampling

applications/solvers/basic/potentialFoam/createFields.H

+    Info<< "Reading field p\n" << endl;
+    volScalarField p
+    (
+        IOobject
+        (
+            "p",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh
+    );
+
+    p = dimensionedScalar("zero", p.dimensions(), 0.0);
+
+
+    Info<< "Reading field U\n" << endl;
+    volVectorField U
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        mesh
+    );
+
+    U = dimensionedVector("0", U.dimensions(), vector::zero);
+
+    surfaceScalarField phi
+    (
+        IOobject
+        (
+            "phi",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        fvc::interpolate(U) & mesh.Sf()
+    );
+
+    if (args.optionFound("initialiseUBCs"))
+    {
+        U.correctBoundaryConditions();
+        phi = fvc::interpolate(U) & mesh.Sf();
+    }
+
+
+    label pRefCell = 0;
+    scalar pRefValue = 0.0;
+    setRefCell
+    (
+        p,
+        potentialFlow,
+        pRefCell,
+        pRefValue
+    );

applications/solvers/basic/potentialFoam/potentialFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    potentialFoam
+
+Description
+    Simple potential flow solver which can be used to generate starting fields
+    for full Navier-Stokes codes.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "fvIOoptionList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addBoolOption("writep", "write the final pressure field");
+    argList::addBoolOption
+    (
+        "initialiseUBCs",
+        "initialise U boundary conditions"
+    );
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "readControls.H"
+    #include "createFields.H"
+    #include "createFvOptions.H"
+