INT: various integrations from openfoam.org

ENH: add log FO
  ENH: improve log with scale, and offset entries
  BUG: ensure extrueMesh does not fail in parallel with wedge extrusion
  BUG: add missing clone and mapping funcs to copiedFixedValue, fixedMultiPhaseHeatFlux
  ENH: meshToMesh0::cellAddressing slight speed up for some geometries
  BUG:0003495: Divide-by-zero in SHF particle break-up model
  BUG:0003492: The formula in the OF is inconsistent with the Rosin-Rammler distribution theory formula

applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMesh.C

@@ -881,6 +881,7 @@ int main(int argc, char *argv[])
 
         // Put all modifications into meshMod
         bool anyChange = collapser.setRefinement(allPointInfo, meshMod);
+        reduce(anyChange, orOp<bool>());
 
         if (anyChange)
         {

etc/caseDicts/postProcessing/fields/log

@@ -0,0 +1,22 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Version:  v1912
+    \\  /    A nd           | Website:  www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+Description
+    Calculates the natural logarithm of an input volScalarField
+\*---------------------------------------------------------------------------*/
+
+type            log;
+libs            (fieldFunctionObjects);
+
+field           <fieldName>;
+
+executeControl  writeTime;
+writeControl    writeTime;
+scale           <scalar>;
+translate       <scalar>;
+
+// ************************************************************************* //

src/functionObjects/field/Make/files

@@ -79,6 +79,7 @@ pressure/pressure.C
 MachNo/MachNo.C
 Curle/Curle.C
 reference/reference.C
+log/log.C
 
 fieldsExpression/fieldsExpression.C
 add/add.C

src/functionObjects/field/log/log.C

@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2018-2019 OpenFOAM Foundation
+    Copyright (C) 2020 OpenCFD Ltd.
+------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "log.H"
+#include "volFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+    defineTypeNameAndDebug(log, 0);
+    addToRunTimeSelectionTable(functionObject, log, dictionary);
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::functionObjects::log::calc()
+{
+    if (foundObject<volScalarField>(fieldName_))
+    {
+        const volScalarField& x = lookupObject<volScalarField>(fieldName_);
+
+        // Cache the current debug setting for dimensionSet
+        const bool dimensionSetDebug = dimensionSet::debug;
+
+        // Switch-off dimension checking if requested
+        if (!checkDimensions_)
+        {
+            dimensionSet::debug = 0;
+        }
+
+        bool stored = store
+        (
+            resultName_,
+            scale_*Foam::log(max(x, clipValue_)) + offset_
+        );
+
+        // Reinstate dimension checking
+        if (!checkDimensions_)
+        {
+            dimensionSet::debug = dimensionSetDebug;
+        }
+
+        return stored;
+    }
+
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::functionObjects::log::log
+(
+    const word& name,
+    const Time& runTime,
+    const dictionary& dict
+)
+:
+    fieldExpression(name, runTime, dict, typeName),
+    checkDimensions_(true),
+    clipValue_(SMALL),
+    scale_(1.0),
+    offset_(0.0)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::functionObjects::log::read(const dictionary& dict)
+{
+    if (fvMeshFunctionObject::read(dict) && fieldExpression::read(dict))
+    {
+        checkDimensions_ = dict.getOrDefault<Switch>("checkDimensions", true);
+        clipValue_ =
+            dict.getCheckOrDefault<scalar>
+            (
+                "clip",
+                SMALL,
+                scalarMinMax::ge(SMALL)
+            );
+        scale_ = dict.getOrDefault<scalar>("scale", 1.0);
+        offset_ = dict.getOrDefault<scalar>("offset", 0.0);
+
+        return true;
+    }
+
+    return false;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/log/log.H

@@ -0,0 +1,205 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | www.openfoam.com
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+    Copyright (C) 2018-2019 OpenFOAM Foundation
+    Copyright (C) 2020 OpenCFD Ltd.
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::functionObjects::log
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    Computes the natural logarithm of an input \c volScalarField.
+
+    \f[
+        f = s \ln(max(f_0, a)) + t
+    \f]
+
+    where
+    \vartable
+      f     | Output volScalarField
+      f_0   | Input volScalarField
+      \ln   | Natural logarithm operator
+      a     | Clip scalar
+      s     | Scaling factor
+      t     | Offset factor
+    \endvartable
+
+    \table
+      Operand       | Type           | Location
+      input         | volScalarField | $FOAM_CASE/\<time\>/\<inpField\>
+      output file   | -              | -
+      output field  | volScalarField | $FOAM_CASE/\<time\>/\<outField\>
+    \endtable
+
+Usage
+    Minimal example by using \c system/controlDict.functions:
+    \verbatim
+    log1
+    {
+        // Mandatory entries (unmodifiable)
+        type            log;
+        libs            (fieldFunctionObjects);
+
+        // Mandatory (inherited) entry (runtime modifiable)
+        field           <inpField>;
+
+        // Optional entries (runtime modifiable)
+        clip            1e-3;
+        checkDimensions false;
+        scale           1.0;
+        offset          0.0;
+
+        // Optional (inherited) entries
+        ...
+    }
+    \endverbatim
+
+    where the entries mean:
+    \table
+      Property     | Description                        | Type | Req'd | Dflt
+      type         | Type name: log                     | word |  yes  | -
+      libs         | Library name: fieldFunctionObjects | word |  yes  | -
+      field        | Name of the operand field          | word |  yes  | -
+      clip         | Value to clip the operand field values <!--
+                 --> to prevent zero or negative input  | scalar | no  | SMALL
+      checkDimensions | Flag to check dimensions of the operand field <!--
+                                                    --> | bool   | no  | true
+      scale        | Scaling factor - \c s above        | scalar | no  | 1.0
+      offset       | Offset factor - \c t above         | scalar | no  | 0.0
+    \endtable
+
+    The inherited entries are elaborated in:
+     - \link functionObject.H \endlink
+     - \link fieldExpression.H \endlink
+
+    Minimal example by using the \c postProcess utility:
+    \verbatim
+        postProcess -func "log(<inpField>)" -scale 1.0 -offset 0.0
+    \endverbatim
+
+Note
+    - Performs \f$\ln(max(x, a))\f$ where \f$x\f$ is a \c volScalarField, and
+    \f$a\f$ a clip scalar, equals to \c SMALL by default. This prevents zero or
+    negative input \f$x\f$, hence the domain error in the natural logarithm.
+    - Dimension checking can optionally be suspended if \f$x\f$ is dimensioned.
+
+See also
+    - Foam::functionObject
+    - Foam::functionObjects::fieldExpression
+    - Foam::functionObjects::fvMeshFunctionObject
+    - ExtendedCodeGuide::functionObjects::field::log
+
+SourceFiles
+    log.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef functionObjects_log_H
+#define functionObjects_log_H
+
+#include "fieldExpression.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class log Declaration
+\*---------------------------------------------------------------------------*/
+
+class log
+:
+    public fieldExpression
+{
+    // Private Data
+
+        //- Flag to check dimensions of the operand
+        Switch checkDimensions_;
+
+        //- Value to clip the operand field values
+        //- to prevent zero or negative input
+        scalar clipValue_;
+
+        //- Scaling factor
+        scalar scale_;
+
+        //- Offset factor
+        scalar offset_;
+
+
+    // Private Member Functions
+
+        //- Calculate the log field and return true if successful
+        virtual bool calc();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("log");
+
+
+    // Constructors
+
+        //- Construct from Time and dictionary
+        log
+        (
+            const word& name,
+            const Time& runTime,
+            const dictionary& dict
+        );
+
+        //- No copy construct
+        log(const log&) = delete;
+
+        //- No copy assignment
+        void operator=(const log&) = delete;
+
+
+    //- Destructor
+    virtual ~log() = default;
+
+
+    // Member Functions
+
+        //- Read the randomise data
+        virtual bool read(const dictionary&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace functionObjects
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/distributionModels/RosinRammler/RosinRammler.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2011-2020 OpenFOAM Foundation
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -77,10 +77,10 @@ Foam::distributionModels::RosinRammler::~RosinRammler()
 
 Foam::scalar Foam::distributionModels::RosinRammler::sample() const
 {
-    scalar K = 1.0 - exp(-pow((maxValue_ - minValue_)/d_, n_));
+    const scalar minValueByDPowN = pow(minValue_/d_, n_);
-    scalar y = rndGen_.sample01<scalar>();
+    const scalar K = 1 - exp(- pow(maxValue_/d_, n_) + minValueByDPowN);
-    scalar x = minValue_ + d_*::pow(-log(1.0 - y*K), 1.0/n_);
+    const scalar y = rndGen_.sample01<scalar>();
-    return x;
+    return d_*pow(minValueByDPowN - log(1 - K*y), 1/n_);
 }
 
 

src/lagrangian/distributionModels/RosinRammler/RosinRammler.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2011-2020 OpenFOAM Foundation
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -30,19 +30,18 @@ Description
     Rosin-Rammler distributionModel
 
    \f[
-       cumulative model =
+       CDF(x) =
-           (1.0 - exp( -(( x - d0)/d)^n )
+            (1 - exp(-(x/d)^n + (d_0/d)^n)
-         / (1.0 - exp( -((d1 - d0)/d)^n )
+           /(1 - exp(-(d_1/d)^n + (d_0/d)^n)
    \f]
 
-
 SourceFiles
     RosinRammler.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef distributionModels_RosinRammler_H
+#ifndef RosinRammler_H
-#define distributionModels_RosinRammler_H
+#define RosinRammler_H
 
 #include "distributionModel.H"
 
@@ -61,7 +60,7 @@ class RosinRammler
 :
     public distributionModel
 {
-    // Private data
+    // Private Data
 
         //- Distribution minimum
         scalar minValue_;
@@ -71,7 +70,10 @@ class RosinRammler
 
         // Model coefficients
 
+            //- Scale parameter
             scalar d_;
+
+            //- Shape parameter
             scalar n_;
 
 

src/lagrangian/spray/submodels/BreakupModel/SHF/SHF.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2011-2013 OpenFOAM Foundation
+    Copyright (C) 2011-2020 OpenFOAM Foundation
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -158,9 +158,21 @@ bool Foam::SHF<CloudType>::update
 
     scalar weGasCorr = weGas/(1.0 + weCorrCoeff_*ohnesorge);
 
-    // droplet deformation characteristic time
+    // update the droplet characteristic time
+    tc += dt;
 
-    scalar tChar = d/Urmag*sqrt(rho/rhoc);
+    // droplet deformation characteristic rate
+    scalar rChar = Urmag/d*sqrt(rhoc/rho);
+
+    // return if the characteristic deformation rate is too low for the
+    // following modelling to be calculable
+    if (tc*rChar < SMALL)
+    {
+        return false;
+    }
+
+    // droplet deformation characteristic time
+    scalar tChar = 1/rChar;
 
     scalar tFirst = cInit_*tChar;
 
@@ -173,9 +185,6 @@ bool Foam::SHF<CloudType>::update
     bool success = false;
 
 
-    // update the droplet characteristic time
-    tc += dt;
-
     if (weGas > weConst_)
     {
         if (weGas < weCrit1_)

src/phaseSystemModels/reactingEulerFoam/derivedFvPatchFields/fixedMultiPhaseHeatFlux/fixedMultiPhaseHeatFluxFvPatchScalarField.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2015-2019 OpenFOAM Foundation
+    Copyright (C) 2015-2020 OpenFOAM Foundation
     Copyright (C) 2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
@@ -168,6 +168,31 @@ void Foam::fixedMultiPhaseHeatFluxFvPatchScalarField::updateCoeffs()
 }
 
 
+void Foam::fixedMultiPhaseHeatFluxFvPatchScalarField::autoMap
+(
+    const fvPatchFieldMapper& m
+)
+{
+    fixedValueFvPatchScalarField::autoMap(m);
+    m(q_);
+}
+
+
+void Foam::fixedMultiPhaseHeatFluxFvPatchScalarField::rmap
+(
+    const fvPatchScalarField& ptf,
+    const labelList& addr
+)
+{
+    fixedValueFvPatchScalarField::rmap(ptf, addr);
+
+    const fixedMultiPhaseHeatFluxFvPatchScalarField& mptf =
+        refCast<const fixedMultiPhaseHeatFluxFvPatchScalarField>(ptf);
+
+    q_.rmap(mptf.q_, addr);
+}
+
+
 void Foam::fixedMultiPhaseHeatFluxFvPatchScalarField::write(Ostream& os) const
 {
     fvPatchField<scalar>::write(os);

src/phaseSystemModels/reactingEulerFoam/derivedFvPatchFields/fixedMultiPhaseHeatFlux/fixedMultiPhaseHeatFluxFvPatchScalarField.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2015-2018 OpenFOAM Foundation
+    Copyright (C) 2015-2020 OpenFOAM Foundation
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -144,6 +144,17 @@ public:
 
     // Member Functions
 
+        // Mapping functions
+
+            //- Map (and resize as needed) from self given a mapping object
+            //  Used to update fields following mesh topology change
+            virtual void autoMap(const fvPatchFieldMapper&);
+
+            //- Reverse map the given fvPatchField onto this fvPatchField
+            //  Used to reconstruct fields
+            virtual void rmap(const fvPatchScalarField&, const labelList&);
+
+
         // Evaluation Functions
 
             //- Update the coefficients associated with the patch field

src/sampling/meshToMesh0/calculateMeshToMesh0Addressing.C

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2011-2020 OpenFOAM Foundation
     Copyright (C) 2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
@@ -32,9 +32,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "meshToMesh0.H"
-#include "SubField.H"
 
-#include "indexedOctree.H"
 #include "treeDataCell.H"
 #include "treeDataFace.H"
 
@@ -273,6 +271,11 @@ void Foam::meshToMesh0::cellAddresses
             if (boundaryCell[curCell])
             {
                 cellAddressing_[toI] = oc.findInside(p);
+
+                if (cellAddressing_[toI] != -1)
+                {
+                    curCell = cellAddressing_[toI];
+                }
             }
             else
             {
@@ -325,6 +328,11 @@ void Foam::meshToMesh0::cellAddresses
                 {
                     // Still not found so use the octree
                     cellAddressing_[toI] = oc.findInside(p);
+
+                    if (cellAddressing_[toI] != -1)
+                    {
+                        curCell = cellAddressing_[toI];
+                    }
                 }
             }
         }

src/sampling/meshToMesh0/meshToMesh0.H

@@ -5,7 +5,7 @@
     \\  /    A nd           | www.openfoam.com
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
-    Copyright (C) 2011-2016 OpenFOAM Foundation
+    Copyright (C) 2011-2020 OpenFOAM Foundation
     Copyright (C) 2019-2020 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
@@ -28,7 +28,7 @@ Class
     Foam::meshToMesh0
 
 Description
-    mesh to mesh interpolation class.
+    Serial mesh to mesh interpolation class.
 
 Note
     This class is due to be deprecated in favour of meshToMesh0New
@@ -105,6 +105,9 @@ class meshToMesh0
 
     // Private Member Functions
 
+        //- Calculates mesh to mesh addressing pattern.
+        //  For each cell from one mesh find the closest cell centre
+        //  in the other mesh
         void calcAddressing();
 
         void cellAddresses