SRFPimpleFoam: upgraded from OpenFOAM-1.7.x for OpenFOAM-dev

applications/solvers/incompressible/pimpleFoam/Allwmake

@@ -3,6 +3,7 @@ cd ${0%/*} || exit 1    # run from this directory
 set -x
 
 wmake
+wmake SRFPimpleFoam
 wmake pimpleDyMFoam
 
 # ----------------------------------------------------------------- end-of-file

applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/Make/files

@@ -0,0 +1,3 @@
+SRFPimpleFoam.C
+
+EXE = $(FOAM_APPBIN)/SRFPimpleFoam

applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/Make/options

@@ -0,0 +1,13 @@
+EXE_INC = \
+    -I$(LIB_SRC)/turbulenceModels/incompressible/turbulenceModel \
+    -I$(LIB_SRC)/transportModels \
+    -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
+    -I$(LIB_SRC)/finiteVolume/lnInclude
+
+EXE_LIBS = \
+    -lincompressibleTransportModels \
+    -lincompressibleTurbulenceModel \
+    -lincompressibleRASModels \
+    -lincompressibleLESModels \
+    -lfiniteVolume \
+    -lmeshTools

applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/SRFPimpleFoam.C

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2010-2011 OpenCFD Ltd.
+     \\/     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
+    SRFPimpleFoam
+
+Description
+    Large time-step transient solver for incompressible, flow in a single
+    rotating frame using the PIMPLE (merged PISO-SIMPLE) algorithm.
+
+    Turbulence modelling is generic, i.e. laminar, RAS or LES may be selected.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "singlePhaseTransportModel.H"
+#include "turbulenceModel.H"
+#include "pimpleControl.H"
+#include "SRFModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createFields.H"
+    #include "initContinuityErrs.H"
+
+    pimpleControl pimple(mesh);
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readTimeControls.H"
+        #include "CourantNo.H"
+        #include "setDeltaT.H"
+
+        runTime++;
+
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        // --- Pressure-velocity PIMPLE corrector loop
+        for (pimple.start(); pimple.loop(); pimple++)
+        {
+            if (pimple.nOuterCorr() != 1)
+            {
+                p.storePrevIter();
+            }
+
+            #include "UrelEqn.H"
+
+            // --- PISO loop
+            for (int corr=0; corr<pimple.nCorr(); corr++)
+            {
+                #include "pEqn.H"
+            }
+
+            // Update the absolute velocity
+            U = Urel + SRF->U();
+
+            if (pimple.turbCorr())
+            {
+                turbulence->correct();
+            }
+        }
+
+        runTime.write();
+
+        Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+            << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+            << nl << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/UrelEqn.H

@@ -0,0 +1,12 @@
+    // Relative momentum predictor
+    tmp<fvVectorMatrix> UrelEqn
+    (
+        fvm::ddt(Urel)
+      + fvm::div(phi, Urel)
+      + turbulence->divDevReff(Urel)
+      + SRF->Su()
+    );
+
+    UrelEqn().relax();
+
+    solve(UrelEqn() == -fvc::grad(p));

applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/createFields.H

@@ -0,0 +1,72 @@
+Info<< "Reading field p\n" << endl;
+volScalarField p
+(
+    IOobject
+    (
+        "p",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading field Urel\n" << endl;
+volVectorField Urel
+(
+    IOobject
+    (
+        "Urel",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+Info<< "Reading/calculating face flux field phi\n" << endl;
+surfaceScalarField phi
+(
+    IOobject
+    (
+        "phi",
+        runTime.timeName(),
+        mesh,
+        IOobject::READ_IF_PRESENT,
+        IOobject::AUTO_WRITE
+    ),
+    linearInterpolate(Urel) & mesh.Sf()
+);
+
+label pRefCell = 0;
+scalar pRefValue = 0.0;
+setRefCell(p, mesh.solutionDict().subDict("PIMPLE"), pRefCell, pRefValue);
+
+singlePhaseTransportModel laminarTransport(Urel, phi);
+
+autoPtr<incompressible::turbulenceModel> turbulence
+(
+    incompressible::turbulenceModel::New(Urel, phi, laminarTransport)
+);
+
+Info<< "Creating SRF model\n" << endl;
+autoPtr<SRF::SRFModel> SRF
+(
+    SRF::SRFModel::New(Urel)
+);
+
+// Create the absolute velocity
+volVectorField U
+(
+    IOobject
+    (
+        "U",
+        runTime.timeName(),
+        mesh,
+        IOobject::NO_READ,
+        IOobject::AUTO_WRITE
+    ),
+    Urel + SRF->U()
+);

applications/solvers/incompressible/pimpleFoam/SRFPimpleFoam/pEqn.H

@@ -0,0 +1,42 @@
+volScalarField rAUrel = 1.0/UrelEqn().A();
+Urel = rAUrel*UrelEqn().H();
+
+if (pimple.nCorr() <= 1)
+{
+    UrelEqn.clear();
+}
+
+phi = (fvc::interpolate(Urel) & mesh.Sf())
+    + fvc::ddtPhiCorr(rAUrel, Urel, phi);
+
+adjustPhi(phi, Urel, p);
+
+// Non-orthogonal pressure corrector loop
+for (int nonOrth=0; nonOrth<=pimple.nNonOrthCorr(); nonOrth++)
+{
+    // Pressure corrector
+    fvScalarMatrix pEqn
+    (
+        fvm::laplacian(rAUrel, p) == fvc::div(phi)
+    );
+
+    pEqn.setReference(pRefCell, pRefValue);
+
+    pEqn.solve
+    (
+        mesh.solver(p.select(pimple.finalInnerIter(corr, nonOrth)))
+    );
+
+    if (nonOrth == pimple.nNonOrthCorr())
+    {
+        phi -= pEqn.flux();
+    }
+}
+
+#include "continuityErrs.H"
+
+p.relax();
+
+// Momentum corrector
+Urel -= rAUrel*fvc::grad(p);
+Urel.correctBoundaryConditions();