TUT: Add and update overset tutorials

1) Deleting ddtCorr option
2) Deleting fluxInterpolation flux option
3) Reducing control readers files

.gitlab/issue_templates/bug.md

@@ -49,7 +49,7 @@
 
 <!--
   Providing details of your set-up can help us identify any issues, e.g.
-  OpenFOAM version : v2112|v2106|v2012|v2006|v1912|v1906 etc
+  OpenFOAM version : v1806|v1812|v1906 etc
   Operating system : ubuntu|openSUSE|centos etc
   Hardware info    : any info that may help?
   Compiler         : gcc|intel|clang etc

Allwmake

@@ -8,7 +8,7 @@ wmake -check-dir "$WM_PROJECT_DIR" 2>/dev/null || {
 }
 if [ -f "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments ]
 then  . "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments || \
-    echo "Argument parse error"
+    echo "Argument parse error";
 else
     echo "Error (${0##*/}) : WM_PROJECT_DIR appears to be incorrect"
     echo "    Check your OpenFOAM environment and installation"
@@ -23,23 +23,23 @@ else
     echo "mpirun=$(command -v mpirun || true)"
 fi
 echo
-# Report compiler information. First non-blank line from --version output
+# Report compiler information
 compiler="$(wmake -show-path-cxx 2>/dev/null || true)"
 if [ -x "$compiler" ]
 then
     echo "compiler=$compiler"
-    "$compiler" --version 2>/dev/null | sed -e '/^$/d;q'
+    "$compiler" --version 2>/dev/null | sed -ne '1p'
 else
     echo "compiler=unknown"
 fi
 
 echo
-echo ========================================
+echo "========================================"
 date "+%Y-%m-%d %H:%M:%S %z" 2>/dev/null || echo "date is unknown"
 echo "Starting compile ${WM_PROJECT_DIR##*/} ${0##*/}"
 echo "  $WM_COMPILER ${WM_COMPILER_TYPE:-system} compiler"
 echo "  ${WM_OPTIONS}, with ${WM_MPLIB} ${FOAM_MPI}"
-echo ========================================
+echo "========================================"
 echo
 
 # Compile tools for wmake
@@ -62,24 +62,26 @@ else
     echo "Skip ThirdParty (no directory)"
 fi
 
-# OpenFOAM libraries
+echo "========================================"
+echo "Compile OpenFOAM libraries"
+echo
 src/Allwmake $targetType $*
 
-# OpenFOAM applications
+echo "========================================"
+echo "Compile OpenFOAM applications"
+echo
 applications/Allwmake $targetType $*
 
-
 # Additional components/modules
-case "$FOAM_MODULE_PREFIX" in
-(false | none)
-    echo ========================================
+if [ "$FOAM_MODULE_PREFIX" = false ] || [ "$FOAM_MODULE_PREFIX" = none ]
+then
+    echo "========================================"
     echo "OpenFOAM modules disabled (prefix=${FOAM_MODULE_PREFIX})"
     echo
-    ;;
-(*)
-    # Use wmake -all instead of Allwmake to allow for overrides
-    ( cd "$WM_PROJECT_DIR/modules" 2>/dev/null && wmake -all )
-esac
+elif [ -d "$WM_PROJECT_DIR/modules" ]
+then
+    (cd "$WM_PROJECT_DIR/modules" 2>/dev/null && wmake -all)
+fi
 
 # Count files in given directory. Ignore "Test-*" binaries.
 _foamCountDirEntries()
@@ -91,7 +93,7 @@ _foamCountDirEntries()
 # Some summary information
 echo
 date "+%Y-%m-%d %H:%M:%S %z" 2>/dev/null || echo "date is unknown"
-echo ========================================
+echo "========================================"
 echo "  ${WM_PROJECT_DIR##*/}"
 echo "  $WM_COMPILER ${WM_COMPILER_TYPE:-system} compiler"
 echo "  ${WM_OPTIONS}, with ${WM_MPLIB} ${FOAM_MPI}"
@@ -101,6 +103,6 @@ echo "  patch = $(etc/openfoam -show-patch 2>/dev/null)"
 echo "  bin   = $(_foamCountDirEntries "$FOAM_APPBIN") entries"
 echo "  lib   = $(_foamCountDirEntries "$FOAM_LIBBIN") entries"
 echo
-echo ========================================
+echo "========================================"
 
 #------------------------------------------------------------------------------

META-INFO/api-info

@@ -1,2 +1,2 @@
-api=2112
+api=2107
 patch=0

README.md

@@ -40,9 +40,9 @@ Violations of the Trademark are monitored, and will be duly prosecuted.
 
 If OpenFOAM has already been compiled on your system, simply source
 the appropriate `etc/bashrc` or `etc/cshrc` file and get started.
-For example, for the OpenFOAM-v2112 version:
+For example, for the OpenFOAM-v2106 version:
 ```
-source /installation/path/OpenFOAM-v2112/etc/bashrc
+source /installation/path/OpenFOAM-v2106/etc/bashrc
 ```
 
 ## Compiling OpenFOAM
@@ -127,8 +127,8 @@ These 3rd-party sources are normally located in a directory parallel
 to the OpenFOAM directory. For example,
 ```
 /path/parent
-|-- OpenFOAM-v2112
-\-- ThirdParty-v2112
+|-- OpenFOAM-v2106
+\-- ThirdParty-v2106
 ```
 There are, however, many cases where this simple convention is inadequate:
 
@@ -136,7 +136,7 @@ There are, however, many cases where this simple convention is inadequate:
   operating system or cluster installation provides it)
 
 * When we have changed the OpenFOAM directory name to some arbitrary
-  directory name, e.g. openfoam-sandbox2112, etc..
+  directory name, e.g. openfoam-sandbox2106, etc..
 
 * When we would like any additional 3rd party software to be located
   inside of the OpenFOAM directory to ensure that the installation is
@@ -156,9 +156,9 @@ when locating the ThirdParty directory with the following precedence:
 2. PREFIX/ThirdParty-VERSION
    * this corresponds to the traditional approach
 3. PREFIX/ThirdParty-vAPI
-   * allows for an updated value of VERSION, *eg*, `v2112-myCustom`,
+   * allows for an updated value of VERSION, *eg*, `v2106-myCustom`,
      without requiring a renamed ThirdParty. The API value would still
-     be `2112` and the original `ThirdParty-v2112/` would be found.
+     be `2106` and the original `ThirdParty-v2106/` would be found.
 4. PREFIX/ThirdParty-API
    * same as the previous example, but using an unadorned API value.
 5. PREFIX/ThirdParty-common

applications/Allwmake

@@ -8,17 +8,13 @@ wmake -check-dir "$WM_PROJECT_DIR/applications" 2>/dev/null || {
 }
 if [ -f "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments ]
 then  . "$WM_PROJECT_DIR"/wmake/scripts/AllwmakeParseArguments || \
-    echo "Argument parse error"
+    echo "Argument parse error";
 else
     echo "Error (${0##*/}) : WM_PROJECT_DIR appears to be incorrect"
     echo "    Check your OpenFOAM environment and installation"
     exit 1
 fi
 
-echo ========================================
-echo Compile OpenFOAM applications
-echo ========================================
-
 #------------------------------------------------------------------------------
 
 wmake -all $targetType solvers
@@ -28,9 +24,3 @@ wmake -all $targetType utilities
 ## wmake -all $targetType tools
 
 #------------------------------------------------------------------------------
-
-echo ========================================
-echo Done OpenFOAM applications
-echo ========================================
-
-#------------------------------------------------------------------------------

applications/solvers/basic/potentialFoam/overPotentialFoam/overPotentialFoam.C

@@ -149,7 +149,7 @@ int main(int argc, char *argv[])
 
     mesh.update();
 
-    surfaceScalarField faceMask(localMin<scalar>(mesh).interpolate(cellMask));
+    //surfaceScalarField faceMask(localMin<scalar>(mesh).interpolate(cellMask));
 
     // Since solver contains no time loop it would never execute
     // function objects so do it ourselves

applications/solvers/combustion/PDRFoam/PDRModels/dragModels/PDRDragModel/PDRDragModelNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -43,9 +43,9 @@ Foam::autoPtr<Foam::PDRDragModel> Foam::PDRDragModel::New
 
     Info<< "Selecting drag model " << modelType << endl;
 
-    auto* ctorPtr = dictionaryConstructorTable(modelType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -57,9 +57,7 @@ Foam::autoPtr<Foam::PDRDragModel> Foam::PDRDragModel::New
     }
 
     return autoPtr<PDRDragModel>
-    (
-        ctorPtr(dict, turbulence, rho, U, phi)
-    );
+        (cstrIter()(dict, turbulence, rho, U, phi));
 }
 
 

applications/solvers/combustion/PDRFoam/XiModels/XiEqModels/XiEqModel/XiEqModelNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,9 +42,9 @@ Foam::autoPtr<Foam::XiEqModel> Foam::XiEqModel::New
 
     Info<< "Selecting flame-wrinkling model " << modelType << endl;
 
-    auto* ctorPtr = dictionaryConstructorTable(modelType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -55,7 +55,7 @@ Foam::autoPtr<Foam::XiEqModel> Foam::XiEqModel::New
         ) << exit(FatalIOError);
     }
 
-    return autoPtr<XiEqModel>(ctorPtr(dict, thermo, turbulence, Su));
+    return autoPtr<XiEqModel>(cstrIter()(dict, thermo, turbulence, Su));
 }
 
 

applications/solvers/combustion/PDRFoam/XiModels/XiGModels/XiGModel/XiGModelNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,9 +42,9 @@ Foam::autoPtr<Foam::XiGModel> Foam::XiGModel::New
 
     Info<< "Selecting flame-wrinkling model " << modelType << endl;
 
-    auto* ctorPtr = dictionaryConstructorTable(modelType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -55,7 +55,7 @@ Foam::autoPtr<Foam::XiGModel> Foam::XiGModel::New
         ) << exit(FatalIOError);
     }
 
-    return autoPtr<XiGModel>(ctorPtr(dict, thermo, turbulence, Su));
+    return autoPtr<XiGModel>(cstrIter()(dict, thermo, turbulence, Su));
 }
 
 

applications/solvers/combustion/PDRFoam/XiModels/XiModel/XiModelNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -45,9 +45,9 @@ Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
 
     Info<< "Selecting flame-wrinkling model " << modelType << endl;
 
-    auto* ctorPtr = dictionaryConstructorTable(modelType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -59,9 +59,7 @@ Foam::autoPtr<Foam::XiModel> Foam::XiModel::New
     }
 
     return autoPtr<XiModel>
-    (
-        ctorPtr(dict, thermo, turbulence, Su, rho, b, phi)
-    );
+        (cstrIter()(dict, thermo, turbulence, Su, rho, b, phi));
 }
 
 

applications/solvers/compressible/rhoCentralFoam/Allwclean

@@ -4,5 +4,6 @@ cd "${0%/*}" || exit    # Run from this directory
 
 wclean libso BCs
 wclean
+wclean rhoCentralDyMFoam
 
 #------------------------------------------------------------------------------

applications/solvers/compressible/rhoCentralFoam/Allwmake

@@ -5,7 +5,8 @@ cd "${0%/*}" || exit                                # Run from this directory
 
 (
     wmake $targetType BCs \
- && wmake $targetType
+ && wmake $targetType \
+ && wmake $targetType rhoCentralDyMFoam \
 )
 
 #------------------------------------------------------------------------------

applications/solvers/compressible/rhoCentralFoam/Make/options

@@ -7,7 +7,7 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
-    -I$(LIB_SRC)/dynamicFvMesh/lnInclude
+    -I$(LIB_SRC)/dynamicMesh/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
@@ -18,6 +18,4 @@ EXE_LIBS = \
     -lspecie \
     -lrhoCentralFoam \
     -lturbulenceModels \
-    -lcompressibleTurbulenceModels \
-    -ldynamicFvMesh \
-    -ltopoChangerFvMesh
+    -lcompressibleTurbulenceModels

applications/solvers/compressible/rhoCentralFoam/rhoCentralDyMFoam/Make/files

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

applications/solvers/compressible/rhoCentralFoam/rhoCentralDyMFoam/Make/options

@@ -0,0 +1,26 @@
+EXE_INC = \
+    -I.. \
+    -I../BCs/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicFvMesh/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -lcompressibleTransportModels \
+    -lfluidThermophysicalModels \
+    -lspecie \
+    -lrhoCentralFoam \
+    -lturbulenceModels \
+    -lcompressibleTurbulenceModels \
+    -ldynamicMesh \
+    -ldynamicFvMesh \
+    -ltopoChangerFvMesh

applications/solvers/compressible/rhoCentralFoam/rhoCentralDyMFoam/rhoCentralDyMFoam.C

@@ -0,0 +1,288 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2011-2016 OpenFOAM Foundation
+-------------------------------------------------------------------------------
+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
+    rhoCentralDyMFoam
+
+Group
+    grpCompressibleSolvers grpMovingMeshSolvers
+
+Description
+    Density-based compressible flow solver based on central-upwind
+    schemes of Kurganov and Tadmor
+    with support for mesh-motion and topology changes.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "dynamicFvMesh.H"
+#include "psiThermo.H"
+#include "turbulentFluidThermoModel.H"
+#include "fixedRhoFvPatchScalarField.H"
+#include "directionInterpolate.H"
+#include "localEulerDdtScheme.H"
+#include "fvcSmooth.H"
+#include "motionSolver.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Density-based compressible flow solver based on central-upwind"
+        " schemes of Kurganov and Tadmor.\n"
+        "With support for mesh-motion and topology changes."
+    );
+
+    #define NO_CONTROL
+    #include "postProcess.H"
+
+    #include "setRootCaseLists.H"
+    #include "createTime.H"
+    #include "createDynamicFvMesh.H"
+    #include "createFields.H"
+    #include "createFieldRefs.H"
+    #include "createTimeControls.H"
+
+    turbulence->validate();
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    #include "readFluxScheme.H"
+
+    const dimensionedScalar v_zero(dimVolume/dimTime, Zero);
+
+    // Courant numbers used to adjust the time-step
+    scalar CoNum = 0.0;
+    scalar meanCoNum = 0.0;
+
+    Info<< "\nStarting time loop\n" << endl;
+
+    while (runTime.run())
+    {
+        #include "readTimeControls.H"
+        #include "setDeltaT.H"
+
+        ++runTime;
+
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        // Do any mesh changes
+        mesh.update();
+
+        // --- Directed interpolation of primitive fields onto faces
+
+        surfaceScalarField rho_pos(interpolate(rho, pos));
+        surfaceScalarField rho_neg(interpolate(rho, neg));
+
+        surfaceVectorField rhoU_pos(interpolate(rhoU, pos, U.name()));
+        surfaceVectorField rhoU_neg(interpolate(rhoU, neg, U.name()));
+
+        volScalarField rPsi("rPsi", 1.0/psi);
+        surfaceScalarField rPsi_pos(interpolate(rPsi, pos, T.name()));
+        surfaceScalarField rPsi_neg(interpolate(rPsi, neg, T.name()));
+
+        surfaceScalarField e_pos(interpolate(e, pos, T.name()));
+        surfaceScalarField e_neg(interpolate(e, neg, T.name()));
+
+        surfaceVectorField U_pos("U_pos", rhoU_pos/rho_pos);
+        surfaceVectorField U_neg("U_neg", rhoU_neg/rho_neg);
+
+        surfaceScalarField p_pos("p_pos", rho_pos*rPsi_pos);
+        surfaceScalarField p_neg("p_neg", rho_neg*rPsi_neg);
+
+        surfaceScalarField phiv_pos("phiv_pos", U_pos & mesh.Sf());
+        surfaceScalarField phiv_neg("phiv_neg", U_neg & mesh.Sf());
+
+        // Make fluxes relative to mesh-motion
+        if (mesh.moving())
+        {
+            phiv_pos -= mesh.phi();
+            phiv_neg -= mesh.phi();
+        }
+        // Note: extracted out the orientation so becomes unoriented
+        phiv_pos.setOriented(false);
+        phiv_neg.setOriented(false);
+
+        volScalarField c("c", sqrt(thermo.Cp()/thermo.Cv()*rPsi));
+        surfaceScalarField cSf_pos
+        (
+            "cSf_pos",
+            interpolate(c, pos, T.name())*mesh.magSf()
+        );
+        surfaceScalarField cSf_neg
+        (
+            "cSf_neg",
+            interpolate(c, neg, T.name())*mesh.magSf()
+        );
+
+        surfaceScalarField ap
+        (
+            "ap",
+            max(max(phiv_pos + cSf_pos, phiv_neg + cSf_neg), v_zero)
+        );
+        surfaceScalarField am
+        (
+            "am",
+            min(min(phiv_pos - cSf_pos, phiv_neg - cSf_neg), v_zero)
+        );
+
+        surfaceScalarField a_pos("a_pos", ap/(ap - am));
+
+        surfaceScalarField amaxSf("amaxSf", max(mag(am), mag(ap)));
+
+        surfaceScalarField aSf("aSf", am*a_pos);
+
+        if (fluxScheme == "Tadmor")
+        {
+            aSf = -0.5*amaxSf;
+            a_pos = 0.5;
+        }
+
+        surfaceScalarField a_neg("a_neg", 1.0 - a_pos);
+
+        phiv_pos *= a_pos;
+        phiv_neg *= a_neg;
+
+        surfaceScalarField aphiv_pos("aphiv_pos", phiv_pos - aSf);
+        surfaceScalarField aphiv_neg("aphiv_neg", phiv_neg + aSf);
+
+        // Reuse amaxSf for the maximum positive and negative fluxes
+        // estimated by the central scheme
+        amaxSf = max(mag(aphiv_pos), mag(aphiv_neg));
+
+        #include "centralCourantNo.H"
+
+        phi = aphiv_pos*rho_pos + aphiv_neg*rho_neg;
+
+        surfaceVectorField phiU(aphiv_pos*rhoU_pos + aphiv_neg*rhoU_neg);
+        // Note: reassembled orientation from the pos and neg parts so becomes
+        // oriented
+        phiU.setOriented(true);
+
+        surfaceVectorField phiUp(phiU + (a_pos*p_pos + a_neg*p_neg)*mesh.Sf());
+
+        surfaceScalarField phiEp
+        (
+            "phiEp",
+            aphiv_pos*(rho_pos*(e_pos + 0.5*magSqr(U_pos)) + p_pos)
+          + aphiv_neg*(rho_neg*(e_neg + 0.5*magSqr(U_neg)) + p_neg)
+          + aSf*p_pos - aSf*p_neg
+        );
+
+        // Make flux for pressure-work absolute
+        if (mesh.moving())
+        {
+            surfaceScalarField phia(a_pos*p_pos + a_neg*p_neg);
+            phia.setOriented(true);
+
+            phiEp += mesh.phi()*phia;
+        }
+
+        volScalarField muEff("muEff", turbulence->muEff());
+        volTensorField tauMC("tauMC", muEff*dev2(Foam::T(fvc::grad(U))));
+
+        // --- Solve density
+        solve(fvm::ddt(rho) + fvc::div(phi));
+
+        // --- Solve momentum
+        solve(fvm::ddt(rhoU) + fvc::div(phiUp));
+
+        U.ref() =
+            rhoU()
+           /rho();
+        U.correctBoundaryConditions();
+        rhoU.boundaryFieldRef() == rho.boundaryField()*U.boundaryField();
+
+        if (!inviscid)
+        {
+            solve
+            (
+                fvm::ddt(rho, U) - fvc::ddt(rho, U)
+              - fvm::laplacian(muEff, U)
+              - fvc::div(tauMC)
+            );
+            rhoU = rho*U;
+        }
+
+        // --- Solve energy
+        surfaceScalarField sigmaDotU
+        (
+            "sigmaDotU",
+            (
+                fvc::interpolate(muEff)*mesh.magSf()*fvc::snGrad(U)
+              + fvc::dotInterpolate(mesh.Sf(), tauMC)
+            )
+          & (a_pos*U_pos + a_neg*U_neg)
+        );
+
+        solve
+        (
+            fvm::ddt(rhoE)
+          + fvc::div(phiEp)
+          - fvc::div(sigmaDotU)
+        );
+
+        e = rhoE/rho - 0.5*magSqr(U);
+        e.correctBoundaryConditions();
+        thermo.correct();
+        rhoE.boundaryFieldRef() ==
+            rho.boundaryField()*
+            (
+                e.boundaryField() + 0.5*magSqr(U.boundaryField())
+            );
+
+        if (!inviscid)
+        {
+            solve
+            (
+                fvm::ddt(rho, e) - fvc::ddt(rho, e)
+              - fvm::laplacian(turbulence->alphaEff(), e)
+            );
+            thermo.correct();
+            rhoE = rho*(e + 0.5*magSqr(U));
+        }
+
+        p.ref() =
+            rho()
+           /psi();
+        p.correctBoundaryConditions();
+        rho.boundaryFieldRef() == psi.boundaryField()*p.boundaryField();
+
+        turbulence->correct();
+
+        runTime.write();
+
+        runTime.printExecutionTime(Info);
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/compressible/rhoCentralFoam/rhoCentralFoam.C

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,14 +30,12 @@ Group
     grpCompressibleSolvers
 
 Description
-    Density-based compressible flow solver based on
-    central-upwind schemes of Kurganov and Tadmor with
-    support for mesh-motion and topology changes.
+    Density-based compressible flow solver based on central-upwind
+    schemes of Kurganov and Tadmor.
 
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
-#include "dynamicFvMesh.H"
 #include "psiThermo.H"
 #include "turbulentFluidThermoModel.H"
 #include "fixedRhoFvPatchScalarField.H"
@@ -52,9 +49,8 @@ int main(int argc, char *argv[])
 {
     argList::addNote
     (
-        "Density-based compressible flow solver based on"
-        " central-upwind schemes of Kurganov and Tadmor with"
-        " support for mesh-motion and topology changes."
+        "Density-based compressible flow solver based on central-upwind"
+        " schemes of Kurganov and Tadmor."
     );
 
     #define NO_CONTROL
@@ -63,7 +59,7 @@ int main(int argc, char *argv[])
     #include "addCheckCaseOptions.H"
     #include "setRootCaseLists.H"
     #include "createTime.H"
-    #include "createDynamicFvMesh.H"
+    #include "createMesh.H"
     #include "createFields.H"
     #include "createFieldRefs.H"
     #include "createTimeControls.H"
@@ -84,18 +80,6 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readTimeControls.H"
-
-        if (!LTS)
-        {
-            #include "setDeltaT.H"
-
-            ++runTime;
-
-            // Do any mesh changes
-            mesh.update();
-        }
-
         // --- Directed interpolation of primitive fields onto faces
 
         surfaceScalarField rho_pos(interpolate(rho, pos));
@@ -123,15 +107,6 @@ int main(int argc, char *argv[])
         surfaceScalarField phiv_neg("phiv_neg", U_neg & mesh.Sf());
         phiv_neg.setOriented(false);
 
-        // Make fluxes relative to mesh-motion
-        if (mesh.moving())
-        {
-            surfaceScalarField meshPhi(mesh.phi());
-            meshPhi.setOriented(false);
-            phiv_pos -= meshPhi;
-            phiv_neg -= meshPhi;
-        }
-
         volScalarField c("c", sqrt(thermo.Cp()/thermo.Cv()*rPsi));
         surfaceScalarField cSf_pos
         (
@@ -182,13 +157,18 @@ int main(int argc, char *argv[])
         amaxSf = max(mag(aphiv_pos), mag(aphiv_neg));
 
         #include "centralCourantNo.H"
+        #include "readTimeControls.H"
 
         if (LTS)
         {
             #include "setRDeltaT.H"
-
-            ++runTime;
         }
+        else
+        {
+            #include "setDeltaT.H"
+        }
+
+        ++runTime;
 
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
@@ -209,14 +189,6 @@ int main(int argc, char *argv[])
           + aSf*p_pos - aSf*p_neg
         );
 
-        // Make flux for pressure-work absolute
-        if (mesh.moving())
-        {
-            surfaceScalarField meshPhi(mesh.phi());
-            meshPhi.setOriented(false);
-            phiEp += meshPhi*(a_pos*p_pos + a_neg*p_neg);
-        }
-
         volScalarField muEff("muEff", turbulence->muEff());
         volTensorField tauMC("tauMC", muEff*dev2(Foam::T(fvc::grad(U))));
 

applications/solvers/compressible/rhoPimpleFoam/overRhoPimpleDyMFoam/createControls.H

@@ -1,4 +0,0 @@
-bool ddtCorr
-(
-    pimple.dict().getOrDefault("ddtCorr", true)
-);

applications/solvers/compressible/rhoPimpleFoam/overRhoPimpleDyMFoam/createFields.H

@@ -69,6 +69,8 @@ mesh.setFluxRequired(p.name());
 
 // Mask field for zeroing out contributions on hole cells
 #include "createCellMask.H"
+// Create bool field with interpolated cells
+#include "createInterpolatedCells.H"
 
 Info<< "Creating turbulence model\n" << endl;
 autoPtr<compressible::turbulenceModel> turbulence

applications/solvers/compressible/rhoPimpleFoam/overRhoPimpleDyMFoam/overRhoPimpleDyMFoam.C

@@ -43,7 +43,6 @@ Description
 #include "dynamicFvMesh.H"
 #include "fluidThermo.H"
 #include "turbulentFluidThermoModel.H"
-#include "bound.H"
 #include "pimpleControl.H"
 #include "pressureControl.H"
 #include "CorrectPhi.H"
@@ -89,10 +88,8 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readControls.H"
         #include "readDyMControls.H"
 
-
         // Store divrhoU from the previous mesh so that it can be mapped
         // and used in correctPhi to ensure the corrected phi has the
         // same divergence
@@ -128,7 +125,6 @@ int main(int argc, char *argv[])
         {
             if (pimple.firstIter() || moveMeshOuterCorrectors)
             {
-
                 // Do any mesh changes
                 mesh.update();
 
@@ -137,52 +133,22 @@ int main(int argc, char *argv[])
                     MRF.update();
 
                     #include "setCellMask.H"
-
-                    const surfaceScalarField faceMaskOld
-                    (
-                        localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-                    );
-
-                    // Zero Uf on old faceMask (H-I)
-                    rhoUf() *= faceMaskOld;
-
-                    surfaceVectorField rhoUfint(fvc::interpolate(rho*U));
-
-                    // Update Uf and phi on new C-I faces
-                    rhoUf() += (1-faceMaskOld)*rhoUfint;
-
-                    // Update Uf boundary
-                    forAll(rhoUf().boundaryField(), patchI)
-                    {
-                        rhoUf().boundaryFieldRef()[patchI] =
-                            rhoUfint.boundaryField()[patchI];
-                    }
-
-                    // Calculate absolute flux from the mapped surface velocity
-                    phi = mesh.Sf() & rhoUf();
+                    #include "setInterpolatedCells.H"
+                    #include "correctRhoPhiFaceMask.H"
 
                     if (correctPhi)
                     {
+                        // Corrects flux on separated regions
                         #include "correctPhi.H"
                     }
 
-                    // Zero phi on current H-I
-                    const surfaceScalarField faceMask
-                    (
-                        localMin<scalar>(mesh).interpolate(cellMask)
-                    );
-
-                    phi *= faceMask;
-                    U   *= cellMask;
-
                      // Make the fluxes relative to the mesh-motion
                     fvc::makeRelative(phi, rho, U);
 
-                }
-
-                if (checkMeshCourantNo)
-                {
-                    #include "meshCourantNo.H"
+                    if (checkMeshCourantNo)
+                    {
+                        #include "meshCourantNo.H"
+                    }
                 }
             }
 

applications/solvers/compressible/rhoPimpleFoam/overRhoPimpleDyMFoam/pEqn.H

@@ -25,17 +25,6 @@ surfaceScalarField phiHbyA
     fvc::interpolate(rho)*fvc::flux(HbyA)
 );
 
-if (ddtCorr)
-{
-    surfaceScalarField faceMaskOld
-    (
-        localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-    );
-
-    phiHbyA +=
-        faceMaskOld*MRF.zeroFilter(rhorAUf*fvc::ddtCorr(rho, U, phi, rhoUf));
-}
-
 fvc::makeRelative(phiHbyA, rho, U);
 MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
 
@@ -134,8 +123,4 @@ if (thermo.dpdt())
     }
 }
 
-surfaceScalarField faceMask
-(
-    localMin<scalar>(mesh).interpolate(cellMask)
-);
 phi *= faceMask;

applications/solvers/compressible/rhoPimpleFoam/overRhoPimpleDyMFoam/readControls.H

@@ -1,9 +0,0 @@
-#include "readTimeControls.H"
-
-correctPhi = pimple.dict().getOrDefault("correctPhi", false);
-
-checkMeshCourantNo =
-    pimple.dict().getOrDefault("checkMeshCourantNo", false);
-
-
-ddtCorr = pimple.dict().getOrDefault("ddtCorr", true);

applications/solvers/compressible/rhoPimpleFoam/setRDeltaT.H

@@ -49,7 +49,7 @@
         );
     }
 
-    // Update the boundary values of the reciprocal time-step
+    // Update tho boundary values of the reciprocal time-step
     rDeltaT.correctBoundaryConditions();
 
     Info<< "Flow time scale min/max = "

applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/Make/options

@@ -1,11 +1,8 @@
 EXE_INC = \
     -I../buoyantBoussinesqSimpleFoam \
-    -I../../incompressible/pimpleFoam \
     -I$(LIB_SRC)/sampling/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/incompressible/lnInclude \
     -I$(LIB_SRC)/transportModels \
@@ -16,8 +13,6 @@ EXE_LIBS = \
     -lfiniteVolume \
     -lfvOptions \
     -lmeshTools \
-    -ldynamicMesh \
-    -ldynamicFvMesh \
     -lsampling \
     -lturbulenceModels \
     -lincompressibleTurbulenceModels \

applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/buoyantBoussinesqPimpleFoam.C

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,8 +30,7 @@ Group
     grpHeatTransferSolvers
 
 Description
-    Transient solver for buoyant, turbulent flow of incompressible fluids,
-    with optional mesh motion and mesh topology changes.
+    Transient solver for buoyant, turbulent flow of incompressible fluids.
 
     Uses the Boussinesq approximation:
     \f[
@@ -53,11 +51,9 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
-#include "dynamicFvMesh.H"
 #include "singlePhaseTransportModel.H"
 #include "turbulentTransportModel.H"
 #include "radiationModel.H"
-#include "CorrectPhi.H"
 #include "fvOptions.H"
 #include "pimpleControl.H"
 
@@ -68,8 +64,7 @@ int main(int argc, char *argv[])
     argList::addNote
     (
         "Transient solver for buoyant, turbulent flow"
-        " of incompressible fluids, with optional mesh"
-        " motion and mesh topology changes.\n"
+        " of incompressible fluids.\n"
         "Uses the Boussinesq approximation."
     );
 
@@ -78,10 +73,10 @@ int main(int argc, char *argv[])
     #include "addCheckCaseOptions.H"
     #include "setRootCaseLists.H"
     #include "createTime.H"
-    #include "createDynamicFvMesh.H"
-    #include "createDyMControls.H"
+    #include "createMesh.H"
+    #include "createControl.H"
     #include "createFields.H"
-    #include "createUfIfPresent.H"
+    #include "createTimeControls.H"
     #include "CourantNo.H"
     #include "setInitialDeltaT.H"
     #include "initContinuityErrs.H"
@@ -94,7 +89,7 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readDyMControls.H"
+        #include "readTimeControls.H"
         #include "CourantNo.H"
         #include "setDeltaT.H"
 
@@ -105,34 +100,6 @@ int main(int argc, char *argv[])
         // --- Pressure-velocity PIMPLE corrector loop
         while (pimple.loop())
         {
-            if (pimple.firstIter() || moveMeshOuterCorrectors)
-            {
-                // Do any mesh changes
-                mesh.controlledUpdate();
-
-                if (mesh.changing())
-                {
-                    MRF.update();
-
-                    if (correctPhi)
-                    {
-                        // Calculate absolute flux
-                        // from the mapped surface velocity
-                        phi = mesh.Sf() & Uf();
-
-                        #include "correctPhi.H"
-
-                        // Make the flux relative to the mesh motion
-                        fvc::makeRelative(phi, U);
-                    }
-
-                    if (checkMeshCourantNo)
-                    {
-                        #include "meshCourantNo.H"
-                    }
-                }
-            }
-
             #include "UEqn.H"
             #include "TEqn.H"
 

applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/pEqn.H

@@ -42,12 +42,6 @@
             U = HbyA + rAU*fvc::reconstruct((phig - p_rghEqn.flux())/rAUf);
             U.correctBoundaryConditions();
             fvOptions.correct(U);
-
-            // Correct Uf if the mesh is moving
-            fvc::correctUf(Uf, U, phi);
-
-            // Make the fluxes relative to the mesh motion
-            fvc::makeRelative(phi, U);
         }
     }
 

applications/solvers/heatTransfer/buoyantPimpleFoam/Make/options

@@ -1,5 +1,4 @@
 EXE_INC = \
-    -I../../compressible/rhoPimpleFoam \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude \
@@ -8,8 +7,6 @@ EXE_INC = \
     -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/dynamicFvMesh/lnInclude \
     -I$(LIB_SRC)/regionFaModels\lnInclude
 
 EXE_LIBS = \
@@ -24,7 +21,4 @@ EXE_LIBS = \
     -lturbulenceModels \
     -lcompressibleTurbulenceModels \
     -latmosphericModels \
-    -ldynamicMesh \
-    -ldynamicFvMesh \
-    -ltopoChangerFvMesh \
     -lregionFaModels

applications/solvers/heatTransfer/buoyantPimpleFoam/buoyantPimpleFoam.C

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2017 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -31,9 +30,8 @@ Group
     grpHeatTransferSolvers
 
 Description
-    Transient solver for buoyant, turbulent flow of compressible fluids
-    for ventilation and heat-transfer, with optional mesh motion
-    and mesh topology changes.
+    Transient solver for buoyant, turbulent flow of compressible fluids for
+    ventilation and heat-transfer.
 
     Turbulence is modelled using a run-time selectable compressible RAS or
     LES model.
@@ -41,16 +39,12 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
-#include "dynamicFvMesh.H"
 #include "rhoThermo.H"
 #include "turbulentFluidThermoModel.H"
 #include "radiationModel.H"
-#include "CorrectPhi.H"
 #include "fvOptions.H"
 #include "pimpleControl.H"
 #include "pressureControl.H"
-#include "localEulerDdtScheme.H"
-#include "fvcSmooth.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -59,8 +53,7 @@ int main(int argc, char *argv[])
     argList::addNote
     (
         "Transient solver for buoyant, turbulent fluid flow"
-        " of compressible fluids, including radiation,"
-        " with optional mesh motion and mesh topology changes."
+        " of compressible fluids, including radiation."
     );
 
     #include "postProcess.H"
@@ -68,105 +61,36 @@ int main(int argc, char *argv[])
     #include "addCheckCaseOptions.H"
     #include "setRootCaseLists.H"
     #include "createTime.H"
-    #include "createDynamicFvMesh.H"
-    #include "createDyMControls.H"
-    #include "initContinuityErrs.H"
+    #include "createMesh.H"
+    #include "createControl.H"
     #include "createFields.H"
     #include "createFieldRefs.H"
-    #include "createRhoUfIfPresent.H"
+    #include "initContinuityErrs.H"
+    #include "createTimeControls.H"
+    #include "compressibleCourantNo.H"
+    #include "setInitialDeltaT.H"
 
     turbulence->validate();
 
-    if (!LTS)
-    {
-        #include "compressibleCourantNo.H"
-        #include "setInitialDeltaT.H"
-    }
-
     // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
     Info<< "\nStarting time loop\n" << endl;
 
     while (runTime.run())
     {
-        #include "readDyMControls.H"
-
-        // Store divrhoU from the previous mesh
-        // so that it can be mapped and used in correctPhi
-        // to ensure the corrected phi has the same divergence
-        autoPtr<volScalarField> divrhoU;
-        if (correctPhi)
-        {
-            divrhoU.reset
-            (
-                new volScalarField
-                (
-                    "divrhoU",
-                    fvc::div(fvc::absolute(phi, rho, U))
-                )
-            );
-        }
-
-        if (LTS)
-        {
-            #include "setRDeltaT.H"
-        }
-        else
-        {
-            #include "compressibleCourantNo.H"
-            #include "setDeltaT.H"
-        }
+        #include "readTimeControls.H"
+        #include "compressibleCourantNo.H"
+        #include "setDeltaT.H"
 
         ++runTime;
 
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
+        #include "rhoEqn.H"
+
         // --- Pressure-velocity PIMPLE corrector loop
         while (pimple.loop())
         {
-            if (pimple.firstIter() || moveMeshOuterCorrectors)
-            {
-                // Store momentum to set rhoUf for introduced faces.
-                autoPtr<volVectorField> rhoU;
-                if (rhoUf.valid())
-                {
-                    rhoU.reset(new volVectorField("rhoU", rho*U));
-                }
-
-                // Do any mesh changes
-                mesh.update();
-
-                if (mesh.changing())
-                {
-                    gh = (g & mesh.C()) - ghRef;
-                    ghf = (g & mesh.Cf()) - ghRef;
-
-                    MRF.update();
-
-                    if (correctPhi)
-                    {
-                        // Calculate absolute flux
-                        // from the mapped surface velocity
-                        phi = mesh.Sf() & rhoUf();
-
-                        #include "correctPhi.H"
-
-                        // Make the fluxes relative to the mesh-motion
-                        fvc::makeRelative(phi, rho, U);
-                    }
-
-                    if (checkMeshCourantNo)
-                    {
-                        #include "meshCourantNo.H"
-                    }
-                }
-            }
-
-            if (pimple.firstIter() && !pimple.SIMPLErho())
-            {
-                #include "rhoEqn.H"
-            }
-
             #include "UEqn.H"
             #include "EEqn.H"
 

applications/solvers/heatTransfer/buoyantPimpleFoam/createFields.H

@@ -1,5 +1,3 @@
-#include "createRDeltaT.H"
-
 Info<< "Reading thermophysical properties\n" << endl;
 
 autoPtr<rhoThermo> pThermo(rhoThermo::New(mesh));

applications/solvers/heatTransfer/buoyantPimpleFoam/overBuoyantPimpleDyMFoam/createFields.H

@@ -124,3 +124,6 @@ dimensionedScalar initialMass("initialMass", fvc::domainIntegrate(rho));
 
 // Mask field for zeroing out contributions on hole cells
 #include "createCellMask.H"
+
+// Create bool field with interpolated cells
+#include "createInterpolatedCells.H"

applications/solvers/heatTransfer/buoyantPimpleFoam/overBuoyantPimpleDyMFoam/overBuoyantPimpleDyMFoam.C

@@ -86,9 +86,6 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readTimeControls.H"
-
-        #include "readControls.H"
         #include "readDyMControls.H"
 
         #include "compressibleCourantNo.H"
@@ -128,45 +125,14 @@ int main(int argc, char *argv[])
                     MRF.update();
 
                     #include "setCellMask.H"
-
-                    const surfaceScalarField faceMaskOld
-                    (
-                        localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-                    );
-
-                    // Zero Uf on old faceMask (H-I)
-                    rhoUf() *= faceMaskOld;
-
-                    //fvc::correctRhoUf(rhoUfint, rho, U, phi);
-                    surfaceVectorField rhoUfint(fvc::interpolate(rho*U));
-
-                    // Update Uf and phi on new C-I faces
-                    rhoUf() += (1-faceMaskOld)*rhoUfint;
-
-                    // Update Uf boundary
-                    forAll(rhoUf().boundaryField(), patchI)
-                    {
-                        rhoUf().boundaryFieldRef()[patchI] =
-                            rhoUfint.boundaryField()[patchI];
-                    }
-
-                    // Calculate absolute flux from the mapped surface velocity
-                    phi = mesh.Sf() & rhoUf();
+                    #include "setInterpolatedCells.H"
+                    #include "correctRhoPhiFaceMask.H"
 
                     if (correctPhi)
                     {
                         #include "correctPhi.H"
                     }
 
-                    // Zero phi on current H-I
-                    const surfaceScalarField faceMask
-                    (
-                        localMin<scalar>(mesh).interpolate(cellMask)
-                    );
-
-                    phi *= faceMask;
-                    U   *= cellMask;
-
                      // Make the fluxes relative to the mesh-motion
                     fvc::makeRelative(phi, rho, U);
                 }

applications/solvers/heatTransfer/buoyantPimpleFoam/overBuoyantPimpleDyMFoam/pEqn.H

@@ -21,16 +21,6 @@ surfaceScalarField phiHbyA
     fvc::flux(rho*HbyA) + phig
 );
 
-if (ddtCorr)
-{
-    surfaceScalarField faceMaskOld
-    (
-        localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-    );
-
-    phiHbyA +=
-        faceMaskOld*MRF.zeroFilter(rhorAUf*fvc::ddtCorr(rho, U, phi));
-}
 
 MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
 
@@ -122,8 +112,4 @@ if (thermo.dpdt())
     }
 }
 
-surfaceScalarField faceMask
-(
-    localMin<scalar>(mesh).interpolate(cellMask)
-);
 phi *= faceMask;

applications/solvers/heatTransfer/buoyantPimpleFoam/overBuoyantPimpleDyMFoam/readControls.H

@@ -1,9 +0,0 @@
-#include "readTimeControls.H"
-
-correctPhi = pimple.dict().getOrDefault("correctPhi", false);
-
-checkMeshCourantNo =
-    pimple.dict().getOrDefault("checkMeshCourantNo", false);
-
-
-ddtCorr = pimple.dict().getOrDefault("ddtCorr", true);

applications/solvers/heatTransfer/buoyantPimpleFoam/pEqn.H

@@ -28,8 +28,6 @@ MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
 // Update the pressure BCs to ensure flux consistency
 constrainPressure(p_rgh, rho, U, phiHbyA, rhorAUf, MRF);
 
-fvc::makeRelative(phiHbyA, rho, U);
-
 fvScalarMatrix p_rghDDtEqn
 (
     fvc::ddt(rho) + psi*correction(fvm::ddt(p_rgh))
@@ -106,15 +104,7 @@ else
 
 rho = thermo.rho();
 
-// Correct rhoUf if the mesh is moving
-fvc::correctRhoUf(rhoUf, rho, U, phi);
-
 if (thermo.dpdt())
 {
     dpdt = fvc::ddt(p);
-
-    if (mesh.moving())
-    {
-        dpdt -= fvc::div(fvc::meshPhi(rho, U), p);
-    }
 }

applications/solvers/heatTransfer/chtMultiRegionFoam/include/createCoupledRegions.H

@@ -9,7 +9,7 @@ forAll(fluidRegions, i)
     const rhoThermo& thermo = refCast<const rhoThermo>(thermoFluid[i]);
     const auto& bpsi = thermo.T().boundaryField();
 
-    forAll(bpsi, patchI)
+    forAll (bpsi, patchI)
     {
         if (bpsi[patchI].useImplicit())
         {
@@ -23,7 +23,7 @@ forAll(solidRegions, i)
     solidThermo& thermo = thermos[i];
     const auto& bpsi = thermo.T().boundaryField();
 
-    forAll(bpsi, patchI)
+    forAll (bpsi, patchI)
     {
         if (bpsi[patchI].useImplicit())
         {
@@ -37,25 +37,7 @@ forAll(fluidRegions, i)
     const rhoThermo& thermo = refCast<const rhoThermo>(thermoFluid[i]);
     if (coupled)
     {
-        Info<< "Create fvMatrixAssembly." << endl;
-        fvMatrixAssemblyPtr.reset
-        (
-            new fvMatrix<scalar>
-            (
-                thermo.he(),
-                dimEnergy/dimTime
-            )
-        );
-        break;
-    }
-}
-
-if (coupled && !fvMatrixAssemblyPtr)
-{
-    forAll(solidRegions, i)
-    {
-        solidThermo& thermo = thermos[i];
-        Info<< "Create fvMatrixAssembly." << endl;
+        Info << "Create fvMatrixAssembly." << endl;
         fvMatrixAssemblyPtr.reset
         (
             new fvMatrix<scalar>

applications/solvers/heatTransfer/solidFoam/createFields.H

@@ -90,24 +90,5 @@ else
     );
 }
 
-// Consider mesh flux to correct for mesh deformation
-bool meshFluxCorr(false);
-if (mesh.solutionDict().found("SIMPLE"))
-{
-    meshFluxCorr =
-        mesh.solutionDict().subDict("SIMPLE").getOrDefault<bool>
-        (
-            "meshFluxCorrection", false
-        );
-}
-else if (mesh.solutionDict().found("PIMPLE"))
-{
-    meshFluxCorr =
-        mesh.solutionDict().subDict("PIMPLE").getOrDefault<bool>
-        (
-            "meshFluxCorrection", false
-        );
-}
-
 #include "createRadiationModel.H"
 #include "createFvOptions.H"

applications/solvers/heatTransfer/solidFoam/hEqn.H

@@ -11,14 +11,14 @@
         fvOptions(rho, h)
     );
 
-    if (meshFluxCorr)
+    if (mesh.changing())
     {
         surfaceScalarField phihMesh
         (
             fvc::interpolate(betav*rho*h)*mesh.phi()
         );
 
-       hEqn -= fvc::div(phihMesh);
+        hEqn -= fvc::div(phihMesh);
     }
 
     hEqn.relax();

applications/solvers/incompressible/pimpleFoam/createFields.H

@@ -1,5 +1,3 @@
-#include "createRDeltaT.H"
-
 Info<< "Reading field p\n" << endl;
 volScalarField p
 (

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/CourantNo.H

@@ -37,7 +37,10 @@ scalar meanCoNum = 0.0;
 
 if (mesh.nInternalFaces())
 {
-    surfaceScalarField phiMask(localMin<scalar>(mesh).interpolate(cellMask));
+    surfaceScalarField phiMask
+    (
+        localMin<scalar>(mesh).interpolate(cellMask + interpolatedCells)
+    );
 
     scalarField sumPhi(fvc::surfaceSum(mag(phiMask*phi))().internalField());
 

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/UEqn.H

@@ -1,5 +1,4 @@
 // Solve the Momentum equation
-
 MRF.correctBoundaryVelocity(U);
 
 tmp<fvVectorMatrix> tUEqn

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/createControls.H

@@ -1,26 +0,0 @@
-#include "createTimeControls.H"
-
-bool correctPhi
-(
-    pimple.dict().getOrDefault("correctPhi", false)
-);
-
-bool checkMeshCourantNo
-(
-    pimple.dict().getOrDefault("checkMeshCourantNo", false)
-);
-
-bool massFluxInterpolation
-(
-    pimple.dict().getOrDefault("massFluxInterpolation", false)
-);
-
-bool adjustFringe
-(
-    pimple.dict().getOrDefault("oversetAdjustPhi", false)
-);
-
-bool ddtCorr
-(
-    pimple.dict().getOrDefault("ddtCorr", true)
-);

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/interpolatedFaces.H

@@ -1,273 +0,0 @@
-// Interpolation used
-interpolationCellPoint<vector> UInterpolator(HbyA);
-
-// Determine faces on outside of interpolated cells
-bitSet isOwnerInterpolatedFace(mesh.nInternalFaces());
-bitSet isNeiInterpolatedFace(mesh.nInternalFaces());
-
-// Determine donor cells
-labelListList donorCell(mesh.nInternalFaces());
-
-scalarListList weightCellCells(mesh.nInternalFaces());
-
-// Interpolated HbyA faces
-vectorField UIntFaces(mesh.nInternalFaces(), Zero);
-
-// Determine receptor neighbour cells
-labelList receptorNeigCell(mesh.nInternalFaces(), -1);
-
-{
-    const cellCellStencilObject& overlap = Stencil::New(mesh);
-    const labelList& cellTypes = overlap.cellTypes();
-    const labelIOList& zoneID = overlap.zoneID();
-
-    label nZones = gMax(zoneID)+1;
-    PtrList<fvMeshSubset> meshParts(nZones);
-    labelList nCellsPerZone(nZones, Zero);
-
-    // A mesh subset for each zone
-    forAll(meshParts, zonei)
-    {
-        meshParts.set
-        (
-            zonei,
-            // Select cells where the zoneID == zonei
-            new fvMeshSubset(mesh, zonei, zoneID)
-        );
-    }
-
-    for (label faceI = 0; faceI < mesh.nInternalFaces(); faceI++)
-    {
-        label ownType = cellTypes[mesh.faceOwner()[faceI]];
-        label neiType = cellTypes[mesh.faceNeighbour()[faceI]];
-        if
-        (
-            ownType == cellCellStencil::INTERPOLATED
-            && neiType == cellCellStencil::CALCULATED
-        )
-        {
-            isOwnerInterpolatedFace.set(faceI);
-
-            const vector& fc = mesh.faceCentres()[faceI];
-
-            for (label zoneI = 0; zoneI < nZones; zoneI++)
-            {
-                if (zoneI != zoneID[mesh.faceOwner()[faceI]])
-                {
-                    const fvMesh& partMesh = meshParts[zoneI].subMesh();
-                    const labelList& cellMap = meshParts[zoneI].cellMap();
-                    label cellI = partMesh.findCell(fc);
-
-                    if (cellI != -1)
-                    {
-                         // Determine weights
-                        labelList stencil(partMesh.cellCells()[cellI]);
-
-                        stencil.append(cellI);
-
-                        label st = stencil.size();
-
-                        donorCell[faceI].setSize(st);
-
-                        weightCellCells[faceI].setSize(st);
-
-                        scalarField weights(st);
-
-                        forAll(stencil, i)
-                        {
-                            scalar d = mag
-                            (
-                                partMesh.cellCentres()[stencil[i]]
-                              - fc
-                            );
-                            weights[i] = 1.0/d;
-                            donorCell[faceI][i] = cellMap[stencil[i]];
-                        }
-                        weights /= sum(weights);
-
-                        weightCellCells[faceI] = weights;
-
-                        forAll(stencil, i)
-                        {
-                            UIntFaces[faceI] +=
-                                weightCellCells[faceI][i]
-                               *UInterpolator.interpolate
-                                (
-                                    fc,
-                                    donorCell[faceI][i]
-                                );
-                        }
-
-                        break;
-                    }
-                }
-            }
-
-            receptorNeigCell[faceI] = mesh.faceNeighbour()[faceI];
-        }
-        else if
-        (
-            ownType == cellCellStencil::CALCULATED
-            && neiType == cellCellStencil::INTERPOLATED
-        )
-        {
-            isNeiInterpolatedFace.set(faceI);
-
-            const vector& fc = mesh.faceCentres()[faceI];
-            for (label zoneI = 0; zoneI < nZones; zoneI++)
-            {
-                if (zoneI != zoneID[mesh.faceNeighbour()[faceI]])
-                {
-                    const fvMesh& partMesh = meshParts[zoneI].subMesh();
-                    const labelList& cellMap = meshParts[zoneI].cellMap();
-                    label cellI = partMesh.findCell(fc);
-
-                    if (cellI != -1)
-                    {
-                        // Determine weights
-                        labelList stencil(partMesh.cellCells()[cellI]);
-
-                        stencil.append(cellI);
-
-                        label st = stencil.size();
-
-                        donorCell[faceI].setSize(st);
-
-                        weightCellCells[faceI].setSize(st);
-
-                        scalarField weights(st);
-
-                        forAll(stencil, i)
-                        {
-                            scalar d = mag
-                            (
-                                partMesh.cellCentres()[stencil[i]]
-                              - fc
-                            );
-                            weights[i] = 1.0/d;
-                            donorCell[faceI][i] = cellMap[stencil[i]];
-                        }
-                        weights /= sum(weights);
-
-                        weightCellCells[faceI] = weights;
-
-                        forAll(stencil, i)
-                        {
-                            UIntFaces[faceI] +=
-                                weightCellCells[faceI][i]
-                               *UInterpolator.interpolate
-                                (
-                                    fc,
-                                    donorCell[faceI][i]
-                                );
-                        }
-
-                        break;
-                    }
-                }
-            }
-
-            receptorNeigCell[faceI] = mesh.faceOwner()[faceI];
-        }
-    }
-}
-
-// contravariant U
-vectorField U1Contrav(mesh.nInternalFaces(), Zero);
-
-surfaceVectorField faceNormals(mesh.Sf()/mesh.magSf());
-
-forAll(isNeiInterpolatedFace, faceI)
-{
-    label cellId = -1;
-    if (isNeiInterpolatedFace.test(faceI))
-    {
-        cellId = mesh.faceNeighbour()[faceI];
-    }
-    else if (isOwnerInterpolatedFace.test(faceI))
-    {
-        cellId = mesh.faceOwner()[faceI];
-    }
-
-    if (cellId != -1)
-    {
-        const vector& n = faceNormals[faceI];
-        vector n1(Zero);
-
-        // 2-D cases
-        if (mesh.nSolutionD() == 2)
-        {
-            for (direction cmpt=0; cmpt<vector::nComponents; cmpt++)
-            {
-                if (mesh.geometricD()[cmpt] == -1)
-                {
-                    switch (cmpt)
-                    {
-                        case vector::X:
-                        {
-                            n1 = vector(0, n.z(), -n.y());
-                            break;
-                        }
-
-                        case vector::Y:
-                        {
-                            n1 = vector(n.z(), 0, -n.x());
-                            break;
-                        }
-
-                        case vector::Z:
-                        {
-                            n1 = vector(n.y(), -n.x(), 0);
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        else if (mesh.nSolutionD() == 3)
-        {
-            //Determine which is the primary direction
-            if (mag(n.x()) > mag(n.y()) && mag(n.x()) > mag(n.z()))
-            {
-                n1 = vector(n.y(), -n.x(), 0);
-            }
-            else if (mag(n.y()) > mag(n.z()))
-            {
-                n1 = vector(0, n.z(), -n.y());
-            }
-            else
-            {
-                n1 = vector(-n.z(), 0, n.x());
-            }
-        }
-        n1.normalise();
-
-        const vector n2 = normalised(n ^ n1);
-
-        tensor rot =
-            tensor
-            (
-               n.x() ,n.y(), n.z(),
-               n1.x() ,n1.y(), n1.z(),
-               n2.x() ,n2.y(), n2.z()
-            );
-
-//         tensor rot =
-//             tensor
-//             (
-//                n  & x ,n  & y, n  & z,
-//                n1 & x ,n1 & y, n1 & z,
-//                n2 & x ,n2 & y, n2 & z
-//             );
-
-        U1Contrav[faceI].x() =
-           2*transform(rot, UIntFaces[faceI]).x()
-           - transform(rot, HbyA[receptorNeigCell[faceI]]).x();
-
-        U1Contrav[faceI].y() = transform(rot, HbyA[cellId]).y();
-
-        U1Contrav[faceI].z() = transform(rot, HbyA[cellId]).z();
-
-        HbyA[cellId] = transform(inv(rot), U1Contrav[faceI]);
-    }
-}

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/overPimpleDyMFoam.C

@@ -46,11 +46,7 @@ Description
 #include "fvOptions.H"
 
 #include "cellCellStencilObject.H"
-#include "zeroGradientFvPatchFields.H"
 #include "localMin.H"
-#include "interpolationCellPoint.H"
-#include "transform.H"
-#include "fvMeshSubset.H"
 #include "oversetAdjustPhi.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -68,10 +64,9 @@ int main(int argc, char *argv[])
     #include "setRootCaseLists.H"
     #include "createTime.H"
     #include "createDynamicFvMesh.H"
+    #include "createDyMControls.H"
     #include "initContinuityErrs.H"
 
-    pimpleControl pimple(mesh);
-
     #include "createFields.H"
     #include "createUf.H"
     #include "createMRF.H"
@@ -88,7 +83,7 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readControls.H"
+        #include "readDyMControls.H"
         #include "CourantNo.H"
 
         #include "setDeltaT.H"
@@ -97,45 +92,26 @@ int main(int argc, char *argv[])
 
         Info<< "Time = " << runTime.timeName() << nl << endl;
 
-        bool changed = mesh.update();
+        mesh.update();
 
-        if (changed)
+        if (mesh.changing())
         {
             #include "setCellMask.H"
             #include "setInterpolatedCells.H"
+            #include "correctPhiFaceMask.H"
 
-            surfaceScalarField faceMaskOld
-            (
-                localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-            );
+            if (correctPhi)
+            {
+                // Corrects flux on separated regions
+                #include "correctPhi.H"
+            }
 
-            // Zero Uf on old faceMask (H-I)
-            Uf *= faceMaskOld;
-            // Update Uf and phi on new C-I faces
-            Uf += (1-faceMaskOld)*fvc::interpolate(U);
-            phi = mesh.Sf() & Uf;
+            fvc::makeRelative(phi, U);
 
-            // Zero phi on current H-I
-            surfaceScalarField faceMask
-            (
-                localMin<scalar>(mesh).interpolate(cellMask)
-            );
-            phi *= faceMask;
-        }
-
-
-        if (mesh.changing() && correctPhi)
-        {
-            // Calculate absolute flux from the mapped surface velocity
-            #include "correctPhi.H"
-        }
-
-        // Make the flux relative to the mesh motion
-        fvc::makeRelative(phi, U);
-
-        if (mesh.changing() && checkMeshCourantNo)
-        {
-            #include "meshCourantNo.H"
+            if (checkMeshCourantNo)
+            {
+                #include "meshCourantNo.H"
+            }
         }
 
         // --- Pressure-velocity PIMPLE corrector loop

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

@@ -1,29 +1,11 @@
-// Option 1: interpolate rAU, do not block out rAU on blocked cells
 volScalarField rAU("rAU", 1.0/UEqn.A());
-mesh.interpolate(rAU);
 
-// Option 2: do not interpolate rAU but block out rAU
-//surfaceScalarField rAUf("rAUf", fvc::interpolate(blockedCells*rAU));
-
-
-// Option 3: do not interpolate rAU but zero out rAUf on faces on holes
-// But what about:
-//
-//   H
-// H I C C C C
-//   H
-//
 surfaceScalarField rAUf("rAUf", fvc::interpolate(rAU));
 volVectorField H("H", UEqn.H());
 
 volVectorField HbyA("HbyA", U);
 HbyA = constrainHbyA(rAU*H, U, p);
 
-if (massFluxInterpolation)
-{
-    #include "interpolatedFaces.H"
-}
-
 if (runTime.outputTime())
 {
     H.write();
@@ -38,18 +20,14 @@ if (pimple.nCorrPISO() <= 1)
 
 phiHbyA = fvc::flux(HbyA);
 
-if (ddtCorr)
+if (runTime.outputTime())
 {
-    surfaceScalarField faceMaskOld
-    (
-        localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-    );
-    phiHbyA += rAUf*faceMaskOld*fvc::ddtCorr(U, Uf);
+    volScalarField divPhiHbyA("divPhiHbyA", fvc::div(phiHbyA));
+    divPhiHbyA.write();
 }
 
 MRF.makeRelative(phiHbyA);
 
-// WIP
 if (p.needReference())
 {
     fvc::makeRelative(phiHbyA, U);
@@ -57,7 +35,8 @@ if (p.needReference())
     fvc::makeAbsolute(phiHbyA, U);
 }
 
-
+// WIP: To adjust phi on fringe faces to help mass
+// conservation
 if (adjustFringe)
 {
     fvc::makeRelative(phiHbyA, U);
@@ -79,27 +58,29 @@ while (pimple.correctNonOrthogonal())
     if (pimple.finalNonOrthogonalIter())
     {
         phi = phiHbyA - pEqn.flux();
-        // option 2:
-        // rAUf*fvc::snGrad(p)*mesh.magSf();
+        pEqn.relax();
+        U =
+            cellMask*
+            (
+                HbyA -
+                rAU*fvc::reconstruct((pEqn.flux())/rAUf)
+            );
+        U.correctBoundaryConditions();
+        fvOptions.correct(U);
     }
 }
 
-
+// Excludes error in interpolated/hole cells
 #include "continuityErrs.H"
 
-// Explicitly relax pressure for momentum corrector
-p.relax();
-volVectorField gradP(fvc::grad(p));
+if (runTime.outputTime())
+{
+    volVectorField Ucorrected("Ucorrected", U);
+    Ucorrected.write();
 
-// Option 2: zero out velocity on blocked out cells
-//U = HbyA - rAU*cellMask*gradP;
-// Option 3: zero out velocity on blocked out cells
-// This is needed for the scalar Eq (k,epsilon, etc)
-// which can use U as source term
-U = cellMask*(HbyA - rAU*gradP);
-U.correctBoundaryConditions();
-
-fvOptions.correct(U);
+    volScalarField divPhiCon("divPhiCon", fvc::div(phi));
+    divPhiCon.write();
+}
 
 {
     Uf = fvc::interpolate(U);
@@ -109,9 +90,4 @@ fvOptions.correct(U);
 
 // Make the fluxes relative to the mesh motion
 fvc::makeRelative(phi, U);
-
-surfaceScalarField faceMask
-(
-    localMin<scalar>(mesh).interpolate(cellMask)
-);
 phi *= faceMask;

applications/solvers/incompressible/pimpleFoam/overPimpleDyMFoam/readControls.H

@@ -1,10 +0,0 @@
-#include "readTimeControls.H"
-
-correctPhi = pimple.dict().getOrDefault("correctPhi", false);
-
-checkMeshCourantNo = pimple.dict().getOrDefault("checkMeshCourantNo", false);
-
-massFluxInterpolation =
-    pimple.dict().getOrDefault("massFluxInterpolation", false);
-
-ddtCorr = pimple.dict().getOrDefault("ddtCorr", true);

applications/solvers/incompressible/pimpleFoam/pimpleFoam.C

@@ -81,8 +81,6 @@ Note
 #include "pimpleControl.H"
 #include "CorrectPhi.H"
 #include "fvOptions.H"
-#include "localEulerDdtScheme.H"
-#include "fvcSmooth.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -109,12 +107,6 @@ int main(int argc, char *argv[])
 
     turbulence->validate();
 
-    if (!LTS)
-    {
-        #include "CourantNo.H"
-        #include "setInitialDeltaT.H"
-    }
-
     // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
     Info<< "\nStarting time loop\n" << endl;
@@ -122,16 +114,8 @@ int main(int argc, char *argv[])
     while (runTime.run())
     {
         #include "readDyMControls.H"
-
-        if (LTS)
-        {
-            #include "setRDeltaT.H"
-        }
-        else
-        {
-            #include "CourantNo.H"
-            #include "setDeltaT.H"
-        }
+        #include "CourantNo.H"
+        #include "setDeltaT.H"
 
         ++runTime;
 

applications/solvers/incompressible/pimpleFoam/setRDeltaT.H

@@ -1,69 +0,0 @@
-{
-    volScalarField& rDeltaT = trDeltaT.ref();
-
-    const dictionary& pimpleDict = pimple.dict();
-
-    scalar maxCo
-    (
-        pimpleDict.getOrDefault<scalar>("maxCo", 0.8)
-    );
-
-    scalar rDeltaTSmoothingCoeff
-    (
-        pimpleDict.getOrDefault<scalar>("rDeltaTSmoothingCoeff", 0.02)
-    );
-
-    scalar rDeltaTDampingCoeff
-    (
-        pimpleDict.getOrDefault<scalar>("rDeltaTDampingCoeff", 1.0)
-    );
-
-    scalar maxDeltaT
-    (
-        pimpleDict.getOrDefault<scalar>("maxDeltaT", GREAT)
-    );
-
-    volScalarField rDeltaT0("rDeltaT0", rDeltaT);
-
-    // Set the reciprocal time-step from the local Courant number
-    rDeltaT.ref() = max
-    (
-        1/dimensionedScalar("maxDeltaT", dimTime, maxDeltaT),
-        fvc::surfaceSum(mag(phi))()()
-       /((2*maxCo)*mesh.V())
-    );
-
-    // Update the boundary values of the reciprocal time-step
-    rDeltaT.correctBoundaryConditions();
-
-    Info<< "Flow time scale min/max = "
-        << gMin(1/rDeltaT.primitiveField())
-        << ", " << gMax(1/rDeltaT.primitiveField()) << endl;
-
-    if (rDeltaTSmoothingCoeff < 1.0)
-    {
-        fvc::smooth(rDeltaT, rDeltaTSmoothingCoeff);
-    }
-
-    Info<< "Smoothed flow time scale min/max = "
-        << gMin(1/rDeltaT.primitiveField())
-        << ", " << gMax(1/rDeltaT.primitiveField()) << endl;
-
-    // Limit rate of change of time scale
-    // - reduce as much as required
-    // - only increase at a fraction of old time scale
-    if
-    (
-        rDeltaTDampingCoeff < 1.0
-     && runTime.timeIndex() > runTime.startTimeIndex() + 1
-    )
-    {
-        rDeltaT =
-            rDeltaT0
-           *max(rDeltaT/rDeltaT0, scalar(1) - rDeltaTDampingCoeff);
-
-        Info<< "Damped flow time scale min/max = "
-            << gMin(1/rDeltaT.primitiveField())
-            << ", " << gMax(1/rDeltaT.primitiveField()) << endl;
-    }
-}

applications/solvers/incompressible/simpleFoam/overSimpleFoam/createOversetFields.H

@@ -24,7 +24,3 @@ bool adjustFringe
 (
     simple.dict().getOrDefault("oversetAdjustPhi", false)
 );
-bool massFluxInterpolation
-(
-    simple.dict().getOrDefault("massFluxInterpolation", false)
-);

applications/solvers/incompressible/simpleFoam/overSimpleFoam/pEqn.H

@@ -1,5 +1,5 @@
 {
-    surfaceScalarField faceMask(localMin<scalar>(mesh).interpolate(cellMask));
+    //surfaceScalarField faceMask(localMin<scalar>(mesh).interpolate(cellMask));
 
     volScalarField rAU(1.0/UEqn.A());
     surfaceScalarField rAUf("rAUf", faceMask*fvc::interpolate(rAU));
@@ -7,12 +7,6 @@
     volVectorField HbyA("HbyA", U);
     HbyA = constrainHbyA(cellMask*rAU*UEqn.H(), U, p);
 
-    //mesh.interpolate(HbyA);
-    if (massFluxInterpolation)
-    {
-        #include "interpolatedFaces.H"
-    }
-
     tUEqn.clear();
 
     surfaceScalarField phiHbyA("phiHbyA", fvc::flux(HbyA));

applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/VoFSolidificationMeltingSource/VoFSolidificationMeltingSource.C

@@ -123,7 +123,7 @@ Foam::fv::VoFSolidificationMeltingSource::VoFSolidificationMeltingSource
 )
 :
     fv::cellSetOption(sourceName, modelType, dict, mesh),
-    alphaSolidT_(Function1<scalar>::New("alphaSolidT", coeffs_, &mesh)),
+    alphaSolidT_(Function1<scalar>::New("alphaSolidT", coeffs_)),
     L_("L", dimEnergy/dimMass, coeffs_),
     relax_(coeffs_.getOrDefault("relax", 0.9)),
     Cu_(coeffs_.getOrDefault<scalar>("Cu", 100000)),

applications/solvers/multiphase/compressibleInterFoam/compressibleInterFilmFoam/VoFSolidificationMeltingSource/VoFSolidificationMeltingSourceIO.C

@@ -33,7 +33,7 @@ bool Foam::fv::VoFSolidificationMeltingSource::read(const dictionary& dict)
 {
     if (fv::cellSetOption::read(dict))
     {
-        alphaSolidT_ = Function1<scalar>::New("alphaSolidT", coeffs_, &mesh_);
+        alphaSolidT_ = Function1<scalar>::New("alphaSolidT", coeffs_);
         coeffs_.readEntry("L", L_);
         coeffs_.readIfPresent("relax", relax_);
         coeffs_.readIfPresent("Cu", Cu_);

applications/solvers/multiphase/compressibleInterFoam/overCompressibleInterDyMFoam/createFields.H

@@ -129,10 +129,5 @@ compressibleInterPhaseTransportModel turbulence
 // Mask field for zeroing out contributions on hole cells
 #include "createCellMask.H"
 
-surfaceScalarField faceMask
-(
-    localMin<scalar>(mesh).interpolate(cellMask)
-);
-
 // Create bool field with interpolated cells
 #include "createInterpolatedCells.H"

applications/solvers/multiphase/compressibleInterFoam/overCompressibleInterDyMFoam/overCompressibleInterDyMFoam.C

@@ -80,9 +80,6 @@ int main(int argc, char *argv[])
     #include "setRootCaseLists.H"
     #include "createTime.H"
     #include "createDynamicFvMesh.H"
-    pimpleControl pimple(mesh);
-
-    #include "createTimeControls.H"
     #include "createDyMControls.H"
     #include "createFields.H"
 
@@ -109,7 +106,7 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readControls.H"
+        #include "readDyMControls.H"
 
         if (LTS)
         {
@@ -154,25 +151,7 @@ int main(int argc, char *argv[])
                     // Update cellMask field for blocking out hole cells
                     #include "setCellMask.H"
                     #include "setInterpolatedCells.H"
-
-                    faceMask =
-                        localMin<scalar>(mesh).interpolate(cellMask.oldTime());
-
-                    // Zero Uf on old faceMask (H-I)
-                    Uf *= faceMask;
-
-                    const surfaceVectorField Uint(fvc::interpolate(U));
-                    // Update Uf and phi on new C-I faces
-                    Uf += (1-faceMask)*Uint;
-
-                    // Update Uf boundary
-                    forAll(Uf.boundaryField(), patchI)
-                    {
-                        Uf.boundaryFieldRef()[patchI] =
-                            Uint.boundaryField()[patchI];
-                    }
-
-                    phi = mesh.Sf() & Uf;
+                    #include "correctPhiFaceMask.H"
 
                     // Correct phi on individual regions
                     if (correctPhi)
@@ -182,12 +161,6 @@ int main(int argc, char *argv[])
 
                     mixture.correct();
 
-                    // Zero phi on current H-I
-                    faceMask = localMin<scalar>(mesh).interpolate(cellMask);
-
-                    phi *= faceMask;
-                    U *= cellMask;
-
                     // Make the flux relative to the mesh motion
                     fvc::makeRelative(phi, U);
 
@@ -202,10 +175,6 @@ int main(int argc, char *argv[])
             #include "alphaControls.H"
             #include "compressibleAlphaEqnSubCycle.H"
 
-            const surfaceScalarField faceMask
-            (
-                localMin<scalar>(mesh).interpolate(cellMask)
-            );
             rhoPhi *= faceMask;
 
             turbulence.correctPhasePhi();

applications/solvers/multiphase/compressibleInterFoam/overCompressibleInterDyMFoam/pEqn.H

@@ -10,19 +10,6 @@
         fvc::flux(HbyA)
     );
 
-    if (ddtCorr)
-    {
-        surfaceScalarField faceMaskOld
-        (
-            localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-        );
-        phiHbyA +=
-            MRF.zeroFilter
-            (
-                fvc::interpolate(rho*rAU)*faceMaskOld*fvc::ddtCorr(U, Uf)
-            );
-    }
-
     MRF.makeRelative(phiHbyA);
 
     surfaceScalarField phig

applications/solvers/multiphase/compressibleInterFoam/twoPhaseMixtureThermo/twoPhaseMixtureThermo.H

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2013-2017 OpenFOAM Foundation
-    Copyright (C) 2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -204,18 +203,6 @@ public:
                 const label patchi
             ) const;
 
-            //- Heat capacity using pressure and temperature
-            virtual tmp<scalarField> Cp
-            (
-                const scalarField& p,
-                const scalarField& T,
-                const labelList& cells
-            ) const
-            {
-                NotImplemented;
-                return tmp<scalarField>::New(p);
-            }
-
             //- Heat capacity at constant volume [J/kg/K]
             virtual tmp<volScalarField> Cv() const;
 
@@ -227,18 +214,6 @@ public:
                 const label patchi
             ) const;
 
-            //- Density from pressure and temperature
-            virtual tmp<scalarField> rhoEoS
-            (
-                const scalarField& p,
-                const scalarField& T,
-                const labelList& cells
-            ) const
-            {
-                NotImplemented;
-                return tmp<scalarField>::New(p);
-            }
-
             //- Gamma = Cp/Cv []
             virtual tmp<volScalarField> gamma() const;
 

applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.H

@@ -318,18 +318,6 @@ public:
                 const label patchi
             ) const;
 
-            //- Heat capacity using pressure and temperature
-            virtual tmp<scalarField> Cp
-            (
-                const scalarField& p,
-                const scalarField& T,
-                const labelList& cells
-            ) const
-            {
-                NotImplemented;
-                return tmp<scalarField>::New(p);
-            }
-
             //- Heat capacity at constant volume [J/kg/K]
             virtual tmp<volScalarField> Cv() const;
 
@@ -341,18 +329,6 @@ public:
                 const label patchi
             ) const;
 
-            //- Density from pressure and temperature
-            virtual tmp<scalarField> rhoEoS
-            (
-                const scalarField& p,
-                const scalarField& T,
-                const labelList& cells
-            ) const
-            {
-                NotImplemented;
-                return tmp<scalarField>::New(p);
-            }
-
             //- Gamma = Cp/Cv []
             virtual tmp<volScalarField> gamma() const;
 

applications/solvers/multiphase/driftFluxFoam/mixtureViscosityModels/mixtureViscosityModel/mixtureViscosityModelNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2014-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -44,9 +44,9 @@ Foam::autoPtr<Foam::mixtureViscosityModel> Foam::mixtureViscosityModel::New
 
     Info<< "Selecting incompressible transport model " << modelType << endl;
 
-    auto* ctorPtr = dictionaryConstructorTable(modelType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -58,9 +58,7 @@ Foam::autoPtr<Foam::mixtureViscosityModel> Foam::mixtureViscosityModel::New
     }
 
     return autoPtr<mixtureViscosityModel>
-    (
-        ctorPtr(name, dict, U, phi)
-    );
+        (cstrIter()(name, dict, U, phi));
 }
 
 

applications/solvers/multiphase/driftFluxFoam/relativeVelocityModels/relativeVelocityModel/relativeVelocityModel.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2014-2017 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -111,9 +111,9 @@ Foam::autoPtr<Foam::relativeVelocityModel> Foam::relativeVelocityModel::New
 
     Info<< "Selecting relative velocity model " << modelType << endl;
 
-    auto* ctorPtr = dictionaryConstructorTable(modelType);
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -127,7 +127,7 @@ Foam::autoPtr<Foam::relativeVelocityModel> Foam::relativeVelocityModel::New
     return
         autoPtr<relativeVelocityModel>
         (
-            ctorPtr
+            cstrIter()
             (
                 dict.optionalSubDict(modelType + "Coeffs"),
                 mixture

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/Make/options

@@ -11,6 +11,7 @@ EXE_INC = \
     -I$(LIB_SRC)/transportModels/compressible/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
     -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/radiation/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/thermophysicalModels/specie/lnInclude \

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/laserDTRM.C

@@ -343,12 +343,12 @@ Foam::radiation::laserDTRM::laserDTRM(const volScalarField& T)
 
     focalLaserPosition_
     (
-        Function1<point>::New("focalLaserPosition", *this, &mesh_)
+        Function1<point>::New("focalLaserPosition", *this)
     ),
 
     laserDirection_
     (
-        Function1<vector>::New("laserDirection", *this, &mesh_)
+        Function1<vector>::New("laserDirection", *this)
     ),
 
     focalLaserRadius_(get<scalar>("focalLaserRadius")),
@@ -359,7 +359,7 @@ Foam::radiation::laserDTRM::laserDTRM(const volScalarField& T)
 
     sigma_(0),
     I0_(0),
-    laserPower_(Function1<scalar>::New("laserPower", *this, &mesh_)),
+    laserPower_(Function1<scalar>::New("laserPower", *this)),
     powerDistribution_(),
 
     reflectionSwitch_(false),
@@ -441,11 +441,11 @@ Foam::radiation::laserDTRM::laserDTRM
 
     focalLaserPosition_
     (
-        Function1<point>::New("focalLaserPosition", *this, &mesh_)
+        Function1<point>::New("focalLaserPosition", *this)
     ),
     laserDirection_
     (
-        Function1<vector>::New("laserDirection", *this, &mesh_)
+        Function1<vector>::New("laserDirection", *this)
     ),
 
     focalLaserRadius_(get<scalar>("focalLaserRadius")),
@@ -456,7 +456,7 @@ Foam::radiation::laserDTRM::laserDTRM
 
     sigma_(0),
     I0_(0),
-    laserPower_(Function1<scalar>::New("laserPower", *this, &mesh_)),
+    laserPower_(Function1<scalar>::New("laserPower", *this)),
     powerDistribution_(),
 
     reflectionSwitch_(false),

applications/solvers/multiphase/icoReactingMultiphaseInterFoam/laserDTRM/reflectionModel/reflectionModel/reflectionModelNew.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,9 +41,9 @@ Foam::radiation::reflectionModel::New
 
     Info<< "Selecting reflectionModel " << modelType << endl;
 
-    auto* ctorPtr = dictionaryConstructorTable(modelType);
+    const auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -54,7 +54,7 @@ Foam::radiation::reflectionModel::New
         ) << exit(FatalIOError);
     }
 
-    return autoPtr<reflectionModel>(ctorPtr(dict, mesh));
+    return autoPtr<reflectionModel>(cstrIter()(dict, mesh));
 }
 
 

applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/interfaceHeatResistance/interfaceHeatResistance.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2020-2021 OpenCFD Ltd.
+    Copyright (C) 2020 OpenCFD Ltd.
     Copyright (C) 2020 Henning Scheufler
 -------------------------------------------------------------------------------
 License
@@ -269,14 +269,14 @@ correct()
 
     // interface heat resistance
     mDotc_ = interfaceArea_*R_*max(TSat - T, T0)/L;
-    mDote_ = interfaceArea_*R_*max(T - TSat, T0)/L;
+    mDote_ = interfaceArea_*R_*(T - TSat)/L;
 
-    // Limiting max condensation
     forAll(mDotc_, celli)
     {
         scalar rhobyDt = mixture_.rho1().value()/mesh_.time().deltaTValue();
         scalar maxEvap = mixture_.alpha1()[celli]*rhobyDt; // positive
         scalar maxCond = -mixture_.alpha2()[celli]*rhobyDt; // negative
+        mDote_[celli] = min(max(mDote_[celli], maxCond), maxEvap);
         mDotc_[celli] = min(max(mDotc_[celli], maxCond), maxEvap);
     }
 
@@ -326,6 +326,14 @@ correct()
 void Foam::temperaturePhaseChangeTwoPhaseMixtures::interfaceHeatResistance::
 updateInterface()
 {
+    const volScalarField& T = mesh_.lookupObject<volScalarField>("T");
+    const twoPhaseMixtureEThermo& thermo =
+    refCast<const twoPhaseMixtureEThermo>
+    (
+        mesh_.lookupObject<basicThermo>(basicThermo::dictName)
+    );
+
+    const dimensionedScalar& TSat = thermo.TSat();
 
     // interface heat resistance
     // Interpolating alpha1 cell centre values to mesh points (vertices)
@@ -346,6 +354,30 @@ updateInterface()
                 mag(cutCell.faceArea())/mesh_.V()[celli];
         }
     }
+
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
+    forAll(pbm, patchi)
+    {
+        if (isA<wallPolyPatch>(pbm[patchi]))
+        {
+            const polyPatch& pp = pbm[patchi];
+            forAll(pp.faceCells(),i)
+            {
+                const label pCelli = pp.faceCells()[i];
+
+                if
+                (
+                    (TSat.value() - T[pCelli]) > 0
+                  && mixture_.alpha1()[pCelli] < 0.9
+                )
+                {
+                    interfaceArea_[pCelli] =
+                        mag(pp.faceAreas()[i])/mesh_.V()[pCelli];
+                }
+            }
+        }
+    }
 }
 
 

applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/temperaturePhaseChangeTwoPhaseMixtures/temperaturePhaseChangeTwoPhaseMixtureNew.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -54,9 +54,9 @@ Foam::temperaturePhaseChangeTwoPhaseMixture::New
 
     Info<< "Selecting phaseChange model " << modelType << endl;
 
-    auto* ctorPtr = componentsConstructorTable(modelType);
+    auto cstrIter = componentsConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -70,7 +70,7 @@ Foam::temperaturePhaseChangeTwoPhaseMixture::New
     return
         autoPtr<temperaturePhaseChangeTwoPhaseMixture>
         (
-            ctorPtr(thermo, mesh)
+            cstrIter()(thermo, mesh)
         );
 }
 

applications/solvers/multiphase/interCondensatingEvaporatingFoam/temperaturePhaseChangeTwoPhaseMixtures/twoPhaseMixtureEThermo/twoPhaseMixtureEThermo.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2016-2021 OpenCFD Ltd.
+    Copyright (C) 2016-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -173,18 +173,6 @@ public:
             const label patchi
         ) const;
 
-        //- Heat capacity using pressure and temperature
-        virtual tmp<scalarField> Cp
-        (
-            const scalarField& p,
-            const scalarField& T,
-            const labelList& cells
-        ) const
-        {
-            NotImplemented;
-            return tmp<scalarField>::New(p);
-        }
-
         //- Return Cv of the mixture
         virtual tmp<volScalarField> Cv() const;
 
@@ -196,18 +184,6 @@ public:
             const label patchI
         ) const;
 
-        //- Density from pressure and temperature
-        virtual tmp<scalarField> rhoEoS
-        (
-            const scalarField& p,
-            const scalarField& T,
-            const labelList& cells
-        ) const
-        {
-            NotImplemented;
-            return tmp<scalarField>::New(p);
-        }
-
         //- Gamma = Cp/Cv []
         virtual tmp<volScalarField> gamma() const;
 

applications/solvers/multiphase/interFoam/overInterDyMFoam/CourantNo.H

@@ -36,7 +36,10 @@ scalar meanCoNum = 0.0;
 
 if (mesh.nInternalFaces())
 {
-    surfaceScalarField phiMask(localMin<scalar>(mesh).interpolate(cellMask));
+    surfaceScalarField phiMask
+    (
+        localMin<scalar>(mesh).interpolate(cellMask + interpolatedCells)
+    );
 
     scalarField sumPhi
     (

applications/solvers/multiphase/interFoam/overInterDyMFoam/createDyMControls.H

@@ -1,30 +0,0 @@
-bool correctPhi
-(
-    pimple.dict().getOrDefault("correctPhi", true)
-);
-
-bool checkMeshCourantNo
-(
-    pimple.dict().getOrDefault("checkMeshCourantNo", false)
-);
-
-bool moveMeshOuterCorrectors
-(
-    pimple.dict().getOrDefault("moveMeshOuterCorrectors", false)
-);
-
-
-bool massFluxInterpolation
-(
-    pimple.dict().getOrDefault("massFluxInterpolation", false)
-);
-
-bool adjustFringe
-(
-    pimple.dict().getOrDefault("oversetAdjustPhi", false)
-);
-
-bool ddtCorr
-(
-    pimple.dict().getOrDefault("ddtCorr", true)
-);

applications/solvers/multiphase/interFoam/overInterDyMFoam/overInterDyMFoam.C

@@ -49,13 +49,9 @@ Description
 #include "turbulentTransportModel.H"
 #include "pimpleControl.H"
 #include "fvOptions.H"
-#include "CorrectPhi.H"
 #include "fvcSmooth.H"
 #include "cellCellStencilObject.H"
 #include "localMin.H"
-#include "interpolationCellPoint.H"
-#include "transform.H"
-#include "fvMeshSubset.H"
 #include "oversetAdjustPhi.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -76,8 +72,7 @@ int main(int argc, char *argv[])
     #include "createTime.H"
     #include "createDynamicFvMesh.H"
     #include "initContinuityErrs.H"
-    pimpleControl pimple(mesh);
-    #include "createTimeControls.H"
+
     #include "createDyMControls.H"
     #include "createFields.H"
     #include "createAlphaFluxes.H"
@@ -102,6 +97,7 @@ int main(int argc, char *argv[])
         #include "correctPhi.H"
     }
     #include "createUf.H"
+    #include "createControls.H"
 
     #include "setCellMask.H"
     #include "setInterpolatedCells.H"
@@ -119,7 +115,7 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readControls.H"
+        #include "readDyMControls.H"
 
         if (LTS)
         {
@@ -164,27 +160,7 @@ int main(int argc, char *argv[])
                     // Update cellMask field for blocking out hole cells
                     #include "setCellMask.H"
                     #include "setInterpolatedCells.H"
-
-                    const surfaceScalarField faceMaskOld
-                    (
-                        localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-                    );
-
-                    // Zero Uf on old faceMask (H-I)
-                    Uf *= faceMaskOld;
-
-                    const surfaceVectorField Uint(fvc::interpolate(U));
-                    // Update Uf and phi on new C-I faces
-                    Uf += (1-faceMaskOld)*Uint;
-
-                    // Update Uf boundary
-                    forAll(Uf.boundaryField(), patchI)
-                    {
-                        Uf.boundaryFieldRef()[patchI] =
-                            Uint.boundaryField()[patchI];
-                    }
-
-                    phi = mesh.Sf() & Uf;
+                    #include "correctPhiFaceMask.H"
 
                     // Correct phi on individual regions
                     if (correctPhi)
@@ -194,17 +170,8 @@ int main(int argc, char *argv[])
 
                     mixture.correct();
 
-                    // Zero phi on current H-I
-                    const surfaceScalarField faceMask
-                    (
-                        localMin<scalar>(mesh).interpolate(cellMask)
-                    );
-                    phi *= faceMask;
-                    U   *= cellMask;
-
                     // Make the flux relative to the mesh motion
                     fvc::makeRelative(phi, U);
-
                 }
 
                 if (mesh.changing() && checkMeshCourantNo)
@@ -213,14 +180,9 @@ int main(int argc, char *argv[])
                 }
             }
 
-
             #include "alphaControls.H"
             #include "alphaEqnSubCycle.H"
 
-            const surfaceScalarField faceMask
-            (
-                localMin<scalar>(mesh).interpolate(cellMask)
-            );
             rhoPhi *= faceMask;
 
             mixture.correct();

applications/solvers/multiphase/interFoam/overInterDyMFoam/pEqn.H

@@ -1,8 +1,5 @@
 {
     rAU = 1.0/UEqn.A();
-    //mesh.interpolate(rAU);
-
-    surfaceScalarField faceMask(localMin<scalar>(mesh).interpolate(cellMask));
 
     surfaceScalarField rAUf("rAUf", fvc::interpolate(rAU));
 
@@ -12,22 +9,8 @@
     //HbyA = rAU*UEqn.H();
     HbyA = constrainHbyA(rAU*H, U, p_rgh);
 
-    if (massFluxInterpolation)
-    {
-        #include "interpolatedFaces.H"
-    }
-
     surfaceScalarField phiHbyA("phiHbyA", fvc::flux(HbyA));
 
-    if (ddtCorr)
-    {
-        surfaceScalarField faceMaskOld
-        (
-            localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-        );
-        phiHbyA +=
-            fvc::interpolate(rho*rAU)*faceMaskOld*fvc::ddtCorr(U, Uf);
-    }
     MRF.makeRelative(phiHbyA);
 
     if (p_rgh.needReference())
@@ -37,13 +20,6 @@
         fvc::makeAbsolute(phiHbyA, U);
     }
 
-    if (adjustFringe)
-    {
-        fvc::makeRelative(phiHbyA, U);
-        oversetAdjustPhi(phiHbyA, U);
-        fvc::makeAbsolute(phiHbyA, U);
-    }
-
     surfaceScalarField phig
     (
         (

applications/solvers/multiphase/interFoam/overInterDyMFoam/readControls.H

@@ -1,16 +0,0 @@
-#include "readTimeControls.H"
-
-correctPhi = pimple.dict().getOrDefault("correctPhi", false);
-
-checkMeshCourantNo =
-    pimple.dict().getOrDefault("checkMeshCourantNo", false);
-
-moveMeshOuterCorrectors =
-    pimple.dict().getOrDefault("moveMeshOuterCorrectors", false);
-
-massFluxInterpolation =
-    pimple.dict().getOrDefault("massFluxInterpolation", false);
-
-ddtCorr = pimple.dict().getOrDefault("ddtCorr", true);
-
-adjustFringe =  pimple.dict().getOrDefault("oversetAdjustPhi", false);

applications/solvers/multiphase/interIsoFoam/UEqn.H

@@ -1,35 +0,0 @@
-    MRF.correctBoundaryVelocity(U);
-
-    fvVectorMatrix UEqn
-    (
-        fvm::ddt(rho, U) + fvm::div(rhoPhi, U)
-      + MRF.DDt(rho, U)
-      + turbulence->divDevRhoReff(rho, U)
-     ==
-        fvOptions(rho, U)
-    );
-
-    #include "UEqnAddPorosity.H"
-
-    UEqn.relax();
-
-    fvOptions.constrain(UEqn);
-
-    if (pimple.momentumPredictor())
-    {
-        solve
-        (
-            UEqn
-         ==
-            fvc::reconstruct
-            (
-                (
-                    mixture.surfaceTensionForce()
-                  - ghf*fvc::snGrad(rho)
-                  - fvc::snGrad(p_rgh)
-                ) * mesh.magSf()
-            )
-        );
-
-        fvOptions.correct(U);
-    }

applications/solvers/multiphase/interIsoFoam/UEqnAddPorosity.H

@@ -1,48 +0,0 @@
-// Including porosity effects in UEqn following:
-// Jensen, B., Jacobsen, N. G., & Christensen, E. D. (2014).
-// Investigations on the porous media equations and resistance
-// coefficients for coastal structures. Coastal Engineering, 84, 56-72.
-
-if (porosityEnabled)
-{
-    const volScalarField& porosity = tporosity.cref();
-
-    const word porosityModel("JensenEtAl2014");
-    const dictionary& dict =
-        porosityProperties.subDict(porosityModel + "Coeffs");
-    const dimensionedScalar alpha(dimless/dimArea, dict.get<scalar>("alpha"));
-    const dimensionedScalar beta(dimless/dimLength, dict.get<scalar>("beta"));
-    const dimensionedScalar d50(dimless, dict.get<scalar>("d50"));
-    const dimensionedScalar KC(dimless, dict.get<scalar>("KC"));
-
-    // Generating Darcy-Forchheimer coefficient: F = rho*U*(a + b*|U|)
-    // Shoud it be mu or muEff in the equation below?
-    {
-        // Darcy term
-        volScalarField DarcyForchheimerCoeff
-        (
-            alpha*sqr(1 - porosity)*mixture.mu()/sqr(porosity)/sqr(d50)
-        );
-
-        // Adding Forchheimer term
-        DarcyForchheimerCoeff += rho*mag(U)
-            *beta*(1 + pos(KC)*7.5/KC)*(1 - porosity)/sqr(porosity)/d50;
-
-        // Adding Darcy-Forchheimer term as implicit source term
-        UEqn += fvm::Sp(DarcyForchheimerCoeff, U);
-    }
-
-    {
-        // Generating added mass force coefficient
-        const dimensionedScalar gamma_p(dimless, dict.get<scalar>("gamma_p"));
-        const volScalarField Cm(gamma_p*(1 - porosity));
-
-        UEqn += Cm*fvm::ddt(rho, U);
-        UEqn += Cm*MRF.DDt(rho, U);
-    }
-
-    // Dividing both matrix entries and source term by porosity to compensate
-    // for the fact that the FVM cell volume averages use division by cell
-    // volume V whereas only the cell pore volume, porosity*V, is accessible.
-    UEqn *= scalar(1)/porosity;
-}

applications/solvers/multiphase/interIsoFoam/alphaEqn.H

@@ -22,20 +22,8 @@
     mixture.correct();
 }
 
-scalar domainFraction = 0;
-if (porosityEnabled)
-{
-    const volScalarField& porosity = tporosity.cref();
-    rhoPhi *= scalar(1)/fvc::interpolate(porosity);
-    domainFraction = alpha1.weightedAverage(mesh.Vsc()*porosity).value();
-}
-else
-{
-    domainFraction = alpha1.weightedAverage(mesh.Vsc()).value();
-}
-
 Info<< "Phase-1 volume fraction = "
-    << domainFraction
+    << alpha1.weightedAverage(mesh.Vsc()).value()
     << "  Min(" << alpha1.name() << ") = " << min(alpha1).value()
     << "  Max(" << alpha1.name() << ") = " << max(alpha1).value()
     << endl;

applications/solvers/multiphase/interIsoFoam/createFields.H

@@ -130,6 +130,5 @@ mesh.setFluxRequired(alpha1.name());
 
 #include "createMRF.H"
 #include "createFvOptions.H"
-#include "createPorosity.H"
 
 isoAdvection advector(alpha1, phi, U);

applications/solvers/multiphase/interIsoFoam/createPorosity.H

@@ -1,34 +0,0 @@
-// Reading porosity properties from constant directory
-IOdictionary porosityProperties
-(
-    IOobject
-    (
-        "porosityProperties",
-        runTime.constant(),
-        runTime,
-        IOobject::READ_IF_PRESENT,
-        IOobject::NO_WRITE
-    )
-);
-
-const bool porosityEnabled
-(
-    porosityProperties.getOrDefault<bool>("porosityEnabled", false)
-);
-
-tmp<volScalarField> tporosity;
-if (porosityEnabled)
-{
-    tporosity = tmp<volScalarField>::New
-    (
-        IOobject
-        (
-            "porosity",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-}

applications/solvers/multiphase/interIsoFoam/interIsoFoam.C

@@ -92,7 +92,7 @@ int main(int argc, char *argv[])
     #include "initCorrectPhi.H"
     #include "createUfIfPresent.H"
 
-    #include "porousCourantNo.H"
+    #include "CourantNo.H"
     #include "setInitialDeltaT.H"
 
     // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -101,8 +101,8 @@ int main(int argc, char *argv[])
     while (runTime.run())
     {
         #include "readDyMControls.H"
-        #include "porousCourantNo.H"
-        #include "porousAlphaCourantNo.H"
+        #include "CourantNo.H"
+        #include "alphaCourantNo.H"
         #include "setDeltaT.H"
 
         ++runTime;

applications/solvers/multiphase/interIsoFoam/porousAlphaCourantNo.H

@@ -1,69 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2021 Johan Roenby
--------------------------------------------------------------------------------
-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/>.
-
-Global
-    porousAlphaCourantNo
-
-Description
-    Calculates and outputs the mean and maximum Courant Numbers.
-
-\*---------------------------------------------------------------------------*/
-
-scalar maxAlphaCo = runTime.controlDict().get<scalar>("maxAlphaCo");
-scalar alphaCoNum = 0;
-scalar meanAlphaCoNum = 0;
-
-if (mesh.nInternalFaces())
-{
-    scalarField sumPhi
-    (
-        mixture.nearInterface()().primitiveField()
-       *fvc::surfaceSum(mag(phi))().primitiveField()
-    );
-
-    if (porosityEnabled)
-    {
-        const volScalarField& porosity = tporosity.cref();
-
-        alphaCoNum =
-            0.5*gMax(sumPhi/mesh.V().field()/porosity)*runTime.deltaTValue();
-
-        meanAlphaCoNum =
-            0.5*(gSum(sumPhi)/gSum(mesh.V().field()*porosity))
-           *runTime.deltaTValue();
-    }
-    else
-    {
-        alphaCoNum = 0.5*gMax(sumPhi/mesh.V().field())*runTime.deltaTValue();
-
-        meanAlphaCoNum =
-            0.5*(gSum(sumPhi)/gSum(mesh.V().field()))*runTime.deltaTValue();
-    }
-}
-
-Info<< "Interface Courant Number mean: " << meanAlphaCoNum
-    << " max: " << alphaCoNum << endl;
-
-// ************************************************************************* //

applications/solvers/multiphase/interIsoFoam/porousCourantNo.H

@@ -1,67 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2021 Johan Roenby
--------------------------------------------------------------------------------
-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/>.
-
-Global
-    porousCourantNo
-
-Description
-    Calculates and outputs the mean and maximum Courant Numbers.
-
-\*---------------------------------------------------------------------------*/
-
-scalar CoNum = 0;
-scalar meanCoNum = 0;
-
-{
-    scalarField sumPhi
-    (
-        fvc::surfaceSum(mag(phi))().primitiveField()
-    );
-
-    if (porosityEnabled)
-    {
-        const volScalarField& porosity = tporosity.cref();
-
-        CoNum =
-            0.5*gMax(sumPhi/mesh.V().field()/porosity)
-           *runTime.deltaTValue();
-
-        meanCoNum =
-            0.5*(gSum(sumPhi)/gSum(mesh.V().field()*porosity))
-           *runTime.deltaTValue();
-    }
-    else
-    {
-        CoNum = 0.5*gMax(sumPhi/mesh.V().field())*runTime.deltaTValue();
-
-        meanCoNum =
-            0.5*(gSum(sumPhi)/gSum(mesh.V().field()))*runTime.deltaTValue();
-    }
-}
-
-Info<< "Courant Number mean: " << meanCoNum
-    << " max: " << CoNum << endl;
-
-// ************************************************************************* //

applications/solvers/multiphase/interPhaseChangeFoam/overInterPhaseChangeDyMFoam/createFields.H

@@ -149,10 +149,5 @@ surfaceScalarField alphaPhi10
 // Mask field for zeroing out contributions on hole cells
 #include "createCellMask.H"
 
-surfaceScalarField faceMask
-(
-    localMin<scalar>(mesh).interpolate(cellMask)
-);
-
 // Create bool field with interpolated cells
 #include "createInterpolatedCells.H"

applications/solvers/multiphase/interPhaseChangeFoam/overInterPhaseChangeDyMFoam/overInterPhaseChangeDyMFoam.C

@@ -82,9 +82,7 @@ int main(int argc, char *argv[])
     #include "setRootCaseLists.H"
     #include "createTime.H"
     #include "createDynamicFvMesh.H"
-    pimpleControl pimple(mesh);
 
-    #include "createTimeControls.H"
     #include "createDyMControls.H"
     #include "initContinuityErrs.H"
     #include "createFields.H"
@@ -118,7 +116,7 @@ int main(int argc, char *argv[])
 
     while (runTime.run())
     {
-        #include "readControls.H"
+        #include "readDyMControls.H"
 
         // Store divU from the previous mesh so that it can be mapped
         // and used in correctPhi to ensure the corrected phi has the
@@ -153,26 +151,7 @@ int main(int argc, char *argv[])
                      // Update cellMask field for blocking out hole cells
                     #include "setCellMask.H"
                     #include "setInterpolatedCells.H"
-
-                    faceMask =
-                        localMin<scalar>(mesh).interpolate(cellMask.oldTime());
-
-
-                    // Zero Uf on old faceMask (H-I)
-                    Uf *= faceMask;
-
-                    const surfaceVectorField Uint(fvc::interpolate(U));
-                    // Update Uf and phi on new C-I faces
-                    Uf += (1-faceMask)*Uint;
-
-                    // Update Uf boundary
-                    forAll(Uf.boundaryField(), patchI)
-                    {
-                        Uf.boundaryFieldRef()[patchI] =
-                            Uint.boundaryField()[patchI];
-                    }
-
-                    phi = mesh.Sf() & Uf;
+                    #include "correctPhiFaceMask.H"
 
                     if (correctPhi)
                     {
@@ -181,12 +160,6 @@ int main(int argc, char *argv[])
 
                     mixture->correct();
 
-                    // Zero phi on current H-I
-                    faceMask = localMin<scalar>(mesh).interpolate(cellMask);
-
-                    phi *= faceMask;
-                    U   *= cellMask;
-
                     // Make the flux relative to the mesh motion
                     fvc::makeRelative(phi, U);
                 }

applications/solvers/multiphase/interPhaseChangeFoam/overInterPhaseChangeDyMFoam/pEqn.H

@@ -8,16 +8,6 @@
         fvc::flux(HbyA)
     );
 
-
-    if (ddtCorr)
-    {
-        surfaceScalarField faceMaskOld
-        (
-            localMin<scalar>(mesh).interpolate(cellMask.oldTime())
-        );
-        phiHbyA += faceMaskOld*fvc::ddtCorr(U, Uf);
-    }
-
     if (p_rgh.needReference())
     {
         fvc::makeRelative(phiHbyA, U);

applications/solvers/multiphase/interPhaseChangeFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixtureNew.C

@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2015 OpenFOAM Foundation
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -56,9 +56,9 @@ Foam::phaseChangeTwoPhaseMixture::New
 
     Info<< "Selecting phaseChange model " << modelType << endl;
 
-    auto* ctorPtr = componentsConstructorTable(modelType);
+    auto cstrIter = componentsConstructorTablePtr_->cfind(modelType);
 
-    if (!ctorPtr)
+    if (!cstrIter.found())
     {
         FatalIOErrorInLookup
         (
@@ -69,7 +69,7 @@ Foam::phaseChangeTwoPhaseMixture::New
         ) << exit(FatalIOError);
     }
 
-    return autoPtr<phaseChangeTwoPhaseMixture>(ctorPtr(U, phi));
+    return autoPtr<phaseChangeTwoPhaseMixture>(cstrIter()(U, phi));
 }
 
 

applications/test/DynamicList2/Make/files

@@ -1,3 +0,0 @@
-Test-DynamicList2.C
-
-EXE = $(FOAM_USER_APPBIN)/Test-DynamicList2

applications/test/DynamicList2/Make/options

@@ -1,2 +0,0 @@
-/* EXE_INC = */
-/* EXE_LIBS = */

applications/test/DynamicList2/Test-DynamicList2.C

@@ -1,155 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2021 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
-    Test allocation patterns when reading into an existing list.
-
-\*---------------------------------------------------------------------------*/
-
-#include "DynamicList.H"
-#include "DynamicField.H"
-#include "IOstreams.H"
-#include "ITstream.H"
-#include "OTstream.H"
-#include "StringStream.H"
-#include "FlatOutput.H"
-#include "ListOps.H"
-#include "labelRange.H"
-#include "labelIndList.H"
-
-using namespace Foam;
-
-template<class T, int SizeMin>
-void printInfo
-(
-    const word& tag,
-    const DynamicList<T, SizeMin>& list,
-    const bool showSize = true
-)
-{
-    Info<< '<' << tag;
-    if (showSize)
-    {
-        Info<< " size=\"" << list.size()
-            << "\" capacity=\"" << list.capacity() << "\"";
-        if (list.cdata())
-        {
-            Info<< " ptr=\"" << name(list.cdata()) << "\"";
-        }
-        else
-        {
-            Info<< " ptr=\"nullptr\"";
-        }
-    }
-    Info<< '>' << nl << flatOutput(list) << nl
-        << "</" << tag << ">\n" << endl;
-}
-
-
-template<class T, int SizeMin>
-void printInfo
-(
-    const word& tag,
-    const DynamicField<T, SizeMin>& list,
-    const bool showSize = true
-)
-{
-    Info<< '<' << tag;
-    if (showSize)
-    {
-        Info<< " size=\"" << list.size()
-            << "\" capacity=\"" << list.capacity() << "\"";
-        if (list.cdata())
-        {
-            Info<< " ptr=\"" << name(list.cdata()) << "\"";
-        }
-        else
-        {
-            Info<< " ptr=\"nullptr\"";
-        }
-    }
-    Info<< '>' << nl << flatOutput(list) << nl
-        << "</" << tag << ">\n" << endl;
-}
-
-
-template<class T, int SizeMin>
-void readList
-(
-    DynamicList<T, SizeMin>& output,
-    const UList<T>& input
-)
-{
-    OTstream os;
-    os << input;
-    ITstream is("input", os.tokens());
-
-    is >> output;
-}
-
-template<class T, int SizeMin>
-void readList
-(
-    DynamicField<T, SizeMin>& output,
-    const UList<T>& input
-)
-{
-    OTstream os;
-    os << input;
-    ITstream is("input", os.tokens());
-
-    is >> output;
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-// Main program:
-
-int main(int argc, char *argv[])
-{
-    //
-    {
-        DynamicList<label, 64> list1;
-
-        list1.resize(4);
-        ListOps::identity(list1);
-
-        list1.resize(3);
-        printInfo("", list1);
-
-        // list1.clear();
-        // printInfo("", list1);
-
-        list1.setCapacity(3);
-        printInfo("", list1);
-    }
-
-    Info<< "\nEnd\n";
-
-    return 0;
-}
-
-
-// ************************************************************************* //

applications/test/Function1/case1/constant/function1Properties

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
@@ -138,53 +138,4 @@ cosine6
 }
 
 
-expr1
-{
-    type expression;
-
-    functions<scalar>
-    {
-        func1 constant 21;
-        func2 constant 15;
-        sin   constant -5;
-    }
-
-    functions<vector>
-    {
-        vfunc3 constant (1 2 3);
-        vfunc4 constant (3 2 1);
-    }
-
-    expression
-    #{
-        100 * fn:vfunc3() & fn:vfunc4() * (vector::z) .z()
-      * (fn:sin(arg()) + fn:func1(fn:func2()))
-    #};
-}
-
-
-expr2
-{
-    type expression;
-
-    functions<scalar>
-    {
-        func1 constant 21;
-        func2 constant 15;
-        sin   constant -5;
-    }
-
-    functions<vector>
-    {
-        vfunc3 constant (1 2 3);
-        vfunc4 constant (3 2 1);
-    }
-
-    expression
-    #{
-        (fn:vfunc3() & vector::z) * arg()
-    #};
-}
-
-
 // ************************************************************************* //

applications/test/Function1/case1/system/controlDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/Hashing2/hashingTests

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/List/Test-List.C

@@ -48,9 +48,7 @@ See also
 #include "scalarList.H"
 #include "HashOps.H"
 #include "ListOps.H"
-#include "IndirectList.H"
 #include "SubList.H"
-#include "SliceList.H"
 #include "ListPolicy.H"
 
 #include <list>
@@ -346,7 +344,7 @@ int main(int argc, char *argv[])
         labelList longLabelList = identity(25);
         reverse(longLabelList);
 
-        FixedList<label, 6> fixedLabelList({0,1,2,3,4,5});
+        FixedList<label, 6> fixedLabelList{0,1,2,3,4,5};
         const labelList constLabelList = identity(25);
 
         Info<< "full-list: " << flatOutput(longLabelList) << nl;
@@ -355,36 +353,6 @@ int main(int argc, char *argv[])
         Info<<"sub range:" << range1 << "=";
         Info<< SubList<label>(longLabelList, range1) << nl;
 
-        {
-            // A valid range
-            const labelRange subset(4, 5);
-
-            // Assign some values
-            longLabelList.slice(subset) = identity(subset.size());
-
-            Info<<"assigned identity in range:" << subset
-                << "=> " << flatOutput(longLabelList) << nl;
-
-            labelList someList(identity(24));
-
-            longLabelList.slice(subset) =
-                SliceList<label>(someList, sliceRange(8, subset.size(), 2));
-
-            Info<<"assigned sliced/stride in range:" << subset
-                << "=> " << flatOutput(longLabelList) << nl;
-
-            // Does not work - need a reference, not a temporary
-            // Foam::reverse(longLabelList[subset]);
-
-            {
-                auto sub(longLabelList.slice(subset));
-                Foam::reverse(sub);
-            }
-
-            Info<<"reversed range:" << subset
-                << "=> " << flatOutput(longLabelList) << nl;
-        }
-
         labelRange range2(7, 8);
         Info<<"sub range:" << range2 << "=";
         Info<< SubList<label>(longLabelList, range2) << nl;
@@ -400,29 +368,29 @@ int main(int argc, char *argv[])
         // > constLabelList[labelRange(23,5)] = 5;
 
         // Check correct overlaps
-        longLabelList.slice(labelRange(-10, 12)) = 200;
-        longLabelList.slice({18,3}) = 100;
-        longLabelList.slice({23,3}) = 400;
+        longLabelList[labelRange(-10, 12)] = 200;
+        longLabelList[{18,3}] = 100;
+        longLabelList[{23,3}] = 400;
         // and complete misses
-        longLabelList.slice({500,50}) = 100;
+        longLabelList[{500,50}] = 100;
 
         // -ve size suppressed by internal 'validateRange' = no-op
-        longLabelList.slice({5,-5}) = 42;
-        longLabelList.slice({21,100}) = 42;
+        longLabelList[{5,-5}] = 42;
+        longLabelList[{21,100}] = 42;
 
         //Good: does not compile
-        longLabelList.slice(labelRange(20,50)) = constLabelList;
+        //> longLabelList[labelRange(20,50)] = constLabelList;
 
         //Good: does not compile
         // longLabelList[labelRange(20,50)] = fixedLabelList;
 
-        Info<< "updated: " << constLabelList.slice(labelRange(23,5)) << nl;
+        Info<< "updated: " << constLabelList[labelRange(23,5)] << nl;
         Info<< "updated: " << flatOutput(longLabelList) << nl;
 
-        //Nope: sort(longLabelList.slice(labelRange(18,5)));
+        //Nope: sort(longLabelList[labelRange(18,5)]);
         {
             // Instead
-            auto sub = longLabelList.slice(labelRange(8));
+            UList<label> sub = longLabelList[labelRange(8)];
             sort(sub);
         }
         Info<< "sub-sorted: " << flatOutput(longLabelList) << nl;

applications/test/PDRblockMesh/Test-PDRblockMesh.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2019-2021 OpenCFD Ltd.
+    Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -180,7 +180,7 @@ int main(int argc, char *argv[])
 
     // Fatal with FULLDEBUG
     {
-        const bool oldThrowingError = FatalError.throwing(true);
+        const bool throwingError = FatalError.throwExceptions();
 
         const label nx = mesh.sizes().x();
         const label ny = mesh.sizes().y();
@@ -230,7 +230,7 @@ int main(int argc, char *argv[])
                 << err.message().c_str() << nl;
         }
 
-        FatalError.throwing(oldThrowingError);
+        FatalError.throwExceptions(throwingError);
     }
 
 

applications/test/PDRblockMesh/box0/system/PDRblockMeshDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PDRblockMesh/box0/system/controlDict

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PDRblockMesh/box0/system/fvSchemes

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PDRblockMesh/box0/system/fvSolution

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PackedList1/Test-PackedList1.C

@@ -6,7 +6,6 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
     Copyright (C) 2011-2016 OpenFOAM Foundation
-    Copyright (C) 2018-2021 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -172,7 +171,7 @@ int main(int argc, char *argv[])
         Info<< "\ntest operator[] non-const with out-of-range index\n";
 
         // Expect failure
-        const bool oldThrowingError = FatalError.throwing(true);
+        const bool throwingError = FatalError.throwExceptions();
 
         try
         {
@@ -191,7 +190,7 @@ int main(int argc, char *argv[])
             Info<< "Failed (expected) " << err << nl << endl;
         }
 
-        FatalError.throwing(oldThrowingError);
+        FatalError.throwExceptions(throwingError);
         report(list1);
     }
 
@@ -199,7 +198,7 @@ int main(int argc, char *argv[])
         Info<< "\ntest operator[] with out-of-range index\n";
 
         // Expect failure
-        const bool oldThrowingError = FatalError.throwing(true);
+        const bool throwingError = FatalError.throwExceptions();
 
         try
         {
@@ -213,7 +212,7 @@ int main(int argc, char *argv[])
             Info<< "Failed (expected) " << err << nl << endl;
         }
 
-        FatalError.throwing(oldThrowingError);
+        FatalError.throwExceptions(throwingError);
         report(list1);
     }
 
@@ -269,7 +268,7 @@ int main(int argc, char *argv[])
 
     // Expect failure
     {
-        const bool oldThrowingError = FatalError.throwing(true);
+        const bool throwingError = FatalError.throwExceptions();
 
         Info<< "\ntest operator[] assignment with auto-vivify\n";
 
@@ -287,7 +286,7 @@ int main(int argc, char *argv[])
             list1.set(36, list1.max_value);
         }
 
-        FatalError.throwing(oldThrowingError);
+        FatalError.throwExceptions(throwingError);
         report(list1);
     }
 

applications/test/PatchFunction1/function1Properties

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  v2112                                 |
+|  \\    /   O peration     | Version:  v2106                                 |
 |   \\  /    A nd           | Website:  www.openfoam.com                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

applications/test/PrecisionAdaptor/Make/files

@@ -1,3 +0,0 @@
-Test-PrecisionAdaptor.C
-
-EXE = $(FOAM_USER_APPBIN)/Test-PrecisionAdaptor

applications/test/PrecisionAdaptor/Make/options

@@ -1,2 +0,0 @@
-/* EXE_INC = */
-/* EXE_LIBS = */

applications/test/PrecisionAdaptor/Test-PrecisionAdaptor.C

@@ -1,111 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | www.openfoam.com
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-    Copyright (C) 2021 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-PrecisionAdaptor
-
-Description
-
-\*---------------------------------------------------------------------------*/
-
-#include "argList.H"
-#include "primitiveFields.H"
-#include "PrecisionAdaptor.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-int main(int argc, char *argv[])
-{
-    Field<double> content1(8);
-    Field<double> content2(8);
-
-    forAll(content1, i)
-    {
-        content1[i] = 10 * i;
-        content2[i] = 10 * i;
-    }
-
-    Foam::reverse(content2);
-
-    ConstPrecisionAdaptor<float, double, Field> cadaptor1;
-
-    cadaptor1.set(content1);
-    cadaptor1.commit();  // This is a no-op
-    Info<< "wrapped: " << cadaptor1() << nl;
-
-    cadaptor1.set(content2);
-    Info<< "wrapped: " << cadaptor1() << nl;
-
-    Info<< nl;
-
-    PrecisionAdaptor<float, double, Field> adaptor2;
-
-    adaptor2.set(content1);
-    adaptor2.ref() *= 2;
-    adaptor2.commit();  // Propagate changes back to input now
-
-    Info<< "modified wrapped: " << adaptor2() << nl;
-
-    adaptor2.set(content2);
-    adaptor2.ref() *= 2;
-    adaptor2.commit();  // Propagate changes back to input now
-
-    Info<< "modified wrapped: " << adaptor2() << nl;
-    Info<< "source: " << content1 << nl;
-    Info<< "source: " << content2 << nl;
-
-
-    content2 *= 2;
-    Info<< nl
-        << "set with " << content2 << nl;
-    Info<< "wrapped was " << adaptor2() << nl;
-    adaptor2.set(content2);
-    Info<< "wrapped now " << adaptor2() << nl;
-    Info<< "source: " << content2 << nl;
-
-    // Can even do this
-    Foam::reverse(adaptor2.ref());
-
-    adaptor2.ref() *= 2;
-    adaptor2.set(content1);  // implicit commit
-    Info<< "updated: " << content2 << nl;
-
-    Info<< nl
-        << "input: " << content1 << nl;
-
-    adaptor2.ref() *= 2;
-    adaptor2.clear();  // discard
-    adaptor2.commit();
-
-    Info<< "unchanged: " << content1 << nl;
-
-    Info<< nl << "Done" << nl << endl;
-    return 0;
-}
-
-
-// ************************************************************************* //

applications/test/Random/Test-Random.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2018-2021 OpenCFD Ltd.
+    Copyright (C) 2018-2019 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -271,7 +271,7 @@ int main(int argc, char *argv[])
 
 
     // This should fail (in FULLDEBUG)
-    const bool oldThrowingError = FatalError.throwing(true);
+    const bool throwingError = FatalError.throwExceptions();
     try
     {
         Info<<"Random position(10,5): "
@@ -282,7 +282,7 @@ int main(int argc, char *argv[])
         Info<< "Caught FatalError " << err << nl << endl;
     }
 
-    FatalError.throwing(oldThrowingError);
+    FatalError.throwExceptions(throwingError);
 
     Info<< "\nDone" << nl << endl;
 

applications/test/argList/Test-argList.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2017-2021 OpenCFD Ltd.
+    Copyright (C) 2017-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -40,7 +40,7 @@ void predicateTests_label(const word& optName, const argList& args)
 {
     Info<< "predicate tests for " << optName << nl;
 
-    const bool oldThrowingError = FatalError.throwing(true);
+    const bool throwingError = FatalError.throwExceptions();
     try
     {
         label val;
@@ -52,7 +52,7 @@ void predicateTests_label(const word& optName, const argList& args)
             << err << nl << endl;
     }
 
-    FatalError.throwing(oldThrowingError);
+    FatalError.throwExceptions(throwingError);
 }
 
 
@@ -60,7 +60,7 @@ void predicateTests_scalar(const word& optName, const argList& args)
 {
     Info<< "predicate tests for " << optName << nl;
 
-    const bool oldThrowingError = FatalError.throwing(true);
+    const bool throwingError = FatalError.throwExceptions();
     try
     {
         scalar val;
@@ -72,7 +72,7 @@ void predicateTests_scalar(const word& optName, const argList& args)
             << err << nl << endl;
     }
 
-    FatalError.throwing(oldThrowingError);
+    FatalError.throwExceptions(throwingError);
 }
 
 
@@ -121,9 +121,6 @@ int main(int argc, char *argv[])
     argList::addArgument("label");
     argList::noMandatoryArgs();
 
-    argList::addDryRunOption("Just for testing");
-    argList::addVerboseOption("Increase verbosity");
-
     #include "setRootCase.H"
 
     Pout<< "command-line ("
@@ -136,10 +133,6 @@ int main(int argc, char *argv[])
         << "globalPath: " << args.globalPath() << nl
         << nl;
 
-    Pout<< "dry-run: " << args.dryRun()
-        << " verbose: " << args.verbose() << nl;
-
-
     if (args.found("relative"))
     {
         Pout<< "input path: " << args["relative"] << nl