liquidFilmFoam.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2016-2017 Wikki 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
    liquidFilmFoam
 
Group
    grpFiniteAreaSolvers
 
Description
    Transient solver for incompressible, laminar flow of Newtonian fluids in
    liquid film formulation.
 
Author
    Zeljko Tukovic, FMENA
    Hrvoje Jasak, Wikki Ltd.
 
\*---------------------------------------------------------------------------*/
 
#include "fvCFD.H"
#include "faCFD.H"
#include "loopControl.H"
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
int main(int argc, char *argv[])
{
    argList::addNote
    (
        "Transient solver for incompressible, laminar flow"
        " of Newtonian fluids in liquid film formulation."
    );
 
    #include "setRootCaseLists.H"
    #include "createTime.H"
    #include "createMesh.H"
    #include "createFaMesh.H"
    #include "readGravitationalAcceleration.H"
    #include "readTransportProperties.H"
    #include "createFaFields.H"
    #include "createFvFields.H"
    #include "createTimeControls.H"
 
    Info<< "\nStarting time loop\n" << endl;
 
    while (runTime.run())
    {
        #include "readSolutionControls.H"
        #include "readTimeControls.H"
        #include "surfaceCourantNo.H"
        #include "capillaryCourantNo.H"
        #include "setDeltaT.H"
 
        ++runTime;
 
        Info<< "Time = " << runTime.timeName() << nl << endl;
 
        while (iters.loop())
        {
            phi2s = fac::interpolate(h)*phis;
 
            #include "calcFrictionFactor.H"
 
            faVectorMatrix UsEqn
            (
                fam::ddt(h, Us)
              + fam::div(phi2s, Us)
              + fam::Sp
                (
                    0.0125
                   *frictionFactor.internalField()
                   *mag(Us.internalField()),
                    Us
                )
             ==
                Gs*h
              - fam::Sp(Sd, Us)
            );
 
            UsEqn.relax();
            solve(UsEqn == - fac::grad(ps*h)/rhol + ps*fac::grad(h)/rhol);
 
            areaScalarField UsA(UsEqn.A());
 
            Us = UsEqn.H()/UsA;
            Us.correctBoundaryConditions();
 
            phis =
                (fac::interpolate(Us) & aMesh.Le())
              - fac::interpolate(1.0/(rhol*UsA))*fac::lnGrad(ps*h)*aMesh.magLe()
              + fac::interpolate(ps/(rhol*UsA))*fac::lnGrad(h)*aMesh.magLe();
 
            faScalarMatrix hEqn
            (
                fam::ddt(h)
              + fam::div(phis, h)
             ==
                Sm
              - fam::Sp
                (
                    Sd/(h + dimensionedScalar("small", dimLength, SMALL)),
                    h
                )
            );
 
            hEqn.relax();
            hEqn.solve();
 
            phi2s = hEqn.flux();
 
            // Bound h
            h.primitiveFieldRef() = max
            (
                max
                (
                    h.primitiveField(),
                    fac::average(max(h, h0))().primitiveField()
                   *pos(h0.value() - h.primitiveField())
                ),
                h0.value()
            );
 
            ps = rhol*Gn*h - sigma*fac::laplacian(h);
            ps.correctBoundaryConditions();
 
            Us -= (1.0/(rhol*UsA))*fac::grad(ps*h)
                - (ps/(rhol*UsA))*fac::grad(h);
            Us.correctBoundaryConditions();
        }
 
        if (runTime.writeTime())
        {
            vsm.mapToVolume(h, H.boundaryFieldRef());
            vsm.mapToVolume(Us, U.boundaryFieldRef());
 
            runTime.write();
        }
 
        runTime.printExecutionTime(Info);
    }
 
    Info<< "End\n" << endl;
 
    return 0;
}
 
 
// ************************************************************************* //