Allwmake

 #!/bin/sh
-cd ${0%/*} || exit 1                        # Run from this directory
-
+cd "${0%/*}" || exit                            # Run from this directory
+targetType=libso
 # Parse arguments for library compilation
-if [ -f $WM_PROJECT_DIR/wmake/scripts/AllwmakeParseArguments ]
-then  . $WM_PROJECT_DIR/wmake/scripts/AllwmakeParseArguments
+if [ -f "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments ]
+then  . "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments
 fi
 
+#------------------------------------------------------------------------------
+# Build into FOAM_USER_{APPBIN,LIBBIN} unless otherwise specified with
+# -prefix or FOAM_MODULE_{APPBIN,LIBBIN} env varables
+
+moduleName="avalanche"
+
 #------------------------------------------------------------------------------
 
+echo "========================================"
+date "+%Y-%m-%d %H:%M:%S %z" 2>/dev/null || echo "date is unknown"
+echo "Starting compile of $moduleName with ${WM_PROJECT_DIR##*/}"
+echo "  $WM_COMPILER $WM_COMPILER_TYPE compiler"
+echo "  ${WM_OPTIONS}, with ${WM_MPLIB} ${FOAM_MPI}"
+echo "  prefix = ${FOAM_MODULE_PREFIX:-default (user)}"
+echo
+
+
 src/Allwmake $targetType $*
 applications/Allwmake $targetType $*
 
+
+# Some summary information
+echo
+date "+%Y-%m-%d %H:%M:%S %z" 2>/dev/null || echo "date is unknown"
+echo "========================================"
+echo "  Finished compile of $moduleName with ${WM_PROJECT_DIR##*/}"
+echo "  $WM_COMPILER $WM_COMPILER_TYPE compiler"
+echo "  ${WM_OPTIONS}, with ${WM_MPLIB} ${FOAM_MPI}"
+echo
 #------------------------------------------------------------------------------

README

@@ -4,7 +4,7 @@ What:
 
 Author:
 
-    Matthias Rauter <matthias.rauter@uibk.ac.at>
+    Matthias Rauter <matthias@rauter.it>
 
     who kindly supplied and ported the code from the original
     implementation using foam-extend to OpenFOAM-1712.

applications/solvers/faParkerFukushimaFoam/Make/files

+faParkerFukushimaFoam.C
+
+EXE = $(FOAM_MODULE_APPBIN)/faParkerFukushimaFoam

applications/solvers/faParkerFukushimaFoam/Make/options

+sinclude $(GENERAL_RULES)/module-path-user
+
+/* Failsafe - user location */
+ifeq (,$(strip $(FOAM_MODULE_APPBIN)))
+    FOAM_MODULE_APPBIN = $(FOAM_USER_APPBIN)
+endif
+ifeq (,$(strip $(FOAM_MODULE_LIBBIN)))
+    FOAM_MODULE_LIBBIN = $(FOAM_USER_LIBBIN)
+endif
+
+EXE_INC = \
+    -I$(LIB_SRC)/finiteArea/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/cfdTools/general/lnInclude \
+    -I../../../src/avalanche/lnInclude
+
+EXE_LIBS = \
+    -lfiniteArea \
+    -lfiniteVolume \
+    -L$(FOAM_LIBBIN) -lfaAvalanche

applications/solvers/faParkerFukushimaFoam/createFaFields.H

+    Info << "Reading field h" << endl;
+    areaScalarField h
+    (
+        IOobject
+        (
+            "h",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        aMesh
+    );
+
+
+    Info << "Reading field Us" << endl;
+    areaVectorField Us
+    (
+        IOobject
+        (
+            "Us",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        aMesh
+    );
+
+    Info << "Reading field c" << endl;
+    areaScalarField c
+    (
+        IOobject
+        (
+            "c",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::AUTO_WRITE
+        ),
+        aMesh
+    );
+
+    Info << "Reading field hentrain" << endl;
+    areaScalarField hentrain
+    (
+        IOobject
+        (
+            "hentrain",
+            runTime.timeName(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        aMesh,
+        dimensionedScalar("hentrain0", dimLength, GREAT)
+    );
+
+    edgeScalarField phis
+    (
+        IOobject
+        (
+            "phis",
+            runTime.timeName(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        fac::interpolate(Us) & aMesh.Le()
+    );
+
+    edgeScalarField phi2s
+    (
+        IOobject
+        (
+            "phi2s",
+            runTime.timeName(),
+            mesh,
+            IOobject::READ_IF_PRESENT,
+            IOobject::AUTO_WRITE
+        ),
+        fac::interpolate(h*Us) & aMesh.Le()
+    );
+
+
+    areaVectorField n = aMesh.faceAreaNormals();
+
+    areaScalarField gn
+    (
+        IOobject
+        (
+            "gn",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        g & n
+    );
+
+    areaVectorField gs
+    (
+        IOobject
+        (
+            "gs",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        g - gn*n
+    );
+
+    areaScalarField ew
+    (
+        IOobject
+        (
+            "ew",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        aMesh,
+        dimensionedScalar(dimVelocity)
+    );
+
+    areaScalarField Sd
+    (
+        IOobject
+        (
+            "Sd",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        aMesh,
+        dimensionedScalar(dimVelocity)
+    );
+
+
+    areaVectorField tau
+    (
+        IOobject
+        (
+            "tau",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        aMesh,
+        dimensionedVector(dimPressure/dimDensity)
+    );
+
+    areaScalarField boundaryCell
+    (
+        IOobject
+        (
+            "dist",
+            runTime.timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        aMesh,
+        dimensionedScalar("one", dimless, 1)
+    );
+
+    const faPatchList& patches = aMesh.boundary();
+
+    const labelList& owner = aMesh.edgeOwner();
+
+    forAll(Us.boundaryField(), patchi)
+    {
+        if (Us.boundaryField()[patchi].type() != "processor" &&
+            Us.boundaryField()[patchi].fixesValue()){
+
+            for(label faceI = patches[patchi].start(); faceI < patches[patchi].start()+patches[patchi].size(); faceI++)
+            {
+                boundaryCell[owner[faceI]] = 0;
+            }
+        }
+    }

applications/solvers/faParkerFukushimaFoam/createSubmodels.H

+
+autoPtr<suspensionEntrainmentModel> entrainment
+(
+    suspensionEntrainmentModel::New(transportProperties, Us, h, hentrain, c, tau)
+);
+
+autoPtr<suspensionFrictionModel> friction
+(
+    suspensionFrictionModel::New(transportProperties, Us, h, c)
+);

applications/solvers/faParkerFukushimaFoam/faParkerFukushimaFoam.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | avalanche module
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2020 Matthias Rauter
+-------------------------------------------------------------------------------
+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
+    faParkerFukushimaFoam
+
+Description
+    A depth-integrated solver for turbidity currents.
+    The solver is based on the Finite Area Method.
+    Model derivation and description:
+    Parker,, Fukushima, and Pantin (1986). "Self-accelerating
+    turbidity currents". Journal of Fluid Mechanics, 171, 145-181.
+    dx.doi.org/10.1017/S0022112086001404
+
+Author
+    Matthias Rauter matthias@rauter.it
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "faCFD.H"
+#include "SolverPerformance.H"
+#include "inletOutletFaPatchFieldsFwd.H"
+#include "inletOutletFaPatchField.H"
+#include "suspensionFrictionModel.H"
+#include "suspensionEntrainmentModel.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "(avalanche)\n"
+        "A depth-integrated solver for turbidity currents using"
+        " Finite Area Methods."
+    );
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createFaMesh.H"
+    #include "readGravitationalAcceleration.H"
+    #include "readTransportProperties.H"
+    #include "createFaFields.H"
+    #include "createSubmodels.H"
+    #include "createTimeControls.H"
+
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    #include "readSolutionControls.H"
+
+    Info<< nl
+        << "Numerical settings" << nl
+        << "    max number of iterations " << nCorr << nl
+        << "    min number of iterations " << minCorr << nl
+        << "    TOL Us " << UsResidualMax << nl
+        << "    TOL h " << hResidualMax << nl
+        << "    TOL c " << cResidualMax << nl << endl;
+
+    const bool initDeltaT = runTime.controlDict().get<bool>("initDeltaT");
+
+    if (initDeltaT)
+    {
+        Info<< "Initializing Delta T" << endl;
+        #include "readTimeControls.H"
+        #include "surfaceCourantNo.H"
+        runTime.setDeltaT
+        (
+            min(maxCo/(CoNum + SMALL)*runTime.deltaT().value(), maxDeltaT)
+        );
+    }
+
+    bool final = false;
+    bool success = false;
+
+    while (runTime.run())
+    {
+        #include "readSolutionControls.H"
+        #include "readTimeControls.H"
+        #include "surfaceCourantNo.H"
+        #include "setDeltaT.H"
+
+        runTime++;
+
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+        final = false;
+
+        for (int iCorr = 0; ; iCorr++)
+        {
+
+            Info<< "Correction iteration " << iCorr << endl;
+
+
+            const areaVectorField & tauSc = friction->tauSc();
+            const areaScalarField & tauSp = friction->tauSp();
+
+            //Parker et al. (1986), Eq. (5)
+            faVectorMatrix UsEqn
+            (
+                fam::ddt(h, Us)
+              + fam::div(phi2s, Us)
+              + tauSc               // ustar**2 expl. part
+              + fam::Sp(tauSp, Us)  // ustar**2 impl. part
+              ==
+                R*gs*c*h
+              - 1./2.*R*gn*fac::grad(c*h*h)*boundaryCell
+            );
+
+            if (!final)
+                UsEqn.relax();
+
+            SolverPerformance<vector> UsResidual = solve(UsEqn);
+
+            Us.correctBoundaryConditions();
+
+            phis = (fac::interpolate(Us) & aMesh.Le());
+
+            tau = tauSc + tauSp*Us;
+
+
+
+            //Calculate water entrainment
+            const areaScalarField Ri(R*gn*c*h/(magSqr(Us)+sqr(u0))); //Parker et al. (1986) Eq. (10)
+            ew = 0.00153/(0.0204+Ri)*mag(Us); //Parker et al. (1986) Eq. (19)
+            ew = ew*pos(hwem-h); //clip entrainment if maximum water height is reached
+
+            //Additional sink term for water
+            const areaScalarField vs(R*gn*Ds*Ds/18./nu); //Terminal velocity
+            areaScalarField dw(pos(h-hmin*2.)*vs);
+
+
+            //Parker et al. (1986), Eq. (3)
+            faScalarMatrix hEqn
+            (
+                fam::ddt(h)
+              + fam::div(phis, h)
+              ==
+                ew
+            );
+
+            if (waterSink)
+            {
+                hEqn += fam::Sp(dw/(h+dimensionedScalar("hmin", dimLength, 1e-5)),h);
+            }
+
+            solverPerformance hResidual = hEqn.solve();
+
+            phi2s = hEqn.flux();
+
+            if (!final)
+            {
+                 h.relax();
+            }
+
+            if (bindHeight)
+            {
+                h = max(h, hmin);
+            }
+
+
+            //Calculate sediment entrainment
+            areaScalarField Sm = entrainment->Sm();
+
+            //no entrainment if there is not a minimal flow thickness
+            Sm = Sm*pos(h-hentmin);
+
+            Sm = min(Sm, hentrain/runTime.deltaT());
+
+            //Calculate sedimation rate Sd following Parker et al. 1986
+            const areaScalarField mu(sqrt(mag(tau))/vs); //Parker et al. (1986), Eq. (21)
+            const areaScalarField r0(1.+31.5*pow(mu+SMALL, -1.46)); //Parker et al. (1986), Eq. (20)
+            //See Parker et al. (1986), Eq. (4), last term
+            Sd = vs*r0*c;
+            Sd = min(Sd, h*c/runTime.deltaT());
+
+            faScalarMatrix cEqn
+            (
+                fam::ddt(h, c)
+              + fam::div(phi2s, c)
+             ==
+                Sm/(hentrain+dimensionedScalar("hentrainmin", dimLength, 1e-5))*hentrain
+              - fam::Sp(Sd/(c+dimensionedScalar("cmin", dimless, 1e-7)), c)
+            );
+
+            if(!final)
+                cEqn.relax();
+
+            solverPerformance cResidual = cEqn.solve();
+
+            if (bindHeight)
+                c = max(c, cmin);
+
+            //Keep track of bed sediment
+            faScalarMatrix hentrainEqn
+            {
+                fam::ddt(hentrain)
+             ==
+              - fam::Sp(Sm/(hentrain+dimensionedScalar("heintrainmin", dimLength, 1e-5)), hentrain)
+              + Sd/(c+dimensionedScalar("cmin", dimless, 1e-7))*c
+            };
+
+            hentrainEqn.solve();
+
+
+            if (final)
+            {
+                if
+                (
+                    success
+                 && mag(UsResidual.initialResidual()) < UsResidualMax
+                 && hResidual.initialResidual() < hResidualMax
+                 && cResidual.initialResidual() < cResidualMax
+                )
+                {
+                    Info<< "Reached residual in Us = "
+                        << UsResidual.initialResidual()
+                        << " < " << UsResidualMax
+                        << ", in h = "
+                        << hResidual.initialResidual()
+                        << " < " << hResidualMax
+                        << ", in c = "
+                        << cResidual.initialResidual()
+                        << " < " << cResidualMax
+                        << ", stopping loop!" << endl;
+                     break;
+                }
+                if (!success)
+                {
+                    Info<< "Reached maximum number of iterations (" << iCorr << "). Residual in Us = "
+                        << UsResidual.initialResidual()
+                        << ", in h = "
+                        << hResidual.initialResidual()
+                        << ", in c = "
+                        << cResidual.initialResidual()
+                        << ", stopping loop!" << endl;
+                    break;
+                }
+            }
+
+            if
+            (
+                (
+                    mag(UsResidual.initialResidual()) < UsResidualMax
+                 && hResidual.initialResidual() < hResidualMax
+                 && cResidual.initialResidual() < cResidualMax
+                 && iCorr >= minCorr
+                )
+             )
+            {
+                final = true;
+                success = true;
+            }
+            else if (iCorr >= nCorr)
+            {
+                final = true;
+                success = false;
+            }
+        }
+
+        if (runTime.outputTime())
+        {
+            runTime.write();
+        }
+
+        runTime.printExecutionTime(Info);
+    }
+
+
+    Info<< nl << "End" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/faParkerFukushimaFoam/readSolutionControls.H

+
+    scalar nCorr =
+            aMesh.solutionDict().getOrDefault<int>("nOuterCorrectors", 50);
+
+    scalar minCorr =
+            aMesh.solutionDict().getOrDefault<int>("minCorrectors", 3);
+
+    scalar hResidualMax =
+        aMesh.solutionDict().getOrDefault<scalar>("hResidualMax", 0.);
+
+    scalar UsResidualMax =
+        aMesh.solutionDict().getOrDefault<scalar>("UsResidualMax", 1);
+
+    scalar cResidualMax =
+        aMesh.solutionDict().getOrDefault<scalar>("cResidualMax", 1);
+

applications/solvers/faParkerFukushimaFoam/readTransportProperties.H

+IOdictionary transportProperties
+(
+    IOobject
+    (
+        "transportProperties",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    )
+);
+
+
+dimensionedScalar hmin("hmin", dimLength, transportProperties);
+
+dimensionedScalar cmin("cmin", dimless, transportProperties);
+
+dimensionedScalar h0("h0", dimLength, transportProperties);
+
+dimensionedScalar u0("u0", dimVelocity, transportProperties);
+
+dimensionedScalar R("R", dimless, transportProperties);
+
+dimensionedScalar Ds("Ds", dimLength, transportProperties);
+
+dimensionedScalar nu("nu", dimViscosity, transportProperties);
+
+dimensionedScalar hwem("hwem", dimLength, transportProperties);
+
+dimensionedScalar hentmin("hentmin", dimLength, transportProperties);
+
+Switch waterSink(transportProperties.getOrDefault<Switch>("waterSink", false));
+
+Switch bindHeight(transportProperties.getOrDefault<Switch>("bindHeight", true));
+
+
+Info << "Running with" << endl
+     << "    hwem " << hwem << endl
+     << "    hmin " << hmin << endl
+     << "    cmin " << cmin << endl
+     << "    h0   " << h0 << endl
+     << "    u0   " << u0 << endl
+     << "    waterSink is " << waterSink << endl
+     << "    bindHeight is " << bindHeight << endl << endl;
+

applications/solvers/faParkerFukushimaFoam/surfaceCourantNo.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     3.2
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Global
+    surfaceCourantNo
+
+Author
+    Hrvoje Jasak, Wikki Ltd.  All rights reserved.
+
+Description
+    Calculates and outputs the mean and maximum Courant Numbers for the
+    Finite Area method.
+
+\*---------------------------------------------------------------------------*/
+
+scalar CoNum = 0.0;
+scalar meanCoNum = 0.0;
+scalar velMag = 0.0;
+if (aMesh.nInternalEdges())
+{
+    edgeScalarField edgeSpeed
+    (
+        mag(fac::interpolate(Us) & aMesh.Le()/aMesh.magLe())
+      + Foam::sqrt(max(dimensionedScalar("gh_min", dimensionSet(0, 2, -2, 0, 0, 0, 0), 0), fac::interpolate(R*c*h*boundaryCell)*fac::interpolate(gn)))
+    );
+
+    velMag = max(edgeSpeed.internalField()).value();
+
+    CoNum = max(aMesh.edgeInterpolation::deltaCoeffs()*edgeSpeed.internalField()).value()*runTime.deltaT().value();
+
+    meanCoNum = sum(aMesh.edgeInterpolation::deltaCoeffs()*edgeSpeed.internalField()*aMesh.magLe()).value()/gSum(aMesh.magLe())*runTime.deltaT().value();
+}
+
+
+Info<< "Courant Number mean: " << meanCoNum
+    << " max: " << CoNum
+    << " velocity max magnitude: " << velMag << endl;
+
+// ************************************************************************* //

applications/solvers/faSavageHutterFoam/Make/files

 faSavageHutterFoam.C
 
-EXE = $(FOAM_APPBIN)/faSavageHutterFoam
+EXE = $(FOAM_MODULE_APPBIN)/faSavageHutterFoam

applications/solvers/faSavageHutterFoam/Make/options

+sinclude $(GENERAL_RULES)/module-path-user
+
+/* Failsafe - user location */
+ifeq (,$(strip $(FOAM_MODULE_APPBIN)))
+    FOAM_MODULE_APPBIN = $(FOAM_USER_APPBIN)
+endif
+ifeq (,$(strip $(FOAM_MODULE_LIBBIN)))
+    FOAM_MODULE_LIBBIN = $(FOAM_USER_LIBBIN)
+endif
+
 EXE_INC = \
     -I$(LIB_SRC)/finiteArea/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
@@ -8,5 +18,4 @@ EXE_INC = \
 EXE_LIBS = \
     -lfiniteArea \
     -lfiniteVolume \
-    -L$(FOAM_LIBBIN) \
-    -lfaAvalanche
+    -L$(FOAM_LIBBIN) -lfaAvalanche

applications/solvers/faSavageHutterFoam/createFvFields.H

-volVectorField U
-(
-    IOobject
-    (
-        "U",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh,
-    dimensionedVector(dimVelocity)
-);
-
-volScalarField H
-(
-    IOobject
-    (
-        "H",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh,
-    dimensionedScalar(dimLength)
-);
-
-volScalarField Hentrain
-(
-    IOobject
-    (
-        "Hentrain",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh,
-    dimensionedScalar(dimLength)
-);
-
-volScalarField Pb
-(
-    IOobject
-    (
-        "Pb",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh,
-    dimensionedScalar(dimPressure)
-);
-
-volVectorField Tau
-(
-    IOobject
-    (
-        "Tau",
-        runTime.timeName(),
-        mesh,
-        IOobject::NO_READ,
-        IOobject::AUTO_WRITE
-    ),
-    mesh,
-    dimensionedVector(dimPressure)
-);
-
-
-#include "calcBasalstress.H"
-
-// Create volume-to surface mapping object
-volSurfaceMapping vsm(aMesh);
-vsm.mapToVolume(Us, U.boundaryFieldRef());
-vsm.mapToVolume(h, H.boundaryFieldRef());
-vsm.mapToVolume(pb, Pb.boundaryFieldRef());
-U.write();
-H.write();
-Pb.write();
-

applications/solvers/faSavageHutterFoam/faSavageHutterFoam.C

 /*---------------------------------------------------------------------------*\
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | faSavageHutterFOAM
+   \\    /   O peration     | avalanche module
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
@@ -31,7 +31,7 @@ Description
     The solver is based on the Finite Area Method.
     Model derivation and description:
     Rauter and Tukovic, "A finite area scheme for shallow granular flows on
-    three-dimensional surfaces", Computers and Fluids:166, 184-199 (2018),
+    three-dimensional surfaces", Computers and Fluids:166, 184–199 (2018),
     dx.doi.org/10.1016/j.compfluid.2018.02.017
 
 Author
@@ -64,7 +64,6 @@ int main(int argc, char *argv[])
     #include "readGravitationalAcceleration.H"
     #include "createFaFields.H"
     #include "readTransportProperties.H"
-    #include "createFvFields.H"
     #include "createTimeControls.H"
 
     Info<< "\nStarting time loop\n" << endl;
@@ -78,14 +77,15 @@ int main(int argc, char *argv[])
         << "    TOL h " << hResidualMax << nl
         << "    TOL Us " << UsResidualMax << nl << endl;
 
-    Switch initDeltaT(runTime.controlDict().lookup("initDeltaT"));
+    const bool initDeltaT = runTime.controlDict().get<bool>("initDeltaT");
 
     if (initDeltaT)
     {
         Info<< "Initializing Delta T" << endl;
         #include "readTimeControls.H"
         #include "surfaceCourantNo.H"
-        runTime.setDeltaT(
+        runTime.setDeltaT
+        (
             min(maxCo/(CoNum + SMALL)*runTime.deltaT().value(), maxDeltaT)
         );
     }
@@ -277,11 +277,6 @@ int main(int argc, char *argv[])
 
         if (runTime.outputTime())
         {
-            vsm.mapToVolume(Us, U.boundaryFieldRef());
-            vsm.mapToVolume(h, H.boundaryFieldRef());
-            vsm.mapToVolume(pb, Pb.boundaryFieldRef());
-            vsm.mapToVolume(tau, Tau.boundaryFieldRef());
-            vsm.mapToVolume(hentrain, Hentrain.boundaryFieldRef());
             runTime.write();
         }
 

applications/solvers/faSavageHutterFoam/readSolutionControls.H

 
     scalar nCorr =
-            aMesh.solutionDict().lookupOrDefault<int>("nOuterCorrectors", 50);
+            aMesh.solutionDict().getOrDefault<int>("nOuterCorrectors", 50);
 
     scalar minCorr =
-            aMesh.solutionDict().lookupOrDefault<int>("minCorrectors", 3);
+            aMesh.solutionDict().getOrDefault<int>("minCorrectors", 3);
 
     scalar hResidualMax =
-        aMesh.solutionDict().lookupOrDefault<scalar>("hResidualMax", 0.);
+        aMesh.solutionDict().getOrDefault<scalar>("hResidualMax", 0.);
 
     scalar UsResidualMax =
-        aMesh.solutionDict().lookupOrDefault<scalar>("UsResidualMax", 1);
+        aMesh.solutionDict().getOrDefault<scalar>("UsResidualMax", 1);
 

applications/solvers/faSavageHutterFoam/readTransportProperties.H

@@ -29,11 +29,11 @@ dimensionedScalar hmin("hmin", dimLength, transportProperties);
 
 dimensionedScalar xi("xi", dimless, transportProperties);
 
-Switch pressureFeedback(transportProperties.lookup("pressureFeedback"));
+Switch pressureFeedback(transportProperties.get<Switch>("pressureFeedback"));
 
-Switch explicitDryAreas(transportProperties.lookup("explicitDryAreas"));
+Switch explicitDryAreas(transportProperties.get<Switch>("explicitDryAreas"));
 
-Switch bindHeight(transportProperties.lookupOrDefault<Switch>("bindHeight", true));
+Switch bindHeight(transportProperties.getOrDefault<Switch>("bindHeight", true));
 
 Info << "Running with" << endl
      << "    hmin " << hmin << endl

applications/utilities/gridToSTL/Make/files

+gridToSTL.C
+
+EXE = $(FOAM_MODULE_APPBIN)/gridToSTL

applications/utilities/gridToSTL/Make/options

+sinclude $(GENERAL_RULES)/module-path-user
+
+/* Failsafe - user location */
+ifeq (,$(strip $(FOAM_MODULE_APPBIN)))
+    FOAM_MODULE_APPBIN = $(FOAM_USER_APPBIN)
+endif
+ifeq (,$(strip $(FOAM_MODULE_LIBBIN)))
+    FOAM_MODULE_LIBBIN = $(FOAM_USER_LIBBIN)
+endif
+
+EXE_INC = \
+    -I$(LIB_SRC)/finiteArea/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/cfdTools/general/lnInclude \
+    -I../../../src/avalanche/lnInclude
+
+EXE_LIBS = \
+    -lfiniteArea \
+    -lfiniteVolume \
+    -lfaAvalanche

applications/utilities/releaseAreaMapping/Make/files

 releaseAreaMapping.C
-HormannAgathos.C
 
-EXE = $(FOAM_APPBIN)/releaseAreaMapping
+EXE = $(FOAM_MODULE_APPBIN)/releaseAreaMapping