convergenceControl: Store solve index per-field not per-entry

Resolves bug report https://bugs.openfoam.org/view.php?id=3173

applications/solvers/combustion/PDRFoam/PDRModels/turbulence/PDRkEpsilon/PDRkEpsilon.C

@@ -146,7 +146,7 @@ void PDRkEpsilon::correct()
     volScalarField GR(drag.Gk());
 
     volScalarField LI
-        (C4_*(Lobs + dimensionedScalar("minLength", dimLength, vSmall)));
+        (C4_*(Lobs + dimensionedScalar("minLength", dimLength, rootVSmall)));
 
     // Dissipation equation
     tmp<fvScalarMatrix> epsEqn

applications/solvers/combustion/PDRFoam/pEqn.H

@@ -11,7 +11,7 @@ if (pimple.transonic())
         fvc::interpolate(psi)
        *(
             fvc::flux(HbyA)
-          + fvc::interpolate(rho*rAU)*fvc::ddtCorr(rho, U, phi)
+          + fvc::interpolate(betav*rho*rAU)*fvc::ddtCorr(rho, U, phi)
            /fvc::interpolate(rho)
         )
     );
@@ -42,7 +42,7 @@ else
         "phiHbyA",
         (
             fvc::flux(rho*HbyA)
-          + fvc::interpolate(rho*rAU)*fvc::ddtCorr(rho, U, phi)
+          + fvc::interpolate(betav*rho*rAU)*fvc::ddtCorr(rho, U, phi)
         )
     );
 

applications/solvers/heatTransfer/buoyantBoussinesqPimpleFoam/buoyantBoussinesqPimpleFoam.C

@@ -48,7 +48,7 @@ Description
 #include "fvCFD.H"
 #include "singlePhaseTransportModel.H"
 #include "turbulentTransportModel.H"
-#include "radiationModel.H"
+#include "noRadiation.H"
 #include "fvOptions.H"
 #include "pimpleControl.H"
 

applications/solvers/heatTransfer/buoyantBoussinesqSimpleFoam/buoyantBoussinesqSimpleFoam.C

@@ -48,7 +48,7 @@ Description
 #include "fvCFD.H"
 #include "singlePhaseTransportModel.H"
 #include "turbulentTransportModel.H"
-#include "radiationModel.H"
+#include "noRadiation.H"
 #include "fvOptions.H"
 #include "simpleControl.H"
 

applications/solvers/heatTransfer/chtMultiRegionFoam/fluid/pEqn.H

@@ -22,7 +22,7 @@ surfaceScalarField phiHbyA
 
 MRF.makeRelative(fvc::interpolate(rho), phiHbyA);
 
-const bool closedVolume = adjustPhi(phiHbyA, U, p_rgh);
+const bool closedVolume = mesh.steady() && adjustPhi(phiHbyA, U, p_rgh);
 const bool adjustMass = closedVolume && !thermo.incompressible();
 
 phiHbyA += phig;

applications/solvers/incompressible/pimpleFoam/pimpleFoam.C

@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Application
-    pimpleDyMFoam.C
+    pimpleFoam
 
 Description
     Transient solver for incompressible, turbulent flow of Newtonian fluids,

applications/solvers/multiphase/compressibleInterFoam/twoPhaseMixtureThermo/twoPhaseMixtureThermo.C

@@ -350,6 +350,25 @@ Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureThermo::kappa
 }
 
 
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureThermo::alphahe() const
+{
+    return
+        alpha1()*thermo1_->alphahe()
+      + alpha2()*thermo2_->alphahe();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseMixtureThermo::alphahe
+(
+    const label patchi
+) const
+{
+    return
+        alpha1().boundaryField()[patchi]*thermo1_->alphahe(patchi)
+      + alpha2().boundaryField()[patchi]*thermo2_->alphahe(patchi);
+}
+
+
 Foam::tmp<Foam::volScalarField> Foam::twoPhaseMixtureThermo::kappaEff
 (
     const volScalarField& alphat

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

@@ -266,6 +266,12 @@ public:
                 const label patchi
             ) const;
 
+            //- Thermal diffusivity for energy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alphahe() const;
+
+            //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alphahe(const label patchi) const;
+
             //- Effective thermal diffusivity of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappaEff
             (

applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.C

@@ -603,6 +603,45 @@ Foam::tmp<Foam::scalarField> Foam::multiphaseMixtureThermo::kappa
 }
 
 
+Foam::tmp<Foam::volScalarField> Foam::multiphaseMixtureThermo::alphahe() const
+{
+    PtrDictionary<phaseModel>::const_iterator phasei = phases_.begin();
+
+    tmp<volScalarField> talphaEff(phasei()*phasei().thermo().alphahe());
+
+    for (++phasei; phasei != phases_.end(); ++phasei)
+    {
+        talphaEff.ref() += phasei()*phasei().thermo().alphahe();
+    }
+
+    return talphaEff;
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::multiphaseMixtureThermo::alphahe
+(
+    const label patchi
+) const
+{
+    PtrDictionary<phaseModel>::const_iterator phasei = phases_.begin();
+
+    tmp<scalarField> talphaEff
+    (
+        phasei().boundaryField()[patchi]
+       *phasei().thermo().alphahe(patchi)
+    );
+
+    for (++phasei; phasei != phases_.end(); ++phasei)
+    {
+        talphaEff.ref() +=
+            phasei().boundaryField()[patchi]
+           *phasei().thermo().alphahe(patchi);
+    }
+
+    return talphaEff;
+}
+
+
 Foam::tmp<Foam::volScalarField> Foam::multiphaseMixtureThermo::kappaEff
 (
     const volScalarField& alphat

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

@@ -397,6 +397,12 @@ public:
                 const label patchi
             ) const;
 
+            //- Thermal diffusivity for energy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alphahe() const;
+
+            //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alphahe(const label patchi) const;
+
             //- Effective thermal diffusivity of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappaEff
             (

applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/MovingPhaseModel/MovingPhaseModel.H

@@ -201,15 +201,6 @@ public:
             virtual void divU(tmp<volScalarField> divU);
 
 
-        // Transport (prevents compiler warnings)
-
-            //- Return the effective thermal conductivity
-            using BasePhaseModel::kappaEff;
-
-            //- Return the effective thermal conductivity for enthalpy
-            using BasePhaseModel::alphaEff;
-
-
         // Turbulence
 
             //- Return the turbulent dynamic viscosity
@@ -224,17 +215,23 @@ public:
             //- Return the effective kinematic viscosity
             virtual tmp<volScalarField> nuEff() const;
 
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture for patch [J/m/s/K]
+            using BasePhaseModel::kappaEff;
+
             //- Return the effective thermal conductivity
             virtual tmp<volScalarField> kappaEff() const;
 
             //- Return the effective thermal conductivity on a patch
             virtual tmp<scalarField> kappaEff(const label patchi) const;
 
-            //- Return the effective thermal diffusivity for enthalpy
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
+            using BasePhaseModel::alphaEff;
+
+            //- Return the effective thermal diffusivity
             virtual tmp<volScalarField> alphaEff() const;
 
-            //- Return the effective thermal conductivity for enthalpy on a
-            //  patch
+            //- Return the effective thermal conductivity on a patch
             virtual tmp<scalarField> alphaEff(const label patchi) const;
 
             //- Return the turbulent kinetic energy

applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/StationaryPhaseModel/StationaryPhaseModel.H

@@ -171,15 +171,6 @@ public:
             virtual void divU(tmp<volScalarField> divU);
 
 
-        // Transport (prevents compiler warnings)
-
-            //- Return the effective thermal conductivity
-            using BasePhaseModel::kappaEff;
-
-            //- Return the effective thermal conductivity for enthalpy
-            using BasePhaseModel::alphaEff;
-
-
         // Turbulence
 
             //- Return the turbulent dynamic viscosity
@@ -194,17 +185,23 @@ public:
             //- Return the effective kinematic viscosity
             virtual tmp<volScalarField> nuEff() const;
 
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture for patch [J/m/s/K]
+            using BasePhaseModel::kappaEff;
+
             //- Return the effective thermal conductivity
             virtual tmp<volScalarField> kappaEff() const;
 
             //- Return the effective thermal conductivity on a patch
             virtual tmp<scalarField> kappaEff(const label patchi) const;
 
-            //- Return the effective thermal diffusivity for enthalpy
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
+            using BasePhaseModel::alphaEff;
+
+            //- Return the effective thermal diffusivity
             virtual tmp<volScalarField> alphaEff() const;
 
-            //- Return the effective thermal conductivity for enthalpy on a
-            //  patch
+            //- Return the effective thermal conductivity on a patch
             virtual tmp<scalarField> alphaEff(const label patchi) const;
 
             //- Return the turbulent kinetic energy

applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/ThermoPhaseModel/ThermoPhaseModel.C

@@ -153,6 +153,25 @@ Foam::ThermoPhaseModel<BasePhaseModel, ThermoType>::kappa
 }
 
 
+template<class BasePhaseModel, class ThermoType>
+Foam::tmp<Foam::volScalarField>
+Foam::ThermoPhaseModel<BasePhaseModel, ThermoType>::alphahe() const
+{
+    return thermo_->alphahe();
+}
+
+
+template<class BasePhaseModel, class ThermoType>
+Foam::tmp<Foam::scalarField>
+Foam::ThermoPhaseModel<BasePhaseModel, ThermoType>::alphahe
+(
+    const label patchi
+) const
+{
+    return thermo_->alphahe(patchi);
+}
+
+
 template<class BasePhaseModel, class ThermoType>
 Foam::tmp<Foam::volScalarField>
 Foam::ThermoPhaseModel<BasePhaseModel, ThermoType>::kappaEff

applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/ThermoPhaseModel/ThermoPhaseModel.H

@@ -112,56 +112,63 @@ public:
             //- Return the laminar kinematic viscosity on a patch
             virtual tmp<scalarField> nu(const label patchi) const;
 
-            //- Return the laminar thermal conductivity
+            //- Thermal diffusivity for enthalpy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alpha() const;
+
+            //- Thermal diffusivity for enthalpy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alpha(const label patchi) const;
+
+            //- Thermal diffusivity for temperature of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappa() const;
 
-            //- Return the laminar thermal conductivity on a patch
+            //- Thermal diffusivity for temperature of mixture
+            //  for patch [J/m/s/K]
             virtual tmp<scalarField> kappa(const label patchi) const;
 
-            //- Return the laminar thermal conductivity, given the turbulent
-            //  thermal diffusivity
+            //- Thermal diffusivity for energy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alphahe() const;
+
+            //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alphahe(const label patchi) const;
+
+
+        // Turbulence
+
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture for patch [J/m/s/K]
+            using BasePhaseModel::kappaEff;
+
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappaEff
             (
                 const volScalarField& alphat
             ) const;
 
-            //- Return the laminar thermal conductivity on a patch, given the
-            //  turbulent thermal diffusivity
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture for patch [J/m/s/K]
             virtual tmp<scalarField> kappaEff
             (
                 const scalarField& alphat,
                 const label patchi
             ) const;
 
-            //- Return the thermal diffusivity for enthalpy
-            virtual tmp<volScalarField> alpha() const;
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
+            using BasePhaseModel::alphaEff;
 
-            //- Return the thermal diffusivity for enthalpy on a patch
-            virtual tmp<scalarField> alpha(const label patchi) const;
-
-            //- Return the effective thermal diffusivity for enthalpy, given the
-            //  turbulent thermal diffusivity
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
             virtual tmp<volScalarField> alphaEff
             (
                 const volScalarField& alphat
             ) const;
 
-            //- Return the effective thermal diffusivity for enthalpy on a
-            //  patch, given the turbulent thermal diffusivity
+            //- Effective thermal turbulent diffusivity of mixture
+            //  for patch [kg/m/s]
             virtual tmp<scalarField> alphaEff
             (
                 const scalarField& alphat,
                 const label patchi
             ) const;
-
-
-        // Turbulence (prevents compiler warnings)
-
-            //- Return the effective thermal conductivity
-            using BasePhaseModel::kappaEff;
-
-            //- Return the effective thermal conductivity for enthalpy
-            using BasePhaseModel::alphaEff;
 };
 
 

applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/phaseModel/phaseModel.H

@@ -327,42 +327,48 @@ public:
             //- Return the laminar kinematic viscosity on a patch
             virtual tmp<scalarField> nu(const label patchi) const = 0;
 
-            //- Return the laminar thermal conductivity
+            //- Thermal diffusivity for enthalpy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alpha() const = 0;
+
+            //- Thermal diffusivity for enthalpy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alpha(const label patchi) const = 0;
+
+            //- Thermal diffusivity for temperature of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappa() const = 0;
 
-            //- Return the laminar thermal conductivity on a patch
+            //- Thermal diffusivity for temperature of mixture
+            //  for patch [J/m/s/K]
             virtual tmp<scalarField> kappa(const label patchi) const = 0;
 
-            //- Return the effective thermal conductivity, given the turbulent
-            //  thermal diffusivity
+            //- Thermal diffusivity for energy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alphahe() const = 0;
+
+            //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alphahe(const label patchi) const = 0;
+
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappaEff
             (
                 const volScalarField& alphat
             ) const = 0;
 
-            //- Return the effective thermal conductivity on a patch, given the
-            //  turbulent thermal diffusivity
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture for patch [J/m/s/K]
             virtual tmp<scalarField> kappaEff
             (
                 const scalarField& alphat,
                 const label patchi
             ) const = 0;
 
-            //- Return the laminar thermal diffusivity for enthalpy
-            virtual tmp<volScalarField> alpha() const = 0;
-
-            //- Return the laminar thermal diffusivity for enthalpy on a patch
-            virtual tmp<scalarField> alpha(const label patchi) const = 0;
-
-            //- Return the effective thermal diffusivity for enthalpy, given the
-            //  turbulent thermal diffusivity
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
             virtual tmp<volScalarField> alphaEff
             (
                 const volScalarField& alphat
             ) const = 0;
 
-            //- Return the effective thermal diffusivity for enthalpy on a
-            //  patch, given the turbulent thermal diffusivity
+            //- Effective thermal turbulent diffusivity of mixture
+            //  for patch [kg/m/s]
             virtual tmp<scalarField> alphaEff
             (
                 const scalarField& alphat,
@@ -384,17 +390,19 @@ public:
             //- Return the effective kinematic viscosity
             virtual tmp<volScalarField> nuEff() const = 0;
 
-            //- Return the effective thermal conductivity
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappaEff() const = 0;
 
-            //- Return the effective thermal conductivity on a patch
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture for patch [J/m/s/K]
             virtual tmp<scalarField> kappaEff(const label patchi) const = 0;
 
-            //- Return the effective thermal diffusivity for enthalpy
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
             virtual tmp<volScalarField> alphaEff() const = 0;
 
-            //- Return the effective thermal conductivity for enthalpy on a
-            //  patch
+            //- Effective thermal turbulent diffusivity of mixture
+            //  for patch [kg/m/s]
             virtual tmp<scalarField> alphaEff(const label patchi) const = 0;
 
             //- Return the turbulent kinetic energy

applications/solvers/multiphase/reactingEulerFoam/reactingMultiphaseEulerFoam/EEqns.H

@@ -12,8 +12,10 @@ for (int Ecorr=0; Ecorr<nEnergyCorrectors; Ecorr++)
         phaseModel& phase = fluid.anisothermalPhases()[anisothermalPhasei];
 
         const volScalarField& alpha = phase;
-        const volScalarField& rho = phase.rho();
-        const volVectorField& U = phase.U();
+        tmp<volScalarField> tRho = phase.rho();
+        const volScalarField& rho = tRho();
+        tmp<volVectorField> tU = phase.U();
+        const volVectorField& U = tU();
 
         fvScalarMatrix EEqn
         (

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/phaseModel/phaseModel.H

@@ -196,19 +196,45 @@ public:
             return thermo_->mu(patchi);
         }
 
-        //- Return the thermal conductivity on a patch
+        //- Thermal diffusivity for enthalpy of mixture [kg/m/s]
+        tmp<volScalarField> alpha() const
+        {
+            return thermo_->alpha();
+        }
+
+        //- Thermal diffusivity for enthalpy of mixture for patch [kg/m/s]
+        tmp<scalarField> alpha(const label patchi) const
+        {
+            return thermo_->alpha(patchi);
+        }
+
+        //- Thermal diffusivity for temperature of mixture [J/m/s/K]
         tmp<scalarField> kappa(const label patchi) const
         {
             return thermo_->kappa(patchi);
         }
 
-        //- Return the thermal conductivity
+        //- Thermal diffusivity for temperature of mixture
+        //  for patch [J/m/s/K]
         tmp<volScalarField> kappa() const
         {
             return thermo_->kappa();
         }
 
-        //- Return the laminar thermal conductivity
+        //- Thermal diffusivity for energy of mixture [kg/m/s]
+        tmp<volScalarField> alphahe() const
+        {
+            return thermo_->alphahe();
+        }
+
+        //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
+        tmp<scalarField> alphahe(const label patchi) const
+        {
+            return thermo_->alphahe(patchi);
+        }
+
+        //- Effective thermal turbulent diffusivity for temperature
+        //  of mixture [J/m/s/K]
         tmp<volScalarField> kappaEff
         (
             const volScalarField& alphat
@@ -217,7 +243,8 @@ public:
             return thermo_->kappaEff(alphat);
         }
 
-        //- Return the laminar thermal conductivity on a patch
+        //- Effective thermal turbulent diffusivity for temperature
+        //  of mixture for patch [J/m/s/K]
         tmp<scalarField> kappaEff
         (
             const scalarField& alphat,
@@ -227,19 +254,7 @@ public:
             return thermo_->kappaEff(alphat, patchi);
         }
 
-        //- Return the laminar thermal diffusivity for enthalpy
-        tmp<volScalarField> alpha() const
-        {
-            return thermo_->alpha();
-        }
-
-        //- Return the laminar thermal diffusivity for enthalpy on a patch
-        tmp<scalarField> alpha(const label patchi) const
-        {
-            return thermo_->alpha(patchi);
-        }
-
-        //- Return the effective thermal diffusivity for enthalpy
+        //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
         tmp<volScalarField> alphaEff
         (
             const volScalarField& alphat
@@ -248,7 +263,8 @@ public:
             return thermo_->alphaEff(alphat);
         }
 
-        //- Return the effective thermal diffusivity for enthalpy on a patch
+        //- Effective thermal turbulent diffusivity of mixture
+        //  for patch [kg/m/s]
         tmp<scalarField> alphaEff
         (
             const scalarField& alphat,

applications/utilities/mesh/conversion/ansysToFoam/ansysToFoam.C

@@ -0,0 +1,31 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    ansysToFoam
+
+Description
+    Converts an ANSYS input mesh file, exported from I-DEAS,
+    to OpenFOAM format.
+
+\*---------------------------------------------------------------------------*/

applications/utilities/mesh/conversion/ansysToFoam/ansysToFoam.L

@@ -21,13 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-Application
-    ansysToFoam
-
-Description
-    Converts an ANSYS input mesh file, exported from I-DEAS,
-    to OpenFOAM format.
-
 \*---------------------------------------------------------------------------*/
 
 %{

applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.C

@@ -0,0 +1,30 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    fluent3DMeshToFoam
+
+Description
+    Converts a Fluent mesh to OpenFOAM format.
+
+\*---------------------------------------------------------------------------*/

applications/utilities/mesh/conversion/fluent3DMeshToFoam/fluent3DMeshToFoam.L

@@ -21,12 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-Application
-    fluent3DMeshToFoam
-
-Description
-    Converts a Fluent mesh to OpenFOAM format.
-
 \*---------------------------------------------------------------------------*/
 
 %{

applications/utilities/mesh/conversion/fluentMeshToFoam/fluentMeshToFoam.C

@@ -0,0 +1,31 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    fluentMeshToFoam
+
+Description
+    Converts a Fluent mesh to OpenFOAM format
+    including multiple region and region boundary handling.
+
+\*---------------------------------------------------------------------------*/

applications/utilities/mesh/conversion/fluentMeshToFoam/fluentMeshToFoam.L

@@ -21,13 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-Application
-    fluentMeshToFoam
-
-Description
-    Converts a Fluent mesh to OpenFOAM format
-    including multiple region and region boundary handling.
-
 \*---------------------------------------------------------------------------*/
 
 %{

applications/utilities/mesh/conversion/gambitToFoam/gambitToFoam.C

@@ -0,0 +1,30 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    gambitToFoam
+
+Description
+    Converts a GAMBIT mesh to OpenFOAM format.
+
+\*---------------------------------------------------------------------------*/

applications/utilities/mesh/conversion/gambitToFoam/gambitToFoam.L

@@ -21,12 +21,6 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-Application
-    gambitToFoam
-
-Description
-    Converts a GAMBIT mesh to OpenFOAM format.
-
 \*---------------------------------------------------------------------------*/
 
 %{

bin/foamGet

@@ -54,7 +54,7 @@ USAGE
 
 error() {
     exec 1>&2
-    while [ "$#" -ge 1 ]; do echo "$1"; shift; done
+    while [ "$#" -ge 1 ]; do echo "Error: $1"; shift; done
     usage
     exit 1
 }
@@ -68,8 +68,8 @@ findFilesInDirs () {
         [ -d "$_d" ] && _out="$(find "$_d" -name "$_str" -type f | sort) $_out"
     done
 
-    # Remove whitespace
-    echo "$_out" | xargs -n 1
+    # Remove whitespace and blank lines
+    echo "$_out" | xargs -n 1 | awk 'NF'
 }
 
 findFiles () {
@@ -136,7 +136,7 @@ setFile () {
 noFilesMessage () {
     _ext="$1"
     [ "$_ext" = "ANY" ] && echo "(with or without file extensions)" && return 1
-    [ -n "$_ext" ] && echo "with file extension $_ext" && return 1
+    [ -n "$_ext" ] && echo "with file extension '$_ext'" && return 1
 }
 
 searchDirs="\
@@ -146,7 +146,7 @@ searchDirs="\
     $FOAM_ETC/caseDicts"
 
 ext="ANY"
-tgt="system"
+tgt=""
 while [ "$#" -gt 0 ]
 do
    case "$1" in
@@ -170,7 +170,6 @@ do
    -t | -target)
       [ "$#" -ge 2 ] || error "'$1' option requires an argument"
       tgt="$2"
-      [ -d "$tgt" ] || error "directory with -t option does not exist: '$tgt'"
       shift 2
       ;;
    -*)
@@ -183,15 +182,32 @@ do
 done
 
 [ $# -gt 1 ] && error "$# arguments \"$*\" specified: only 1 permitted"
-[ $# -eq 1 ] || error "Missing argument: no file name/prefix <file> supplied"
+[ $# -eq 1 ] || error "missing argument: no file name/prefix <file> supplied"
 prefix="$1"
 
+[ "$tgt" ] || \
+    case "$prefix" in
+       All*)
+          tgt="."
+          ;;
+       *Properties|*Cloud)
+          tgt="constant"
+          ;;
+       s)
+          tgt="0"
+          ;;
+       *)
+          tgt="system"
+          ;;
+    esac
+
 [ -s "system/controlDict" ] || \
-    error "Cannot find OpenFOAM case directory (no system/controlDict file)"
+    echo "Warning: cannot find OpenFOAM case directory (no system/controlDict file)"
+[ -d "$tgt" ] || error "target directory does not exist: '$tgt'"
 
 files="$(findFiles "$searchDirs" "$prefix" "$ext")"
 [ -z "$files" ] && \
-    error "No file $prefix found $(noFilesMessage "$ext")"
+    error "no file $prefix found $(noFilesMessage "$ext")"
 
 nFiles="$(nArgs "$files")"
 [ "$nFiles" -eq 1 ] && cpFile "$files" "$tgt" && exit 0

bin/foamInfo

@@ -39,6 +39,7 @@ options:
   -browser | -b <name> output C++ source guide web page with specified browser,
                        e.g. foamInfo -browser "firefox"
   -help    | -h        print the usage
+  -keyword | -k        uses <name> as a keyword, rather than an exact match
   -web     | -w        output C++ source guide web page with the browser
                        specified in the global controlDict file
 
@@ -49,13 +50,22 @@ Prints the following for an application, a script, or a model
 - Usage details from the header file;
 - Examples: a list of relevant cases from the tutorials directory.
 
-For example, run:
+By default, finds a case-sensitive match to <name>; otherwise, a
+case-insensitive match; otherwise, looks for a broader keyword match
+with "-keyword | -k" option.
+
+Examples:
   foamInfo simpleFoam
-  foamInfo kEpsilon
   foamInfo turbulentIntensityKineticEnergyInlet
   foamInfo fixedTemperatureConstraint
   foamInfo surfaces
   foamInfo foamNewBC
+  foamInfo wallFunction
+  foamInfo kEpsilon
+  foamInfo -k kEpsilon
+  foamInfo fixedValue
+  foamInfo -k fixedValue
+  foamInfo -k contactAngle
 
 USAGE
 }
@@ -67,6 +77,17 @@ error() {
     exit 1
 }
 
+# (1) case-sensitive match; (2) case-insensitive match; (3) keyword match
+findModelFiles() {
+    find "$FOAM_SRC" \
+        -name "$1" \
+        -iname "$2" \
+        ! -iname "$3" \
+        ! -name "*Fwd.H" \
+        ! -name "*Fields.H" \
+        ! -name "*I.H" -type f
+}
+
 findFiles() {
     _pre="$1"
 
@@ -77,20 +98,16 @@ findFiles() {
     _out="$(find "$FOAM_SRC/../bin" -name "${_pre}" -type f) $_out"
 
     # Model
-    # exact match
-    _models="$(find "$FOAM_SRC" \
-             -name "${_pre}*.H" \
-             ! -name "*Fwd.H" \
-             ! -name "*Fields.H" \
-             ! -name "*I.H" -type f)"
+    # case-sensitive match
+    _models="$(findModelFiles "${_pre}*.H" "*" "")"
 
-    # otherwise "looser" match
+    # case-insensitive match
     [ "$_models" ] || \
-        _models="$(find "$FOAM_SRC" \
-                 -iname "*${_pre}*.H" \
-                 ! -name "*Fwd.H" \
-                 ! -name "*Fields.H" \
-                 ! -name "*I.H" -type f)"
+        _models="$(findModelFiles "*" "${_pre}*.H" "")"
+
+    # keyword match
+    [ "$_models" -a ! "$KEYWORD" ] || \
+          _models="$_models $(findModelFiles "*" "*${_pre}*.H" "${_pre}*.H")"
 
     _out="$_models $_out"
 
@@ -105,7 +122,7 @@ findFiles() {
     _out="$(find "$FOAM_ETC" -name "${_pre}" -type f) $_out"
 
     # Remove whitespace
-    echo "$_out" | xargs -n 1
+    echo "$_out" | xargs -n 1 | awk 'NF'
 }
 
 nArgs() {
@@ -292,6 +309,7 @@ all=""
 # Global controlDict file
 controlDict="$(foamEtcFile controlDict 2> /dev/null)"
 BROWSER="$(grep docBrowser "$controlDict" 2> /dev/null | cut -d "\"" -f2)"
+KEYWORD=""
 
 while [ "$#" -gt 0 ]
 do
@@ -309,6 +327,10 @@ do
     -h | -help)
         usage && exit 0
         ;;
+    -k | -keyword)
+        KEYWORD="yes"
+        shift
+        ;;
     -w | -web)
         web="yes"
         shift

bin/foamUpdateCaseFileHeader

@@ -1,145 +0,0 @@
-#!/bin/sh
-#------------------------------------------------------------------------------
-# =========                 |
-# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-#  \\    /   O peration     | Website:  https://openfoam.org
-#   \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
-#    \\/     M anipulation  |
-#------------------------------------------------------------------------------
-# License
-#     This file is part of OpenFOAM.
-#
-#     OpenFOAM is free software: you can redistribute it and/or modify it
-#     under the terms of the GNU General Public License as published by
-#     the Free Software Foundation, either version 3 of the License, or
-#     (at your option) any later version.
-#
-#     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-#     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-#     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-#     for more details.
-#
-#     You should have received a copy of the GNU General Public License
-#     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-#
-# Script
-#     foamUpdateCaseFileHeader
-#
-# Description
-#     Updates the header of application files.
-#     By default, writes current version in the header.
-#     Alternatively version can be specified with -v option.
-#     Also removes consecutive blank lines from file.
-#
-#------------------------------------------------------------------------------
-error() {
-    exec 1>&2
-    while [ "$#" -ge 1 ]; do echo "$1"; shift; done
-    usage
-    exit 1
-}
-
-usage() {
-    cat<<USAGE
-
-Usage: ${0##*/} [OPTION] <file1> ... <fileN>
-
-options:
-  -version <ver>    specifies the version to be written in the header
-  -help             print the usage
-
-  Updates the header of application files and removes consecutive blank lines.
-  By default, writes current OpenFOAM version in the header.
-  An alternative version can be specified with the -version option.
-
-USAGE
-}
-
-while [ "$#" -gt 0 ]
-do
-    case "$1" in
-    -h | -help)
-        usage && exit 0
-        ;;
-    -v | -version)
-        [ "$#" -ge 2 ] || error "'$1' option requires an argument"
-        version="$2"
-        shift 2
-        ;;
-    -*)
-        error "unknown option: '$*'"
-        ;;
-    *)
-        break
-        ;;
-    esac
-done
-
-echo "$version" | grep -Eq '^([0-9]\.[0-9x]|dev)$' || \
-    error "The version number is \"${version}\"." \
-    "The format must be MAJOR.MINOR (e.g. \"$WM_PROJECT_VERSION\" or \"dev\")"
-
-# constant width for version - default to WM_PROJECT_VERSION
-version=$(printf %-36s "${version:-$WM_PROJECT_VERSION}")
-
-[ $# -ge 1 ] || error
-
-printHeader()
-{
-    cat<<HEADER
-/*--------------------------------*- C++ -*----------------------------------*\\
-  =========                 |
-| \\\\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\\\    /   O peration     | Version:  $version  |
-|   \\\\  /    A nd           | Website:  https://openfoam.org                  |
-|    \\\\/     M anipulation  |                                                 |
-\\*---------------------------------------------------------------------------*/
-FoamFile
-{
-    version     2.0;
-    format      $1;
-    class       $2;
-    object      $3;
-}
-HEADER
-}
-
-
-#
-# extract attribute '$1' from file '$2'
-#
-FoamFileAttribute()
-{
-    sed -n -e 's/[ ;]*$//' -e "s/^ *$1 *//p" "$2"
-}
-
-
-#
-# main
-#
-
-tmpFile=FoamFile.tmp$$
-for caseFile
-do
-    if grep FoamFile $caseFile >/dev/null 2>&1
-    then
-        echo "Updating case file: $caseFile"
-        sed -n '/FoamFile/,/}/p' $caseFile > $tmpFile
-
-        format=$(FoamFileAttribute format $tmpFile)
-        class=$(FoamFileAttribute  class  $tmpFile)
-        object=$(FoamFileAttribute object $tmpFile)
-
-        printHeader "$format" "$class" "$object" > $tmpFile
-
-        sed '1,/}/d' $caseFile | sed '/./,/^$/!d' >> $tmpFile
-
-        # use cat to avoid removing/replace soft-links
-        [ -s $tmpFile ] && cat $tmpFile >| $caseFile
-        rm -f $tmpFile 2>/dev/null
-    else
-        echo " Invalid case file: $caseFile" 1>&2
-    fi
-done
-
-#------------------------------------------------------------------------------

bin/paraFoam

@@ -3,7 +3,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     | Website:  https://openfoam.org
-#   \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+#   \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 # License
@@ -40,6 +40,7 @@ options:
   -block            use blockMesh reader  (uses .blockMesh extension)
   -builtin          use VTK builtin OpenFOAM reader  (uses .foam extension)
   -case <dir>       specify alternative case directory, default is the cwd
+  -empty            launch ParaView without opening any data files
   -region <name>    specify alternative mesh region
   -touch            only create the file  (eg, .blockMesh, .OpenFOAM, etc)
   -touchAll         create .blockMesh, .OpenFOAM files (and for all regions)
@@ -59,6 +60,29 @@ error() {
     exit 1
 }
 
+pvExec () {
+    _opt=""
+    [ "$ParaView_GL" = mesa ] && _opt="--mesa"
+
+    paraview $_opt "$@"
+}
+
+noPVReader () {
+    cat<<EOF
+FATAL ERROR: The official reader module for OpenFOAM data does not exist on
+your system.  This means that the version of ParaView you are using was not
+compiled with OpenFOAM, or distributed with a packaged version of OpenFOAM.
+
+For information on packaged versions of OpenFOAM/ParaView and compilation of
+OpenFOAM/ParaView, see https://openfoam.org/download
+
+Alternatively, you might be able to view your OpenFOAM data with the reader
+module provided with ParaView by running:
+    paraFoam -builtin
+
+EOF
+}
+
 # We want to do nice exit when running paraview to give paraview opportunity
 # to clean up
 unset FOAM_ABORT
@@ -96,6 +120,10 @@ do
         cd "$2" 2>/dev/null || error "directory does not exist:  '$2'"
         shift 2
         ;;
+    -empty)
+        echo "Launching ParaView without opening any files."
+        pvExec && exit 0
+        ;;
     -region)
         [ "$#" -ge 2 ] || error "'$1' option requires an argument"
         regionName=$2
@@ -125,20 +153,9 @@ do
 done
 
 # Check that reader module has been built
-if [ $requirePV -eq 1 -a ! -f "$PV_PLUGIN_PATH/libPVFoamReader_SM.so" ]
-then
-    cat<< BUILDREADER
-
-FATAL ERROR: ParaView reader module libraries do not exist
-
-Please build the reader module before continuing:
-cd \$FOAM_UTILITIES/postProcessing/graphics/PVReaders
-./Allwclean
-./Allwmake
-
-BUILDREADER
-    exit 1
-fi
+[ $requirePV -eq 1 ] && \
+    ! [ -f "$PV_PLUGIN_PATH/libPVFoamReader_SM.so" ] && \
+    noPVReader && exit 1
 
 # Check for --data=... argument
 hasDataArg()
@@ -158,7 +175,6 @@ hasDataArg()
 
 hasDataArg "$@"
 
-
 # Get a sensible caseName from the directory name
 caseName=${PWD##*/}
 caseFile="$caseName.$extension"
@@ -179,7 +195,7 @@ fi
 case "${optTouch:-false}" in
 all)
     extension=OpenFOAM
-    if [ -f system/blockMeshDict -o -f constant/polyMesh/blockMeshDict ]
+    if [ -f system/blockMeshDict ] || [ -f constant/polyMesh/blockMeshDict ]
     then
         touch "$caseName.blockMesh"
         echo "Created '$caseName.blockMesh'"
@@ -189,12 +205,10 @@ all)
     # Discover probable regions
     for region in constant/*
     do
-        if [ -d "$region" -a -d "$region"/polyMesh ]
-        then
-            regionName=${region##*/}
-            touch "$caseName{$regionName}.$extension"
+        [ -d "$region" ] && [ -d "${region}/polyMesh" ] && \
+            regionName=${region##*/} && \
+            touch "$caseName{$regionName}.$extension" && \
             echo "Created '$caseName{$regionName}.$extension'"
-        fi
     done
     exit 0
     ;;
@@ -217,7 +231,7 @@ if [ "${hasData:-false}" = true ]
 then
 
     # Has --data=.., send directly to paraview
-    exec paraview "$@"
+    pvExec "$@"
 
 else
 
@@ -235,7 +249,8 @@ else
                     $blockMeshDictDir \
                 ;
             do
-                [ -s "$parentDir/$check" ] || {
+                [ -s "$parentDir/$check" ] || [ -s "$parentDir/$check.orig" ] ||
+                {
                     [ -n "$warn" ] && echo "$warn" 1>&2
                     echo "    $parentDir/$check" 1>&2
                     unset warn
@@ -250,7 +265,8 @@ else
                     $fvControls/fvSolution \
                 ;
             do
-                [ -s "$parentDir/$check" ] || {
+                [ -s "$parentDir/$check" ] || [ -s "$parentDir/$check.orig" ] ||
+                {
                     [ -n "$warn" ] && echo "$warn" 1>&2
                     echo "    $parentDir/$check" 1>&2
                     unset warn
@@ -263,7 +279,7 @@ else
         echo "Cannot locate OpenFOAM-format case files"
         printf "Would you like to open ParaView anyway <Y|n>:"
         read open
-        [ "$open" = "" ] || echo "$open" | grep -iqE "^y" && paraview
+        [ "$open" = "" ] || echo "$open" | grep -iqE "^y" && pvExec
         exit
     }
 
@@ -275,8 +291,8 @@ else
     }
 
     # For now filter out any ld.so errors. Caused by non-system compiler?
-    paraview --data="$caseFile" "$@" 2>&1 \
-        | fgrep -v 'Inconsistency detected by ld.so'
+    pvExec --data="$caseFile" "$@" 2>&1 \
+        | grep -v -F 'Inconsistency detected by ld.so'
 fi
 
 

doc/Doxygen/Doxyfile

@@ -793,9 +793,7 @@ INPUT_ENCODING         = UTF-8
 # *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd,
 # *.vhdl, *.ucf, *.qsf, *.as and *.js.
 
-FILE_PATTERNS          = *.H \
-                         *.C \
-                         *.dox
+FILE_PATTERNS          = *.H *.C
 
 # The RECURSIVE tag can be used to specify whether or not subdirectories should
 # be searched for input files as well.
@@ -810,7 +808,11 @@ RECURSIVE              = YES
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                =
+EXCLUDE                = \
+    $(WM_PROJECT_DIR)/src/mesh/blockMesh/blockMesh/blockMesh.C \
+    $(WM_PROJECT_DIR)/src/dynamicMesh/polyTopoChange/polyTopoChange/removeFaces.C \
+    $(WM_PROJECT_DIR)/src/meshTools/sets/topoSets/topoSet.C \
+    $(WM_PROJECT_DIR)/src/conversion/polyDualMesh/polyDualMesh.C
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
@@ -1422,7 +1424,7 @@ EXT_LINKS_IN_WINDOW    = NO
 # Minimum value: 8, maximum value: 50, default value: 10.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-FORMULA_FONTSIZE       = 10
+FORMULA_FONTSIZE       = 16
 
 # Use the FORMULA_TRANPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are not
@@ -1632,7 +1634,8 @@ PAPER_TYPE             = a4wide
 # If left blank no extra packages will be included.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-EXTRA_PACKAGES         = $(WM_PROJECT_DIR)/doc/Doxygen/Macros/tensorOperator
+EXTRA_PACKAGES         = $(WM_PROJECT_DIR)/doc/Doxygen/Macros/tensorOperator \
+                         amsmath
 
 # The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
 # generated LaTeX document. The header should contain everything until the first

etc/caseDicts/general/workflow/Allclean

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# Run from this directory
+cd "${0%/*}" || exit 1
+
+# Source tutorial clean functions
+. "$WM_PROJECT_DIR/bin/tools/CleanFunctions"
+
+# Delete the following:
+# - time directories
+# - constant/polyMesh directory
+# - postProcessing and VTK directories
+# - log files
+# - field files with a ".orig" backup
+cleanCase
+
+#------------------------------------------------------------------------------

etc/caseDicts/general/workflow/Allmesh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+# Run from this directory
+cd "${0%/*}" || exit 1
+
+# Source tutorial run functions
+. "$WM_PROJECT_DIR/bin/tools/RunFunctions"
+
+# Example workflow with meshing applications
+runApplication blockMesh
+runApplication topoSet
+runApplication refineMesh -overwrite
+runApplication transformPoints -scale "(0.01 0.01 0.01)"
+
+#------------------------------------------------------------------------------

etc/caseDicts/general/workflow/Allrun

@@ -0,0 +1,33 @@
+#!/bin/sh
+
+# Run from this directory
+cd "${0%/*}" || exit 1
+
+# Source tutorial run functions
+. "$WM_PROJECT_DIR/bin/tools/RunFunctions"
+
+# Example with runApplication:
+# - runs blockMesh in background
+# - redirecting standard output to log.blockMesh
+# - does *not* run in log file already exists
+runApplication blockMesh
+
+# Example running topoSet and refineMesh 3 times with multiple dictionaries
+# -a|-append option appends to log file
+i=0
+while [ "$i" -lt 3 ]
+do
+    runApplication -a topoSet -dict "topoSetDict.${i}"
+    runApplication -a refineMesh -dict "refineMeshDict.${i}"
+    i=$(( i + 1))
+done
+
+runApplication decomposePar
+
+# Example with runParallel to run in parallel
+# getApplication finds solver name from "application" entry in controlDict
+runParallel "$(getApplication)"
+
+runApplication reconstructPar
+
+#------------------------------------------------------------------------------

etc/caseDicts/postProcessing/visualization/streamlines

@@ -10,12 +10,111 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-nLines  20;
-start   (0 -4 1e-06); // Ensure that points do not coincide with
-end     (0  4 1e-06); // mesh faces, but instead lie inside cells
-fields  (U p);
-
-// Must be last entry
 #includeEtc "caseDicts/postProcessing/visualization/streamlines.cfg"
 
+fields  (U p);
+
+// Streamline direction: forward, backward, both
+direction       both;
+
+// Select from methods with sub-dictionary settings below
+seedMethod      lineCell;
+
+// Seeding along a line
+lineCell
+{
+    type            lineCell;   // lineCellFace, lineFace
+    start           (0 -1 1);
+    end             (0  1 1);
+}
+
+lineUniform
+{
+    type            lineUniform;
+    start           (0 -1 1);
+    end             (0  1 1);
+    nPoints         50;
+}
+
+circleRandom
+{
+    type            circleRandom;
+    centre          (0 0 0);
+    radius          1;
+    normal          (1 0 0);
+    nPoints         50;
+}
+
+arcUniform
+{
+    type            arcUniform;
+    centre          (0 0 0);
+    normal          (1 0 0);
+    radial          (0 1 0);
+    startAngle      0;    // rad
+    endAngle        3.14; // rad
+    nPoints         50;
+}
+
+// Seeding within a volume region
+boxUniform
+{
+    type            boxUniform;
+    box             (-1 -1 -1) (1 1 1);
+    nPoints         (3 3 3);
+}
+
+sphereRandom
+{
+    type            sphereRandom;
+    centre          (0 0 0);
+    radius          1;
+    nPoints         50;
+}
+
+// Seeding at points on a surface
+triSurfaceMesh
+{
+    type            triSurfaceMesh;
+    surface         <surfaceMeshFile>; // in constant/triSurface directory
+}
+
+// Seeding at a boundary
+boundaryRandom
+{
+    type            boundaryRandom;
+    patches         (<patch1> <patch2>);
+    nPoints         50;
+}
+
+// Seeding a set of points
+points
+{
+    type            points;
+    points          (
+                        (0 -1 1)
+                        (0  0 1)
+                        (0  1 1)
+                    );
+    ordered         on;
+}
+
+boundaryPoints
+{
+    type            boundaryPoints;
+    points          (
+                        (0 -1 1)
+                        (0  0 1)
+                        (0  1 1)
+                    );
+    maxDistance     1;
+}
+
+// DO NOT REMOVE from END of file; sets the seedSampleSet
+seedSampleSet
+{
+    ${$seedMethod};
+    axis x;
+}
+
 // ************************************************************************* //

etc/caseDicts/postProcessing/visualization/streamlines.cfg

@@ -13,20 +13,10 @@ executeControl  writeTime;
 writeControl    writeTime;
 
 setFormat       vtk;
-direction       forward;
 
 lifeTime        10000;
 nSubCycle       5;
 
 cloudName       particleTracks;
 
-seedSampleSet
-{
-    type            lineUniform;
-    axis            x;
-    start           $start;
-    end             $end;
-    nPoints         $nLines;
-}
-
 // ************************************************************************* //

etc/caseDicts/postProcessing/visualization/surfaces

@@ -40,7 +40,7 @@ surfaces
         pointAndNormalDict
         {
             basePoint    (0 0 2); // Overrides default basePoint (0 0 0)
-            normalVector $z;      // $y: macro for (0 0 1)
+            normalVector $z;      // $z: macro for (0 0 1)
         }
     }
 

etc/config.csh/paraview

@@ -2,7 +2,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     | Website:  https://openfoam.org
-#   \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+#   \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 # License
@@ -63,6 +63,8 @@ setenv ParaView_VERSION 5.4.0
 #setenv ParaView_VERSION 5.5.0
 setenv ParaView_MAJOR detect
 
+#setenv ParaView_GL=system
+setenv ParaView_GL=mesa
 
 # Evaluate command-line parameters for ParaView
 while ( $#argv > 0 )
@@ -127,6 +129,7 @@ if ( -r $ParaView_DIR || -r $paraviewInstDir ) then
             setenv PYTHONPATH ${paraviewPython}:$ParaView_LIB_DIR
         endif
     endif
+    if ("$ParaView_GL" == mesa) alias paraview 'paraview --mesa'
 else
     unsetenv PV_PLUGIN_PATH
 endif

etc/config.sh/aliases

@@ -71,7 +71,7 @@ alias run='cd $FOAM_RUN'
 # Refresh the environment
 # ~~~~~~~~~~~~~~~~~~~~~~~
 # For backward-compatibility unalias wmRefresh if it is defined as an alias
-if declare -f wmRefresh > /dev/null
+if command -V wmRefresh 2> /dev/null | head -1 | grep -q "function"
 then
     unset wmRefresh
 else
@@ -82,7 +82,7 @@ wmRefresh()
 {
     wmProjectDir=$WM_PROJECT_DIR
     foamSettings=$FOAM_SETTINGS
-    wmUnset
+    . $wmProjectDir/etc/config.sh/unset
     . $wmProjectDir/etc/bashrc $foamSettings
 }
 

etc/config.sh/compiler

@@ -57,6 +57,12 @@ OpenFOAM | ThirdParty)
     Gcc61)
         gcc_version=gcc-6.1.0
         ;;
+    Gcc72)
+        gcc_version=gcc-7.2.0
+        ;;
+    Gcc73)
+        gcc_version=gcc-7.3.0
+        ;;
     Gcc81)
         gcc_version=gcc-8.1.0
         ;;

etc/config.sh/paraview

@@ -2,7 +2,7 @@
 # =========                 |
 # \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 #  \\    /   O peration     | Website:  https://openfoam.org
-#   \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+#   \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
 #    \\/     M anipulation  |
 #------------------------------------------------------------------------------
 # License
@@ -69,6 +69,8 @@ export ParaView_VERSION=5.4.0
 #export ParaView_VERSION=5.5.0
 export ParaView_MAJOR=detect
 
+#export ParaView_GL=system
+export ParaView_GL=mesa
 
 # Evaluate command-line parameters for ParaView
 _foamParaviewEval()
@@ -144,6 +146,8 @@ then
             export PYTHONPATH=$paraviewPython:$ParaView_LIB_DIR
         fi
     fi
+
+    [ "$ParaView_GL" = mesa ] && alias paraview="paraview --mesa"
 else
     unset PV_PLUGIN_PATH
 fi

etc/controlDict

@@ -24,7 +24,7 @@ Documentation
         "$WM_PROJECT_USER_DIR/html"
         "~OpenFOAM/html"
         "$WM_PROJECT_DIR/doc/Doxygen/html"
-        "http://cpp.openfoam.org/dev"
+        "http://cpp.openfoam.org/v6"
     );
     doxySourceFileExt "_8C.html";
 }

etc/templates/closedVolumeRotating/system/createBafflesDict

@@ -16,6 +16,8 @@ FoamFile
 
 internalFacesOnly true;
 
+fields true;
+
 baffles
 {
     baffleFaces

etc/templates/closedVolumeRotating/system/fvSolution

@@ -16,7 +16,7 @@ FoamFile
 
 solvers
 {
-    p
+    "(p|pcorr)"
     {
         solver          GAMG;
         smoother        GaussSeidel;
@@ -32,7 +32,7 @@ solvers
         relTol          0.1;
     }
 
-    pFinal
+    "(p|pcorr)Final"
     {
         $p;
         relTol         0;

etc/templates/inflowOutflowRotating/system/createBafflesDict

@@ -16,6 +16,8 @@ FoamFile
 
 internalFacesOnly true;
 
+fields true;
+
 baffles
 {
     baffleFaces

etc/templates/inflowOutflowRotating/system/fvSolution

@@ -16,7 +16,7 @@ FoamFile
 
 solvers
 {
-    p
+    "(p|pcorr)"
     {
         solver          GAMG;
         smoother        GaussSeidel;
@@ -32,7 +32,7 @@ solvers
         relTol          0.1;
     }
 
-    pFinal
+    "(p|pcorr)Final"
     {
         $p;
         relTol         0;

etc/templates/singleFluidCHT/templates/materials/air/radiationProperties

@@ -15,9 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-radiation off;
-
-radiationModel  P1;
+radiationModel  none; // P1;
 
 solverFreq 1;
 

etc/templates/singleFluidCHT/templates/materials/water/radiationProperties

@@ -15,9 +15,7 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-radiation off;
-
-radiationModel  P1;
+radiationModel  none; // P1;
 
 solverFreq 1;
 

etc/templates/singleFluidCHT/templates/materials/water/thermophysicalProperties

@@ -20,7 +20,7 @@ thermoType
     mixture         pureMixture;
     transport       const;
     thermo          hConst;
-    equationOfState perfectGas;
+    equationOfState perfectFluid;
     specie          specie;
     energy          sensibleEnthalpy;
 }
@@ -32,6 +32,11 @@ mixture
         nMoles      1;
         molWeight   18.0;       // [g/mol]
     }
+    equationOfState
+    {
+        R           3000;      // [J/(kg K)]
+        rho0        1027;      // [kg/m^3]
+    }
     thermodynamics
     {
         Cp          4181;      // [J/(kg K)] at T = 293 K

src/OpenFOAM/primitives/Pair/Pair.H

@@ -116,6 +116,7 @@ public:
                 FatalErrorInFunction
                     << "Call to other only valid for Pair with differing"
                     << " elements:" << *this << abort(FatalError);
+                return first();
             }
             else if (first() == a)
             {

src/OpenFOAM/primitives/polynomialEqns/cubicEqn/cubicEqn.C

@@ -96,7 +96,7 @@ Foam::Roots<3> Foam::cubicEqn::roots() const
 
     if (oneReal)
     {
-        const Roots<1> r = linearEqn(- a, b/3).roots();
+        const Roots<1> r = linearEqn(a, b/3).roots();
         return Roots<3>(r.type(0), r[0]);
     }
     else if (twoReal)

src/OpenFOAM/primitives/polynomialEqns/quadraticEqn/quadraticEqn.C

@@ -71,7 +71,7 @@ Foam::Roots<2> Foam::quadraticEqn::roots() const
 
     if (oneReal)
     {
-        const Roots<1> r = linearEqn(- a, b/2).roots();
+        const Roots<1> r = linearEqn(a, b/2).roots();
         return Roots<2>(r, r);
     }
     else if (twoReal)

src/TurbulenceModels/compressible/EddyDiffusivity/EddyDiffusivity.H

@@ -102,42 +102,40 @@ public:
         //- Re-read model coefficients if they have changed
         virtual bool read();
 
-        //- Return the turbulent thermal diffusivity for enthalpy [kg/m/s]
+        //- Turbulent thermal diffusivity for enthalpy [kg/m/s]
         virtual tmp<volScalarField> alphat() const
         {
             return alphat_;
         }
 
-        //- Return the turbulent thermal diffusivity for enthalpy for a patch
-        //  [kg/m/s]
+        //- Turbulent thermal diffusivity for enthalpy for a patch [kg/m/s]
         virtual tmp<scalarField> alphat(const label patchi) const
         {
             return alphat()().boundaryField()[patchi];
         }
 
-        //- Return the effective turbulent thermal diffusivity for temperature
-        //  [J/m/s/K]
+        //- Effective thermal turbulent diffusivity for temperature
+        //  of mixture [J/m/s/K]
         virtual tmp<volScalarField> kappaEff() const
         {
             return this->transport_.kappaEff(alphat());
         }
 
-        //- Return the effective turbulent thermal diffusivity for temperature
-        //  [J/m/s/K]
+        //- Effective thermal turbulent diffusivity for temperature
+        //  of mixture for patch [J/m/s/K]
         virtual tmp<scalarField> kappaEff(const label patchi) const
         {
             return this->transport_.kappaEff(alphat(patchi), patchi);
         }
 
-        //- Return the effective turbulent thermal diffusivity for enthalpy
-        //  [kg/m/s]
+        //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
         virtual tmp<volScalarField> alphaEff() const
         {
             return this->transport_.alphaEff(alphat());
         }
 
-        //- Return the effective turbulent thermal diffusivity for enthalpy
-        //  for a patch [kg/m/s]
+        //- Effective thermal turbulent diffusivity of mixture
+        //  for patch [kg/m/s]
         virtual tmp<scalarField> alphaEff(const label patchi) const
         {
             return this->transport_.alphaEff(alphat(patchi), patchi);

src/TurbulenceModels/compressible/ThermalDiffusivity/ThermalDiffusivity.H

@@ -107,65 +107,62 @@ public:
 
     // Member Functions
 
-        //- Return the thermal diffusivity for temperature [J/m/s/K]
-        virtual tmp<volScalarField> kappa() const
-        {
-            return this->transport_.kappa();
-        }
-
-        //- Return the laminar thermal diffusivity for temperature on patch
-        //  [J/m/s/K]
-        virtual tmp<scalarField> kappa(const label patchi) const
-        {
-            return this->transport_.kappa(patchi);
-        }
-
-        //- Return the laminar thermal diffusivity for enthalpy [kg/m/s]
+        //- Thermal diffusivity for enthalpy of mixture [kg/m/s]
         virtual tmp<volScalarField> alpha() const
         {
             return this->transport_.alpha();
         }
 
-        //- Return the laminar thermal diffusivity for enthalpy on patch
-        //  [kg/m/s]
+        //- Thermal diffusivity for enthalpy of mixture for patch [kg/m/s]
         virtual tmp<scalarField> alpha(const label patchi) const
         {
             return this->transport_.alpha(patchi);
         }
 
-        //- Return the turbulent thermal diffusivity for enthalpy [kg/m/s]
+        //- Thermal diffusivity for temperature of mixture [J/m/s/K]
+        virtual tmp<volScalarField> kappa() const
+        {
+            return this->transport_.kappa();
+        }
+
+        //- Thermal diffusivity for temperature of mixture
+        //  for patch [J/m/s/K]
+        virtual tmp<scalarField> kappa(const label patchi) const
+        {
+            return this->transport_.kappa(patchi);
+        }
+
+        //- Turbulent thermal diffusivity for enthalpy [kg/m/s]
         virtual tmp<volScalarField> alphat() const;
 
-        //- Return the turbulent thermal diffusivity for enthalpy for a patch
-        //  [kg/m/s]
+        //- Turbulent thermal diffusivity for enthalpy for a patch [kg/m/s]
         virtual tmp<scalarField> alphat(const label patchi) const;
 
-        //- Return the effective turbulent thermal diffusivity for temperature
-        //  [J/m/s/K]
+        //- Effective thermal turbulent diffusivity for temperature
+        //  of mixture [J/m/s/K]
         virtual tmp<volScalarField> kappaEff() const
         {
             return kappa();
         }
 
-        //- Return the effective turbulent thermal diffusivity for temperature
-        //  [J/m/s/K]
+        //- Effective thermal turbulent diffusivity for temperature
+        //  of mixture for patch [J/m/s/K]
         virtual tmp<scalarField> kappaEff(const label patchi) const
         {
             return kappa(patchi);
         }
 
-        //- Return the effective turbulent thermal diffusivity for enthalpy
-        //  [kg/m/s]
+        //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
         virtual tmp<volScalarField> alphaEff() const
         {
-            return alpha();
+            return this->transport_.alphahe();
         }
 
-        //- Return the effective turbulent thermal diffusivity for enthalpy
-        //  for a patch [kg/m/s]
+        //- Effective thermal turbulent diffusivity of mixture
+        //  for patch [kg/m/s]
         virtual tmp<scalarField> alphaEff(const label patchi) const
         {
-            return alpha(patchi);
+            return this->transport_.alphahe(patchi);
         }
 };
 

src/fileFormats/vtk/vtkUnstructuredReader.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,6 +29,7 @@ License
 #include "stringIOList.H"
 #include "cellModeller.H"
 #include "vectorIOField.H"
+#include "stringOps.H"
 
 /* * * * * * * * * * * * * * * Static Member Data  * * * * * * * * * * * * * */
 
@@ -907,6 +908,19 @@ void Foam::vtkUnstructuredReader::read(ISstream& inFile)
                 }
             }
         }
+        else if (tag == "METADATA")
+        {
+            // Read rest of the line
+            string line;
+            inFile.getLine(line);
+
+            // Skip until an empty line is found
+            inFile.getLine(line);
+            while (!stringOps::trim(line).empty())
+            {
+                inFile.getLine(line);
+            }
+        }
         else
         {
             FatalIOErrorInFunction(inFile)

src/finiteVolume/cfdTools/general/solutionControl/convergenceControl/correctorConvergenceControl/correctorConvergenceControl.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -60,7 +60,6 @@ public:
         wordRe name;
         scalar absTol;
         scalar relTol;
-        label solveIndex;
     };
 
 

src/finiteVolume/cfdTools/general/solutionControl/convergenceControl/singleRegionCorrectorConvergenceControl/singleRegionCorrectorConvergenceControl.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -96,7 +96,6 @@ bool Foam::singleRegionCorrectorConvergenceControl::readCorrResidualControls()
             rd.name = fName.c_str();
             rd.absTol = readScalar(fieldDict.lookup("tolerance"));
             rd.relTol = readScalar(fieldDict.lookup("relTol"));
-            rd.solveIndex = 0;
             data.append(rd);
         }
         else
@@ -177,11 +176,11 @@ corrCriteriaSatisfied() const
     const dictionary& solverDict = mesh_.solverPerformanceDict();
     forAllConstIter(dictionary, solverDict, iter)
     {
-        const word& variableName = iter().keyword();
+        const word& fieldName = iter().keyword();
         const label fieldi =
             convergenceControl::residualControlIndex
             (
-                variableName,
+                fieldName,
                 corrResidualControl_
             );
         if (fieldi != -1)
@@ -190,8 +189,8 @@ corrCriteriaSatisfied() const
             convergenceControl::getInitialResiduals
             (
                 mesh_,
-                variableName,
-                corrResidualControl_[fieldi].solveIndex,
+                fieldName,
+                solveIndex_.found(fieldName) ? solveIndex_[fieldName] : 0,
                 iter().stream(),
                 firstResidual,
                 residual
@@ -209,7 +208,7 @@ corrCriteriaSatisfied() const
 
             if (control_.debug)
             {
-                Info<< control_.algorithmSpace() << "  " << variableName
+                Info<< control_.algorithmSpace() << "  " << fieldName
                     << ": tolerance " << residual << " ("
                     << corrResidualControl_[fieldi].absTol << ")"
                     << ", relTol " << relativeResidual << " ("
@@ -225,10 +224,7 @@ corrCriteriaSatisfied() const
 
 void Foam::singleRegionCorrectorConvergenceControl::resetCorrSolveIndex()
 {
-    forAll(corrResidualControl_, i)
-    {
-        corrResidualControl_[i].solveIndex = 0;
-    }
+    solveIndex_.clear();
 }
 
 
@@ -237,23 +233,14 @@ void Foam::singleRegionCorrectorConvergenceControl::updateCorrSolveIndex()
     const dictionary& solverDict = mesh_.solverPerformanceDict();
     forAllConstIter(dictionary, solverDict, iter)
     {
-        const word& variableName = iter().keyword();
-        const label fieldi =
-            convergenceControl::residualControlIndex
-            (
-                variableName,
-                corrResidualControl_
-            );
-        if (fieldi != -1)
-        {
-            getNSolves
-            (
-                mesh_,
-                variableName,
-                iter().stream(),
-                corrResidualControl_[fieldi].solveIndex
-            );
-        }
+        const word& fieldName = iter().keyword();
+        getNSolves
+        (
+            mesh_,
+            fieldName,
+            iter().stream(),
+            solveIndex_(fieldName)
+        );
     }
 }
 

src/finiteVolume/cfdTools/general/solutionControl/convergenceControl/singleRegionCorrectorConvergenceControl/singleRegionCorrectorConvergenceControl.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -62,6 +62,11 @@ protected:
         //- List of residual data per field
         List<corrResidualData> corrResidualControl_;
 
+        //- The index of the solution at the start of the corrector loop, for
+        //  each field. If the field name is not in the table then the index is
+        //  assumed to be zero; i.e, the first solution.
+        HashTable<label> solveIndex_;
+
 
 public:
 

src/finiteVolume/fields/fvPatchFields/derived/freestreamPressure/freestreamPressureFvPatchScalarField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -131,13 +131,39 @@ void Foam::freestreamPressureFvPatchScalarField::updateCoeffs()
             UName_
         );
 
+    const Field<scalar> magUp(mag(Up));
+
+    const Field<vector>& nf = patch().nf();
+
+    Field<scalar>& vf = valueFraction();
+
     if (supersonic_)
     {
-        valueFraction() = 0.5 - 0.5*(Up & patch().nf())/mag(Up);
+        forAll(vf, i)
+        {
+            if (magUp[i] > vSmall)
+            {
+                vf[i] = 0.5 - 0.5*(Up[i] & nf[i])/magUp[i];
+            }
+            else
+            {
+                vf[i] = 0.5;
+            }
+        }
     }
     else
     {
-        valueFraction() = 0.5 + 0.5*(Up & patch().nf())/mag(Up);
+        forAll(vf, i)
+        {
+            if (magUp[i] > vSmall)
+            {
+                vf[i] = 0.5 + 0.5*(Up[i] & nf[i])/magUp[i];
+            }
+            else
+            {
+                vf[i] = 0.5;
+            }
+        }
     }
 
     mixedFvPatchField<scalar>::updateCoeffs();

src/finiteVolume/fields/fvPatchFields/derived/freestreamVelocity/freestreamVelocityFvPatchVectorField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2018-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -107,8 +107,23 @@ void Foam::freestreamVelocityFvPatchVectorField::updateCoeffs()
     }
 
     const Field<vector>& Up = *this;
+    const Field<scalar> magUp(mag(Up));
 
-    valueFraction() = 0.5 - 0.5*(Up & patch().nf())/mag(Up);
+    const Field<vector>& nf = patch().nf();
+
+    Field<scalar>& vf = valueFraction();
+
+    forAll(vf, i)
+    {
+        if (magUp[i] > vSmall)
+        {
+            vf[i] = 0.5 - 0.5*(Up[i] & nf[i])/magUp[i];
+        }
+        else
+        {
+            vf[i] = 0.5;
+        }
+    }
 
     mixedFvPatchField<vector>::updateCoeffs();
 }

src/finiteVolume/fields/fvPatchFields/doc/boundaryConditions.dox

@@ -1,97 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2012-2018 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-\page pageBoundaryConditions Boundary Conditions
-\ref grpBoundaryConditions are required to 'close' the simulation problem.
-Careful attention should be applied to their selection so as to create a
-well-posed system of equations, which can be solved numerically.
-
-\section secBoundaryConditionsOverview Overview
-The set of available \ref grpBoundaryConditions comprise of basic, turbulent and
-thermophysical types.
-
-\subsection secBC1 Basic boundary conditions
-    - \ref grpConstraintBoundaryConditions
-    - \ref grpInletBoundaryConditions
-    - \ref grpOutletBoundaryConditions
-    - \ref grpGenericBoundaryConditions
-    - \ref grpCoupledBoundaryConditions
-    - \ref grpWallBoundaryConditions
-
-\subsection secBC2 Turbulent flow boundary conditions
-    - \ref grpRASBoundaryConditions
-
-\subsection secBC3 Thermophysical boundary conditions
-    - \ref grpThermoBoundaryConditions
-
-
-\section secWallFunctions Wall-functions
-Wall-functions in OpenFOAM are modelled as boundary conditions, applied to
-the viscosity for momentum, and thermal diffusivity for energy.
-
-Wall-functions
-    - \ref grpWallFunctions
-
-Thermal wall-functions for incompressible flow
-    - \ref grpIcoWallFunctions
-
-Thermal wall-functions for compressible flow
-    - \ref grpCmpWallFunctions
-
-
-\section secBoundaryConditions Typical usage for pressure-velocity systems
-The choice as to the most appropriate set of boundary conditions is dictated by
-the type of flow problem.  In many cases, multiple possible selections exist;
-the following tables offer suggestions for subsonic flow.
-
-subsonic inlet (flow specified):
-\table
-    Variable             | Symbol | Type
-    pressure             | p      | \link Foam::zeroGradientFvPatchField zeroGradient\endlink
-    velocity             | U      | \link Foam::fixedValueFvPatchField fixedValue\endlink
-    transported property | -      | \link Foam::fixedValueFvPatchField fixedValue\endlink
-    derived property     | -      | \link Foam::calculatedFvPatchField calculated\endlink or \link Foam::zeroGradientFvPatchField zeroGradient\endlink
-\endtable
-
-subsonic outlet:
-\table
-    Variable             | Symbol | Type
-    pressure             | p      | \link Foam::fixedValueFvPatchField fixedValue\endlink
-    velocity             | U      | \link Foam::inletOutletFvPatchField inletOutlet\endlink or \link Foam::pressureInletOutletVelocityFvPatchVectorField pressureInletOutletVelocity\endlink
-    transported property | -      | \link Foam::inletOutletFvPatchField inletOutlet\endlink
-    derived property     | -      | \link Foam::calculatedFvPatchField calculated\endlink or \link Foam::zeroGradientFvPatchField zeroGradient\endlink
-\endtable
-
-wall (impermeable, non-slip):
-\table
-    Variable             | Symbol | Type
-    pressure             | p      | \link Foam::zeroGradientFvPatchField zeroGradient\endlink
-    velocity             | U      | \link Foam::fixedValueFvPatchField fixedValue\endlink
-    transported property | -      | \link Foam::fixedValueFvPatchField fixedValue\endlink
-    derived property     | -      | \link Foam::calculatedFvPatchField calculated\endlink or \link Foam::zeroGradientFvPatchField zeroGradient\endlink
-\endtable
-
-
-\*---------------------------------------------------------------------------*/

src/functionObjects/field/CourantNo/CourantNo.C

@@ -73,48 +73,33 @@ bool Foam::functionObjects::CourantNo::calc()
         const surfaceScalarField& phi =
             lookupObject<surfaceScalarField>(fieldName_);
 
-        tmp<volScalarField::Internal> Coi
+        tmp<volScalarField> tCo
         (
+            new volScalarField
+            (
+                IOobject
+                (
+                    resultName_,
+                    mesh_.time().timeName(),
+                    mesh_
+                ),
+                mesh_,
+                dimensionedScalar("0", dimless, 0.0),
+                zeroGradientFvPatchScalarField::typeName
+            )
+        );
+
+        tCo->ref() =
             byRho
             (
                 (0.5*mesh_.time().deltaT())
                *fvc::surfaceSum(mag(phi))()()
                /mesh_.V()
-            )
-        );
-
-        if (foundObject<volScalarField>(resultName_))
-        {
-            volScalarField& Co = lookupObjectRef<volScalarField>(resultName_);
-
-            Co.ref() = Coi();
-            Co.correctBoundaryConditions();
-        }
-        else
-        {
-            tmp<volScalarField> tCo
-            (
-                new volScalarField
-                (
-                    IOobject
-                    (
-                        resultName_,
-                        mesh_.time().timeName(),
-                        mesh_,
-                        IOobject::NO_READ,
-                        IOobject::NO_WRITE
-                    ),
-                    mesh_,
-                    dimensionedScalar("0", dimless, 0.0),
-                    zeroGradientFvPatchScalarField::typeName
-                )
             );
-            tCo.ref().ref() = Coi();
-            tCo.ref().correctBoundaryConditions();
-            mesh_.objectRegistry::store(tCo.ptr());
-        }
 
-        return true;
+        tCo->correctBoundaryConditions();
+
+        return store(resultName_, tCo);
     }
     else
     {

src/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItem.C

@@ -60,7 +60,7 @@ Foam::functionObjects::fieldAverageItem::fieldAverageItem()
     meanFieldName_("unknown"),
     prime2Mean_(0),
     prime2MeanFieldName_("unknown"),
-    base_(ITER),
+    base_(baseType::iter),
     window_(-1.0),
     windowName_("")
 {}

src/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItem.H

@@ -89,10 +89,10 @@ public:
             static const word EXT_PRIME2MEAN;
 
         //- Enumeration defining the averaging base type
-        enum baseType
+        enum class baseType
         {
-            ITER,
-            TIME
+            iter,
+            time
         };
 
 
@@ -198,16 +198,16 @@ public:
                 return baseTypeNames_[base_];
             }
 
-            //- Return true if base is ITER
+            //- Return true if base is iter
             Switch iterBase() const
             {
-                return base_ == ITER;
+                return base_ == baseType::iter;
             }
 
             //- Return true if base is time
             Switch timeBase() const
             {
-                return base_ == TIME;
+                return base_ == baseType::time;
             }
 
             scalar window() const

src/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItemIO.C

@@ -36,7 +36,7 @@ Foam::functionObjects::fieldAverageItem::fieldAverageItem(Istream& is)
     meanFieldName_("unknown"),
     prime2Mean_(0),
     prime2MeanFieldName_("unknown"),
-    base_(ITER),
+    base_(baseType::iter),
     window_(-1.0)
 {
     is.check
@@ -116,21 +116,25 @@ Foam::Ostream& Foam::functionObjects::operator<<
     );
 
     os  << faItem.fieldName_ << nl << token::BEGIN_BLOCK << nl;
-    os.writeKeyword("mean") << faItem.mean_ << token::END_STATEMENT << nl;
-    os.writeKeyword("prime2Mean") << faItem.mean_
-        << token::END_STATEMENT << nl;
-    os.writeKeyword("base") << faItem.baseTypeNames_[faItem.base_]
-        << token::END_STATEMENT << nl;
+
+    os.writeKeyword("mean")
+        << faItem.mean_ << token::END_STATEMENT << nl;
+
+    os.writeKeyword("prime2Mean")
+        << faItem.prime2Mean_ << token::END_STATEMENT << nl;
+
+    os.writeKeyword("base")
+        << faItem.baseTypeNames_[faItem.base_] << token::END_STATEMENT << nl;
 
     if (faItem.window_ > 0)
     {
-        os.writeKeyword("window") << faItem.window_
-            << token::END_STATEMENT << nl;
+        os.writeKeyword("window")
+            << faItem.window_ << token::END_STATEMENT << nl;
 
         if (faItem.windowName_ != "")
         {
-            os.writeKeyword("windowName") << faItem.windowName_
-                << token::END_STATEMENT << nl;
+            os.writeKeyword("windowName")
+                << faItem.windowName_ << token::END_STATEMENT << nl;
         }
     }
 

src/functionObjects/field/processorField/processorField.C

@@ -51,25 +51,6 @@ Foam::functionObjects::processorField::processorField
     fvMeshFunctionObject(name, runTime, dict)
 {
     read(dict);
-
-    volScalarField* procFieldPtr
-    (
-        new volScalarField
-        (
-            IOobject
-            (
-                "processorID",
-                mesh_.time().timeName(),
-                mesh_,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            mesh_,
-            dimensionedScalar("0", dimless, 0.0)
-        )
-    );
-
-    mesh_.objectRegistry::store(procFieldPtr);
 }
 
 
@@ -91,10 +72,24 @@ bool Foam::functionObjects::processorField::read(const dictionary& dict)
 
 bool Foam::functionObjects::processorField::execute()
 {
-    mesh_.lookupObjectRef<volScalarField>("processorID") ==
-        dimensionedScalar("proci", dimless, Pstream::myProcNo());
+    word name("processorID");
 
-    return true;
+    tmp<volScalarField> tprocField
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                name,
+                mesh_.time().timeName(),
+                mesh_
+            ),
+            mesh_,
+            dimensionedScalar(name, dimless, Pstream::myProcNo())
+        )
+    );
+
+    return store(name, tprocField);
 }
 
 

src/functionObjects/field/turbulenceIntensity/turbulenceIntensity.C

@@ -71,25 +71,6 @@ Foam::functionObjects::turbulenceIntensity::turbulenceIntensity
     logFiles(obr_, name),
     writeLocalObjects(obr_, log)
 {
-    volScalarField* turbulenceIntensityPtr
-    (
-        new volScalarField
-        (
-            IOobject
-            (
-                "I",
-                mesh_.time().timeName(),
-                mesh_,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            mesh_,
-            dimensionedScalar("0", dimless, 0.0)
-        )
-    );
-
-    mesh_.objectRegistry::store(turbulenceIntensityPtr);
-
     read(dict);
     resetName(typeName);
     resetLocalObjectName("I");
@@ -115,9 +96,6 @@ bool Foam::functionObjects::turbulenceIntensity::read(const dictionary& dict)
 
 bool Foam::functionObjects::turbulenceIntensity::execute()
 {
-    volScalarField& turbulenceIntensity =
-        mesh_.lookupObjectRef<volScalarField>("I");
-
     if (mesh_.foundObject<turbulenceModel>(turbulenceModel::propertiesName))
     {
         const turbulenceModel& turbModel = mesh_.lookupObject<turbulenceModel>
@@ -126,12 +104,19 @@ bool Foam::functionObjects::turbulenceIntensity::execute()
         );
 
         volScalarField uPrime(sqrt((2.0/3.0)*turbModel.k()));
-        turbulenceIntensity =
-            uPrime
-           /max
+
+        word name("I");
+
+        return
+            store
             (
-                max(uPrime, mag(turbModel.U())),
-                dimensionedScalar("small", dimVelocity, small)
+                name,
+                uPrime
+               /max
+                (
+                    max(uPrime, mag(turbModel.U())),
+                    dimensionedScalar("small", dimVelocity, small)
+                )
             );
     }
     else
@@ -139,9 +124,9 @@ bool Foam::functionObjects::turbulenceIntensity::execute()
         FatalErrorInFunction
             << "Unable to find turbulence model in the "
             << "database" << exit(FatalError);
-    }
 
-    return true;
+        return false;
+    }
 }
 
 

src/functionObjects/field/wallHeatFlux/wallHeatFlux.C

@@ -58,15 +58,30 @@ void Foam::functionObjects::wallHeatFlux::writeFileHeader(const label i)
 }
 
 
-void Foam::functionObjects::wallHeatFlux::calcHeatFlux
+Foam::tmp<Foam::volScalarField>
+Foam::functionObjects::wallHeatFlux::calcWallHeatFlux
 (
     const volScalarField& alpha,
-    const volScalarField& he,
-    volScalarField& wallHeatFlux
+    const volScalarField& he
 )
 {
+    tmp<volScalarField> twallHeatFlux
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                type(),
+                mesh_.time().timeName(),
+                mesh_
+            ),
+            mesh_,
+            dimensionedScalar("0", dimMass/pow3(dimTime), 0)
+        )
+    );
+
     volScalarField::Boundary& wallHeatFluxBf =
-        wallHeatFlux.boundaryFieldRef();
+        twallHeatFlux.ref().boundaryFieldRef();
 
     const volScalarField::Boundary& heBf =
         he.boundaryField();
@@ -97,6 +112,8 @@ void Foam::functionObjects::wallHeatFlux::calcHeatFlux
             }
         }
     }
+
+    return twallHeatFlux;
 }
 
 
@@ -114,25 +131,6 @@ Foam::functionObjects::wallHeatFlux::wallHeatFlux
     writeLocalObjects(obr_, log),
     patchSet_()
 {
-    volScalarField* wallHeatFluxPtr
-    (
-        new volScalarField
-        (
-            IOobject
-            (
-                type(),
-                mesh_.time().timeName(),
-                mesh_,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            mesh_,
-            dimensionedScalar("0", dimMass/pow3(dimTime), 0)
-        )
-    );
-
-    mesh_.objectRegistry::store(wallHeatFluxPtr);
-
     read(dict);
     resetName(typeName);
     resetLocalObjectName(typeName);
@@ -205,7 +203,7 @@ bool Foam::functionObjects::wallHeatFlux::read(const dictionary& dict)
 
 bool Foam::functionObjects::wallHeatFlux::execute()
 {
-    volScalarField& wallHeatFlux = lookupObjectRef<volScalarField>(type());
+    word name(type());
 
     if
     (
@@ -221,11 +219,10 @@ bool Foam::functionObjects::wallHeatFlux::execute()
                 turbulenceModel::propertiesName
             );
 
-        calcHeatFlux
+        return store
         (
-            turbModel.alphaEff(),
-            turbModel.transport().he(),
-            wallHeatFlux
+            name,
+            calcWallHeatFlux(turbModel.alphaEff(), turbModel.transport().he())
         );
     }
     else if (foundObject<solidThermo>(solidThermo::dictName))
@@ -233,7 +230,7 @@ bool Foam::functionObjects::wallHeatFlux::execute()
         const solidThermo& thermo =
             lookupObject<solidThermo>(solidThermo::dictName);
 
-        calcHeatFlux(thermo.alpha(), thermo.he(), wallHeatFlux);
+        return store(name, calcWallHeatFlux(thermo.alpha(), thermo.he()));
     }
     else
     {

src/functionObjects/field/wallHeatFlux/wallHeatFlux.H

@@ -108,11 +108,10 @@ protected:
         virtual void writeFileHeader(const label i);
 
         //- Calculate the heat-flux
-        void calcHeatFlux
+        tmp<volScalarField> calcWallHeatFlux
         (
             const volScalarField& alpha,
-            const volScalarField& he,
-            volScalarField& wallHeatFlux
+            const volScalarField& he
         );
 
 

src/functionObjects/field/wallHeatTransferCoeff/wallHeatTransferCoeff.C

@@ -63,15 +63,35 @@ void Foam::functionObjects::wallHeatTransferCoeff::writeFileHeader
 }
 
 
-void Foam::functionObjects::wallHeatTransferCoeff::calcHeatTransferCoeff
+Foam::tmp<Foam::volScalarField>
+Foam::functionObjects::wallHeatTransferCoeff::calcHeatTransferCoeff
 (
     const volScalarField& nu,
-    const volScalarField& nut,
-    volScalarField& wallHeatTransferCoeff
+    const volScalarField& nut
 )
 {
+    tmp<volScalarField> twallHeatTransferCoeff
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                type(),
+                mesh_.time().timeName(),
+                mesh_
+            ),
+            mesh_,
+            dimensionedScalar
+            (
+                "0",
+                dimMass/pow3(dimTime)/(dimTemperature/dimLength),
+                0
+            )
+        )
+    );
+
     volScalarField::Boundary& wallHeatTransferCoeffBf =
-        wallHeatTransferCoeff.boundaryFieldRef();
+        twallHeatTransferCoeff.ref().boundaryFieldRef();
 
     const volScalarField::Boundary& nuBf = nu.boundaryField();
     const volScalarField::Boundary& nutBf = nut.boundaryField();
@@ -84,6 +104,8 @@ void Foam::functionObjects::wallHeatTransferCoeff::calcHeatTransferCoeff
                 rho_*Cp_*(nuBf[patchi]/Prl_ + nutBf[patchi]/Prt_);
         }
     }
+
+    return twallHeatTransferCoeff;
 }
 
 
@@ -101,30 +123,6 @@ Foam::functionObjects::wallHeatTransferCoeff::wallHeatTransferCoeff
     writeLocalObjects(obr_, log),
     patchSet_()
 {
-    volScalarField* wallHeatTransferCoeffPtr
-    (
-        new volScalarField
-        (
-            IOobject
-            (
-                type(),
-                mesh_.time().timeName(),
-                mesh_,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            mesh_,
-            dimensionedScalar
-            (
-                "0",
-                dimMass/pow3(dimTime)/(dimTemperature/dimLength),
-                0
-            )
-        )
-    );
-
-    mesh_.objectRegistry::store(wallHeatTransferCoeffPtr);
-
     read(dict);
     resetName(typeName);
     resetLocalObjectName(typeName);
@@ -202,8 +200,7 @@ bool Foam::functionObjects::wallHeatTransferCoeff::read(const dictionary& dict)
 
 bool Foam::functionObjects::wallHeatTransferCoeff::execute()
 {
-    volScalarField& wallHeatTransferCoeff =
-        lookupObjectRef<volScalarField>(type());
+    word name(type());
 
     if
     (
@@ -219,11 +216,10 @@ bool Foam::functionObjects::wallHeatTransferCoeff::execute()
                 turbulenceModel::propertiesName
             );
 
-        calcHeatTransferCoeff
+        return store
         (
-            turbModel.nu(),
-            turbModel.nut(),
-            wallHeatTransferCoeff
+            name,
+            calcHeatTransferCoeff(turbModel.nu(), turbModel.nut())
         );
     }
     else
@@ -231,9 +227,9 @@ bool Foam::functionObjects::wallHeatTransferCoeff::execute()
         FatalErrorInFunction
             << "Unable to find incompressible turbulence model in the "
             << "database" << exit(FatalError);
-    }
 
-    return true;
+        return false;
+    }
 }
 
 

src/functionObjects/field/wallHeatTransferCoeff/wallHeatTransferCoeff.H

@@ -130,11 +130,10 @@ protected:
         virtual void writeFileHeader(const label i);
 
         //- Calculate the heat transfer coefficient
-        void calcHeatTransferCoeff
+        tmp<volScalarField> calcHeatTransferCoeff
         (
             const volScalarField& nu,
-            const volScalarField& nut,
-            volScalarField& wallHeatTransferCoeff
+            const volScalarField& nut
         );
 
 

src/functionObjects/field/wallShearStress/wallShearStress.C

@@ -57,25 +57,42 @@ void Foam::functionObjects::wallShearStress::writeFileHeader(const label i)
 }
 
 
-void Foam::functionObjects::wallShearStress::calcShearStress
+Foam::tmp<Foam::volVectorField>
+Foam::functionObjects::wallShearStress::calcShearStress
 (
-    const volSymmTensorField& Reff,
-    volVectorField& shearStress
+    const volSymmTensorField& Reff
 )
 {
-    shearStress.dimensions().reset(Reff.dimensions());
+    tmp<volVectorField> twallShearStress
+    (
+        new volVectorField
+        (
+            IOobject
+            (
+                type(),
+                mesh_.time().timeName(),
+                mesh_
+            ),
+            mesh_,
+            dimensionedVector("0", Reff.dimensions(), Zero)
+        )
+    );
+
+    volVectorField::Boundary& wallShearStressBf =
+        twallShearStress.ref().boundaryFieldRef();
 
     forAllConstIter(labelHashSet, patchSet_, iter)
     {
         label patchi = iter.key();
 
-        vectorField& ssp = shearStress.boundaryFieldRef()[patchi];
         const vectorField& Sfp = mesh_.Sf().boundaryField()[patchi];
         const scalarField& magSfp = mesh_.magSf().boundaryField()[patchi];
         const symmTensorField& Reffp = Reff.boundaryField()[patchi];
 
-        ssp = (-Sfp/magSfp) & Reffp;
+        wallShearStressBf[patchi] = (-Sfp/magSfp) & Reffp;
     }
+
+    return twallShearStress;
 }
 
 
@@ -93,30 +110,6 @@ Foam::functionObjects::wallShearStress::wallShearStress
     writeLocalObjects(obr_, log),
     patchSet_()
 {
-    volVectorField* wallShearStressPtr
-    (
-        new volVectorField
-        (
-            IOobject
-            (
-                type(),
-                mesh_.time().timeName(),
-                mesh_,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            mesh_,
-            dimensionedVector
-            (
-                "0",
-                sqr(dimLength)/sqr(dimTime),
-                Zero
-            )
-        )
-    );
-
-    mesh_.objectRegistry::store(wallShearStressPtr);
-
     read(dict);
     resetName(typeName);
     resetLocalObjectName(typeName);
@@ -192,9 +185,6 @@ bool Foam::functionObjects::wallShearStress::execute()
     typedef compressible::turbulenceModel cmpModel;
     typedef incompressible::turbulenceModel icoModel;
 
-    volVectorField& wallShearStress =
-        mesh_.lookupObjectRef<volVectorField>(type());
-
     tmp<volSymmTensorField> Reff;
     if (mesh_.foundObject<cmpModel>(turbulenceModel::propertiesName))
     {
@@ -217,9 +207,9 @@ bool Foam::functionObjects::wallShearStress::execute()
             << "database" << exit(FatalError);
     }
 
-    calcShearStress(Reff(), wallShearStress);
+    word name(type());
 
-    return true;
+    return store(name, calcShearStress(Reff));
 }
 
 

src/functionObjects/field/wallShearStress/wallShearStress.H

@@ -117,10 +117,9 @@ protected:
         virtual void writeFileHeader(const label i);
 
         //- Calculate the shear-stress
-        void calcShearStress
+        tmp<volVectorField> calcShearStress
         (
-            const volSymmTensorField& Reff,
-            volVectorField& shearStress
+            const volSymmTensorField& Reff
         );
 
 

src/functionObjects/field/yPlus/yPlus.C

@@ -62,12 +62,28 @@ void Foam::functionObjects::yPlus::writeFileHeader(const label i)
 }
 
 
-void Foam::functionObjects::yPlus::calcYPlus
+Foam::tmp<Foam::volScalarField> Foam::functionObjects::yPlus::calcYPlus
 (
-    const turbulenceModel& turbModel,
-    volScalarField& yPlus
+    const turbulenceModel& turbModel
 )
 {
+    tmp<volScalarField> tyPlus
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                type(),
+                mesh_.time().timeName(),
+                mesh_
+            ),
+            mesh_,
+            dimensionedScalar("0", dimless, 0.0)
+        )
+    );
+
+    volScalarField::Boundary& yPlusBf = tyPlus.ref().boundaryFieldRef();
+
     volScalarField::Boundary d = nearWallDist(mesh_).y();
 
     const volScalarField::Boundary nutBf =
@@ -81,8 +97,6 @@ void Foam::functionObjects::yPlus::calcYPlus
 
     const fvPatchList& patches = mesh_.boundary();
 
-    volScalarField::Boundary& yPlusBf = yPlus.boundaryFieldRef();
-
     forAll(patches, patchi)
     {
         const fvPatch& patch = patches[patchi];
@@ -108,6 +122,8 @@ void Foam::functionObjects::yPlus::calcYPlus
                 )/nuBf[patchi];
         }
     }
+
+    return tyPlus;
 }
 
 
@@ -124,25 +140,6 @@ Foam::functionObjects::yPlus::yPlus
     logFiles(obr_, name),
     writeLocalObjects(obr_, log)
 {
-    volScalarField* yPlusPtr
-    (
-        new volScalarField
-        (
-            IOobject
-            (
-                type(),
-                mesh_.time().timeName(),
-                mesh_,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            mesh_,
-            dimensionedScalar("0", dimless, 0.0)
-        )
-    );
-
-    mesh_.objectRegistry::store(yPlusPtr);
-
     read(dict);
     resetName(typeName);
     resetLocalObjectName(typeName);
@@ -168,9 +165,6 @@ bool Foam::functionObjects::yPlus::read(const dictionary& dict)
 
 bool Foam::functionObjects::yPlus::execute()
 {
-    volScalarField& yPlus =
-        mesh_.lookupObjectRef<volScalarField>(type());
-
     if (mesh_.foundObject<turbulenceModel>(turbulenceModel::propertiesName))
     {
         const turbulenceModel& model = mesh_.lookupObject<turbulenceModel>
@@ -178,7 +172,9 @@ bool Foam::functionObjects::yPlus::execute()
             turbulenceModel::propertiesName
         );
 
-        calcYPlus(model, yPlus);
+        word name(type());
+
+        return store(name, calcYPlus(model));
     }
     else
     {

src/functionObjects/field/yPlus/yPlus.H

@@ -95,10 +95,9 @@ class yPlus
         virtual void writeFileHeader(const label i);
 
         //- Calculate y+
-        void calcYPlus
+        tmp<volScalarField> calcYPlus
         (
-            const turbulenceModel& turbModel,
-            volScalarField& yPlus
+            const turbulenceModel& turbModel
         );
 
         //- Disallow default bitwise copy construct

src/lagrangian/basic/particle/particle.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -564,6 +564,16 @@ public:
             trackingData& td
         );
 
+        //- As above, but does not change the master patch. Needed in order for
+        //  ACMI to be able to delegate a hit to the non-overlap patch.
+        template<class TrackCloudType>
+        void hitFaceNoChangeToMasterPatch
+        (
+            const vector& displacement,
+            TrackCloudType& cloud,
+            trackingData& td
+        );
+
         //- Convenience function. Cobines trackToFace and hitFace
         template<class TrackCloudType>
         void trackToAndHitFace

src/lagrangian/basic/particle/particleTemplates.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -108,6 +108,33 @@ void Foam::particle::hitFace
     trackingData& td
 )
 {
+    if (debug)
+    {
+        Info << "Particle " << origId() << nl << FUNCTION_NAME << nl << endl;
+    }
+
+    if (onBoundaryFace())
+    {
+        changeToMasterPatch();
+    }
+
+    hitFaceNoChangeToMasterPatch(direction, cloud, td);
+}
+
+
+template<class TrackCloudType>
+void Foam::particle::hitFaceNoChangeToMasterPatch
+(
+    const vector& direction,
+    TrackCloudType& cloud,
+    trackingData& td
+)
+{
+    if (debug)
+    {
+        Info << "Particle " << origId() << nl << FUNCTION_NAME << nl << endl;
+    }
+
     typename TrackCloudType::particleType& p =
         static_cast<typename TrackCloudType::particleType&>(*this);
     typename TrackCloudType::particleType::trackingData& ttd =
@@ -123,8 +150,6 @@ void Foam::particle::hitFace
     }
     else if (onBoundaryFace())
     {
-        changeToMasterPatch();
-
         if (!p.hitPatch(cloud, ttd))
         {
             const polyPatch& patch = mesh_.boundaryMesh()[p.patch()];
@@ -392,7 +417,7 @@ void Foam::particle::hitCyclicACMIPatch
         // Move to the face associated with the non-overlap patch and redo the
         // face interaction.
         tetFacei_ = facei_ = cpp.nonOverlapPatch().start() + localFacei;
-        hitFace(direction, cloud, td);
+        hitFaceNoChangeToMasterPatch(direction, cloud, td);
     }
 }
 

src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.C

@@ -349,14 +349,14 @@ bool Foam::KinematicParcel<ParcelType>::move
 
         p.age() += dt;
 
-        if (p.onFace())
+        if (p.active() && p.onFace())
         {
             cloud.functions().postFace(p, ttd.keepParticle);
         }
 
         cloud.functions().postMove(p, dt, start, ttd.keepParticle);
 
-        if (p.onFace() && ttd.keepParticle)
+        if (p.active() && p.onFace() && ttd.keepParticle)
         {
             p.hitFace(s, cloud, ttd);
         }

src/rigidBodyDynamics/joints/composite/compositeJoint.C

@@ -52,7 +52,7 @@ namespace joints
 
 void Foam::RBD::joints::composite::setLastJoint()
 {
-    //last().joint::operator=(*this);
+    last().joint::operator=(*this);
 }
 
 

src/rigidBodyDynamics/joints/joint/joint.H

@@ -243,6 +243,9 @@ public:
 
     // Member Operators
 
+        //- Assignment
+        inline void operator=(const joint& j);
+
         //- Return the unit quaternion for this joint
         //  if it uses a quaternion representation for rotation
         inline quaternion unitQuaternion

src/rigidBodyDynamics/joints/joint/jointI.H

@@ -64,6 +64,14 @@ inline const Foam::List<Foam::spatialVector>& Foam::RBD::joint::S() const
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
+inline void Foam::RBD::joint::operator=(const joint& j)
+{
+    S_ = j.S_;
+    index_ = j.index_;
+    qIndex_ = j.qIndex_;
+}
+
+
 inline Foam::quaternion Foam::RBD::joint::unitQuaternion
 (
     const scalarField& q

src/sampling/sampledSet/lineFace/lineFace.C

@@ -124,6 +124,7 @@ void Foam::sampledSets::lineFace::calcSamples
             if (!sampleParticle.onBoundaryFace())
             {
                 FatalErrorInFunction
+                    << "Failed to associate with the starting boundary face"
                     << exit(FatalError);
             }
         }

src/thermophysicalModels/basic/basicThermo/basicThermo.H

@@ -422,21 +422,27 @@ public:
             //- Thermal diffusivity for temperature of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappa() const = 0;
 
-            //- Thermal diffusivity for temperature
-            //  of mixture for patch [J/m/s/K]
+            //- Thermal diffusivity for temperature of mixture
+            //  for patch [J/m/s/K]
             virtual tmp<scalarField> kappa
             (
                 const label patchi
             ) const = 0;
 
-            //- Effective thermal diffusivity for temperature
+            //- Thermal diffusivity for energy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alphahe() const = 0;
+
+            //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alphahe(const label patchi) const = 0;
+
+            //- Effective thermal turbulent diffusivity for temperature
             //  of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappaEff
             (
                 const volScalarField&
             ) const = 0;
 
-            //- Effective thermal diffusivity for temperature
+            //- Effective thermal turbulent diffusivity for temperature
             //  of mixture for patch [J/m/s/K]
             virtual tmp<scalarField> kappaEff
             (
@@ -444,13 +450,14 @@ public:
                 const label patchi
             ) const = 0;
 
-            //- Effective thermal diffusivity of mixture [kg/m/s]
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
             virtual tmp<volScalarField> alphaEff
             (
                 const volScalarField& alphat
             ) const = 0;
 
-            //- Effective thermal diffusivity of mixture for patch [kg/m/s]
+            //- Effective thermal turbulent diffusivity of mixture
+            //  for patch [kg/m/s]
             virtual tmp<scalarField> alphaEff
             (
                 const scalarField& alphat,

src/thermophysicalModels/basic/heThermo/heThermo.C

@@ -794,6 +794,31 @@ Foam::tmp<Foam::scalarField> Foam::heThermo<BasicThermo, MixtureType>::kappa
 }
 
 
+template<class BasicThermo, class MixtureType>
+Foam::tmp<Foam::volScalarField>
+Foam::heThermo<BasicThermo, MixtureType>::alphahe() const
+{
+    tmp<Foam::volScalarField> alphaEff(this->CpByCpv()*this->alpha_);
+    alphaEff.ref().rename("alphahe");
+    return alphaEff;
+}
+
+
+template<class BasicThermo, class MixtureType>
+Foam::tmp<Foam::scalarField>
+Foam::heThermo<BasicThermo, MixtureType>::alphahe(const label patchi) const
+{
+    return
+    this->CpByCpv
+    (
+        this->p_.boundaryField()[patchi],
+        this->T_.boundaryField()[patchi],
+        patchi
+    )
+   *this->alpha_.boundaryField()[patchi];
+}
+
+
 template<class BasicThermo, class MixtureType>
 Foam::tmp<Foam::volScalarField>
 Foam::heThermo<BasicThermo, MixtureType>::kappaEff

src/thermophysicalModels/basic/heThermo/heThermo.H

@@ -268,18 +268,27 @@ public:
             //- Thermal diffusivity for temperature of mixture [J/m/s/K]
             virtual tmp<volScalarField> kappa() const;
 
-            //- Thermal diffusivity for temperature
-            //  of mixture for patch [J/m/s/K]
+            //- Thermal diffusivity for temperature of mixture
+            //  for patch [J/m/s/K]
             virtual tmp<scalarField> kappa
             (
                 const label patchi
             ) const;
 
-            //- Effective thermal diffusivity for temperature
-            //  of mixture [J/m/s/K]
-            virtual tmp<volScalarField> kappaEff(const volScalarField&) const;
+            //- Thermal diffusivity for energy of mixture [kg/m/s]
+            virtual tmp<volScalarField> alphahe() const;
 
-            //- Effective thermal diffusivity for temperature
+            //- Thermal diffusivity for energy of mixture for patch [kg/m/s]
+            virtual tmp<scalarField> alphahe(const label patchi) const;
+
+            //- Effective thermal turbulent diffusivity for temperature
+            //  of mixture [J/m/s/K]
+            virtual tmp<volScalarField> kappaEff
+            (
+                const volScalarField&
+            ) const;
+
+            //- Effective thermal turbulent diffusivity for temperature
             //  of mixture for patch [J/m/s/K]
             virtual tmp<scalarField> kappaEff
             (
@@ -287,13 +296,14 @@ public:
                 const label patchi
             ) const;
 
-            //- Effective thermal diffusivity of mixture [kg/m/s]
+            //- Effective thermal turbulent diffusivity of mixture [kg/m/s]
             virtual tmp<volScalarField> alphaEff
             (
                 const volScalarField& alphat
             ) const;
 
-            //- Effective thermal diffusivity of mixture for patch [kg/m/s]
+            //- Effective thermal turbulent diffusivity of mixture
+            //  for patch [kg/m/s]
             virtual tmp<scalarField> alphaEff
             (
                 const scalarField& alphat,

src/thermophysicalModels/radiation/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.C

@@ -67,7 +67,8 @@ greyDiffusiveRadiationMixedFvPatchScalarField
     (
         p,
         ptf.emissivityMethod(),
-        ptf.emissivity_
+        ptf.emissivity_,
+        mapper
     ),
     TName_(ptf.TName_)
 {}
@@ -143,6 +144,27 @@ greyDiffusiveRadiationMixedFvPatchScalarField
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+void Foam::radiation::greyDiffusiveRadiationMixedFvPatchScalarField::autoMap
+(
+    const fvPatchFieldMapper& m
+)
+{
+    mixedFvPatchScalarField::autoMap(m);
+    radiationCoupledBase::autoMap(m);
+}
+
+
+void Foam::radiation::greyDiffusiveRadiationMixedFvPatchScalarField::rmap
+(
+    const fvPatchScalarField& ptf,
+    const labelList& addr
+)
+{
+    mixedFvPatchScalarField::rmap(ptf, addr);
+    radiationCoupledBase::rmap(ptf, addr);
+}
+
+
 void Foam::radiation::greyDiffusiveRadiationMixedFvPatchScalarField::
 updateCoeffs()
 {

src/thermophysicalModels/radiation/derivedFvPatchFields/greyDiffusiveRadiation/greyDiffusiveRadiationMixedFvPatchScalarField.H

@@ -171,6 +171,21 @@ public:
                 return TName_;
             }
 
+        // Mapping functions
+
+            //- Map (and resize as needed) from self given a mapping object
+            virtual void autoMap
+            (
+                const fvPatchFieldMapper&
+            );
+
+            //- Reverse map the given fvPatchField onto this fvPatchField
+            virtual void rmap
+            (
+                const fvPatchScalarField&,
+                const labelList&
+            );
+
 
         // Evaluation functions
 

src/thermophysicalModels/radiation/derivedFvPatchFields/greyDiffusiveViewFactor/greyDiffusiveViewFactorFixedValueFvPatchScalarField.C

@@ -58,9 +58,10 @@ greyDiffusiveViewFactorFixedValueFvPatchScalarField
     (
         patch(),
         ptf.emissivityMethod(),
-        ptf.emissivity_
+        ptf.emissivity_,
+        mapper
     ),
-    qro_(ptf.qro_)
+    qro_(ptf.qro_, mapper)
 {}
 
 
@@ -128,6 +129,32 @@ greyDiffusiveViewFactorFixedValueFvPatchScalarField
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+void Foam::radiation::greyDiffusiveViewFactorFixedValueFvPatchScalarField::
+autoMap
+(
+    const fvPatchFieldMapper& m
+)
+{
+    fixedValueFvPatchScalarField::autoMap(m);
+    radiationCoupledBase::autoMap(m);
+    qro_.autoMap(m);
+}
+
+
+void Foam::radiation::greyDiffusiveViewFactorFixedValueFvPatchScalarField::rmap
+(
+    const fvPatchScalarField& ptf,
+    const labelList& addr
+)
+{
+    fixedValueFvPatchScalarField::rmap(ptf, addr);
+    radiationCoupledBase::rmap(ptf, addr);
+    const greyDiffusiveViewFactorFixedValueFvPatchScalarField& mrptf =
+        refCast<const greyDiffusiveViewFactorFixedValueFvPatchScalarField>(ptf);
+
+    qro_.rmap(mrptf.qro_, addr);
+}
+
 void Foam::radiation::greyDiffusiveViewFactorFixedValueFvPatchScalarField::
 updateCoeffs()
 {

src/thermophysicalModels/radiation/derivedFvPatchFields/greyDiffusiveViewFactor/greyDiffusiveViewFactorFixedValueFvPatchScalarField.H

@@ -168,6 +168,20 @@ public:
             }
 
 
+            //- Map (and resize as needed) from self given a mapping object
+            virtual void autoMap
+            (
+                const fvPatchFieldMapper&
+            );
+
+            //- Reverse map the given fvPatchField onto this fvPatchField
+            virtual void rmap
+            (
+                const fvPatchScalarField&,
+                const labelList&
+            );
+
+
         // Evaluation functions
 
             //- Update the coefficients associated with the patch field

src/thermophysicalModels/radiation/derivedFvPatchFields/wideBandDiffusiveRadiation/wideBandDiffusiveRadiationMixedFvPatchScalarField.C

@@ -68,7 +68,8 @@ wideBandDiffusiveRadiationMixedFvPatchScalarField
     (
         p,
         ptf.emissivityMethod(),
-        ptf.emissivity_
+        ptf.emissivity_,
+        mapper
     ),
     TName_(ptf.TName_)
 {}
@@ -147,6 +148,27 @@ wideBandDiffusiveRadiationMixedFvPatchScalarField
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+void Foam::radiation::wideBandDiffusiveRadiationMixedFvPatchScalarField::
+autoMap
+(
+    const fvPatchFieldMapper& m
+)
+{
+    mixedFvPatchScalarField::autoMap(m);
+    radiationCoupledBase::autoMap(m);
+}
+
+
+void Foam::radiation::wideBandDiffusiveRadiationMixedFvPatchScalarField::rmap
+(
+    const fvPatchScalarField& ptf,
+    const labelList& addr
+)
+{
+    mixedFvPatchScalarField::rmap(ptf, addr);
+    radiationCoupledBase::rmap(ptf, addr);
+}
+
 void Foam::radiation::wideBandDiffusiveRadiationMixedFvPatchScalarField::
 updateCoeffs()
 {

src/thermophysicalModels/radiation/derivedFvPatchFields/wideBandDiffusiveRadiation/wideBandDiffusiveRadiationMixedFvPatchScalarField.H

@@ -165,6 +165,20 @@ public:
             }
 
 
+            //- Map (and resize as needed) from self given a mapping object
+            virtual void autoMap
+            (
+                const fvPatchFieldMapper&
+            );
+
+            //- Reverse map the given fvPatchField onto this fvPatchField
+            virtual void rmap
+            (
+                const fvPatchScalarField&,
+                const labelList&
+            );
+
+
         // Evaluation functions
 
             //- Update the coefficients associated with the patch field

src/thermophysicalModels/radiation/include/createIncompressibleRadiationModel.H

@@ -10,7 +10,7 @@
         1.0
     );
 
-    if (radiation->radiation())
+    if (!isType<radiation::noRadiation>(radiation()))
     {
         IOdictionary transportProperties
         (

src/thermophysicalModels/radiation/radiationModels/noRadiation/noRadiation.C

@@ -68,16 +68,20 @@ Foam::radiation::noRadiation::~noRadiation()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool Foam::radiation::noRadiation::read()
-{
-    return radiationModel::read();
-}
+void Foam::radiation::noRadiation::correct()
+{}
 
 
 void Foam::radiation::noRadiation::calculate()
 {}
 
 
+bool Foam::radiation::noRadiation::read()
+{
+    return radiationModel::read();
+}
+
+
 Foam::tmp<Foam::volScalarField> Foam::radiation::noRadiation::Rp() const
 {
     return tmp<volScalarField>

src/thermophysicalModels/radiation/radiationModels/noRadiation/noRadiation.H

@@ -85,6 +85,9 @@ public:
 
         // Edit
 
+            //- Main update/correction routine
+            void correct();
+
             //- Solve radiation equation(s)
             void calculate();
 

src/thermophysicalModels/radiation/radiationModels/radiationModel/radiationModel.C

@@ -74,19 +74,16 @@ Foam::IOobject Foam::radiation::radiationModel::createIOobject
 
 void Foam::radiation::radiationModel::initialise()
 {
-    if (radiation_)
-    {
-        solverFreq_ = max(1, lookupOrDefault<label>("solverFreq", 1));
+    solverFreq_ = max(1, lookupOrDefault<label>("solverFreq", 1));
 
-        absorptionEmission_.reset
-        (
-            absorptionEmissionModel::New(*this, mesh_).ptr()
-        );
+    absorptionEmission_.reset
+    (
+        absorptionEmissionModel::New(*this, mesh_).ptr()
+    );
 
-        scatter_.reset(scatterModel::New(*this, mesh_).ptr());
+    scatter_.reset(scatterModel::New(*this, mesh_).ptr());
 
-        soot_.reset(sootModel::New(*this, mesh_).ptr());
-    }
+    soot_.reset(sootModel::New(*this, mesh_).ptr());
 }
 
 
@@ -108,7 +105,6 @@ Foam::radiation::radiationModel::radiationModel(const volScalarField& T)
     mesh_(T.mesh()),
     time_(T.time()),
     T_(T),
-    radiation_(false),
     coeffs_(dictionary::null),
     solverFreq_(0),
     firstIter_(true),
@@ -128,7 +124,6 @@ Foam::radiation::radiationModel::radiationModel
     mesh_(T.mesh()),
     time_(T.time()),
     T_(T),
-    radiation_(lookupOrDefault("radiation", true)),
     coeffs_(subOrEmptyDict(type + "Coeffs")),
     solverFreq_(1),
     firstIter_(true),
@@ -136,11 +131,6 @@ Foam::radiation::radiationModel::radiationModel
     scatter_(nullptr),
     soot_(nullptr)
 {
-    if (readOpt() == IOobject::NO_READ)
-    {
-        radiation_ = false;
-    }
-
     initialise();
 }
 
@@ -167,7 +157,6 @@ Foam::radiation::radiationModel::radiationModel
     mesh_(T.mesh()),
     time_(T.time()),
     T_(T),
-    radiation_(lookupOrDefault("radiation", true)),
     coeffs_(subOrEmptyDict(type + "Coeffs")),
     solverFreq_(1),
     firstIter_(true),
@@ -187,11 +176,25 @@ Foam::radiation::radiationModel::~radiationModel()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+void Foam::radiation::radiationModel::correct()
+{
+    if (firstIter_ || (time_.timeIndex() % solverFreq_ == 0))
+    {
+        calculate();
+        firstIter_ = false;
+    }
+
+    if (!soot_.empty())
+    {
+        soot_->correct();
+    }
+}
+
+
 bool Foam::radiation::radiationModel::read()
 {
     if (regIOobject::read())
     {
-        lookup("radiation") >> radiation_;
         coeffs_ = subOrEmptyDict(type() + "Coeffs");
 
         solverFreq_ = lookupOrDefault<label>("solverFreq", 1);
@@ -206,26 +209,6 @@ bool Foam::radiation::radiationModel::read()
 }
 
 
-void Foam::radiation::radiationModel::correct()
-{
-    if (!radiation_)
-    {
-        return;
-    }
-
-    if (firstIter_ || (time_.timeIndex() % solverFreq_ == 0))
-    {
-        calculate();
-        firstIter_ = false;
-    }
-
-    if (!soot_.empty())
-    {
-        soot_->correct();
-    }
-}
-
-
 Foam::tmp<Foam::fvScalarMatrix> Foam::radiation::radiationModel::Sh
 (
     const basicThermo& thermo,

src/thermophysicalModels/radiation/radiationModels/radiationModel/radiationModel.H

@@ -86,9 +86,6 @@ protected:
         //- Reference to the temperature field
         const volScalarField& T_;
 
-        //- Radiation model on/off flag
-        Switch radiation_;
-
         //- Radiation model dictionary
         dictionary coeffs_;
 
@@ -211,12 +208,6 @@ public:
 
         // Access
 
-            //- Radiation model on/off flag
-            const Switch radiation() const
-            {
-                return radiation_;
-            }
-
             //- Source term component (for power of T^4)
             virtual tmp<volScalarField> Rp() const = 0;
 

src/thermophysicalModels/thermophysicalProperties/liquidProperties/N2/N2.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2019 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -83,7 +83,7 @@ Foam::N2::N2()
         2873563218390.8,
        -165274505604341.0
     ),
-    mu_(32.165, 496.9, 3.9069, -1.08e-21, 10.0),
+    mu_(-32.165, 496.9, 3.9069, -1.08e-21, 10.0),
     mug_(7.632e-07, 0.58823, 67.75, 0.0),
     kappa_(0.7259, -0.016728, 0.00016215, -5.7605e-07, 0.0, 0.0),
     kappag_(0.000351, 0.7652, 25.767, 0.0),

tutorials/heatTransfer/buoyantBoussinesqPimpleFoam/BernardCells/system/streamlines

@@ -10,10 +10,18 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-nLines  24;
-start   (0 0.5 0);
-end     (9 0.5 0);
-fields  (U);
+direction       both;
+
+seedSampleSet
+{
+    type            lineUniform;
+    start           (0 0.5 0);
+    end             (9 0.5 0);
+    nPoints         24;
+    axis            x;
+}
+
+fields          (U);
 
 #includeEtc "caseDicts/postProcessing/visualization/streamlines.cfg"
 

tutorials/heatTransfer/chtMultiRegionFoam/coolingSphere/Allclean

@@ -6,7 +6,7 @@ cd "${0%/*}" || exit 1    # Run from this directory
 
 removeRegionDirs () {
     # HACK to get regionDirs from materialProperties
-    _regionDirs="$(grep -E "^[a-Z]" constant/materialProperties | tail -n +2)"
+    _regionDirs="$(grep "^[a-zA-Z]" constant/materialProperties | tail -n +2)"
 
     for _d in system constant
     do

tutorials/heatTransfer/chtMultiRegionFoam/coolingSphere/templates/materials/water/thermophysicalProperties

@@ -20,7 +20,7 @@ thermoType
     mixture         pureMixture;
     transport       const;
     thermo          hConst;
-    equationOfState perfectGas;
+    equationOfState perfectFluid;
     specie          specie;
     energy          sensibleEnthalpy;
 }
@@ -32,6 +32,11 @@ mixture
         nMoles      1;
         molWeight   18.0;       // [g/mol]
     }
+    equationOfState
+    {
+        R           3000;      // [J/(kg K)]
+        rho0        1027;      // [kg/m^3]
+    }
     thermodynamics
     {
         Cp          4181;      // [J/(kg K)] at T = 293 K

tutorials/heatTransfer/chtMultiRegionFoam/heatExchanger/constant/air/radiationProperties

@@ -16,10 +16,6 @@ FoamFile
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-radiation       off;
-
 radiationModel  none;
 
-
-
 // ************************************************************************* //