Merge remote-tracking branch 'upstream/develop' into wp3-directional-refinement

src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions/epsilonWallFunctions/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C

@@ -229,9 +229,6 @@ void Foam::epsilonWallFunctionFvPatchScalarField::calculate
 
     const scalarField magGradUw(mag(Uw.snGrad()));
 
-    typedef DimensionedField<scalar, volMesh> FieldType;
-    const FieldType& G = db().lookupObject<FieldType>(turbModel.GName());
-
     // Set epsilon and G
     forAll(nutw, facei)
     {
@@ -255,8 +252,6 @@ void Foam::epsilonWallFunctionFvPatchScalarField::calculate
         else
         {
             epsilon0[celli] += w*2.0*k[celli]*nuw[facei]/sqr(y[facei]);
-
-            G0[celli] += w*G[celli];
         }
     }
 }

src/dynamicMesh/meshCut/cellCuts/cellCuts.C

@@ -242,7 +242,12 @@ void Foam::cellCuts::syncProc()
                             else
                             {
                                 label oppFp = relCut[i]-1;
-                                label fp = f.size()-1-oppFp;
+                                label fp =
+                                (
+                                    oppFp == 0
+                                  ? 0
+                                  : f.size()-oppFp
+                                );
                                 absoluteCut[i] = vertToEVert(f[fp]);
                             }
                         }

src/finiteVolume/fields/fvPatchFields/derived/turbulentDFSEMInlet/turbulentDFSEMInletFvPatchVectorField.C

@@ -108,16 +108,29 @@ void Foam::turbulentDFSEMInletFvPatchVectorField::writeLumleyCoeffs() const
     {
         fileName valsFile
         (
-            this->db().time().caseConstant()
-           /"boundaryData"
-           /this->patch().name()
-           /"0"
-           /"R"
+            fileHandler().filePath
+            (
+                fileName
+                (
+                    db().time().path()
+                   /db().time().caseConstant()
+                   /"boundaryData"
+                   /this->patch().name()
+                   /"0"
+                   /"R"
+                )
+            )
         );
 
-        IFstream is(valsFile);
+        autoPtr<ISstream> isPtr
+        (
+            fileHandler().NewIFstream
+            (
+                valsFile
+            )
+        );
 
-        Field<symmTensor> Rexp(is);
+        Field<symmTensor> Rexp(isPtr());
 
         OFstream os(db().time().path()/"lumley_input.out");
 

src/finiteVolume/fields/fvPatchFields/derived/turbulentDFSEMInlet/turbulentDFSEMInletFvPatchVectorFieldTemplates.C

@@ -72,16 +72,29 @@ Foam::turbulentDFSEMInletFvPatchVectorField::interpolateBoundaryData
 
     fileName valsFile
     (
-        this->db().time().path()
-       /this->db().time().caseConstant()
-       /"boundaryData"
-       /patchName
-       /"0"
-       /fieldName
+        fileHandler().filePath
+        (
+            fileName
+            (
+                this->db().time().path()
+               /this->db().time().caseConstant()
+               /"boundaryData"
+               /patchName
+               /"0"
+               /fieldName
+            )
+        )
     );
 
-    IFstream is(valsFile);
-    Field<Type> vals(is);
+    autoPtr<ISstream> isPtr
+    (
+        fileHandler().NewIFstream
+        (
+            valsFile
+        )
+    );
+
+    Field<Type> vals(isPtr());
 
     Info<< "Turbulent DFSEM patch " << patchName
         << ": interpolating field " << fieldName

src/functionObjects/field/Make/files

@@ -11,6 +11,13 @@ fieldValues/fieldValueDelta/fieldValueDelta.C
 fieldValues/volFieldValue/volFieldValue.C
 fieldValues/surfaceFieldValue/surfaceFieldValue.C
 
+heatTransferCoeff/heatTransferCoeff.C
+heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModel.C
+heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModelNew.C
+heatTransferCoeff/heatTransferCoeffModels/fixedReferenceTemperature/fixedReferenceTemperature.C
+heatTransferCoeff/heatTransferCoeffModels/localReferenceTemperature/localReferenceTemperature.C
+heatTransferCoeff/heatTransferCoeffModels/ReynoldsAnalogy/ReynoldsAnalogy.C
+
 nearWallFields/nearWallFields.C
 nearWallFields/findCellParticle.C
 nearWallFields/findCellParticleCloud.C

src/functionObjects/field/extractEulerianParticles/extractEulerianParticles/extractEulerianParticles.C

@@ -314,7 +314,8 @@ void Foam::functionObjects::extractEulerianParticles::collectParticles
                     tag,
                     time,
                     d,
-                    U
+                    U,
+                    false // not looking to set cell owner etc.
                 );
 
                 cloud_.addParticle(ip);

src/functionObjects/field/heatTransferCoeff/heatTransferCoeff.C

@@ -0,0 +1,114 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "heatTransferCoeff.H"
+#include "dictionary.H"
+#include "heatTransferCoeffModel.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+    defineTypeNameAndDebug(heatTransferCoeff, 0);
+    addToRunTimeSelectionTable(functionObject, heatTransferCoeff, dictionary);
+}
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::functionObjects::heatTransferCoeff::calc()
+{
+    volScalarField& htc = mesh_.lookupObjectRef<volScalarField>(resultName_);
+
+    htcModelPtr_->calc(htc);
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::functionObjects::heatTransferCoeff::heatTransferCoeff
+(
+    const word& name,
+    const Time& runTime,
+    const dictionary& dict
+)
+:
+    fieldExpression(name, runTime, dict),
+    htcModelPtr_()
+{
+    read(dict);
+
+    setResultName(typeName, name + ":htc:" + htcModelPtr_->type());
+
+    volScalarField* heatTransferCoeffPtr
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                resultName_,
+                mesh_.time().timeName(),
+                mesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            mesh_,
+            dimensionedScalar("0", dimPower/dimArea/dimTemperature, 0.0)
+        )
+    );
+
+    mesh_.objectRegistry::store(heatTransferCoeffPtr);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::functionObjects::heatTransferCoeff::~heatTransferCoeff()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::functionObjects::heatTransferCoeff::read(const dictionary& dict)
+{
+    if (fieldExpression::read(dict))
+    {
+        htcModelPtr_ = heatTransferCoeffModel::New(dict, mesh_, fieldName_);
+
+        htcModelPtr_->read(dict);
+
+        return true;
+    }
+
+    return false;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeff.H

@@ -0,0 +1,199 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+Class
+    Foam::functionObjects::heatTransferCoeff
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object calculates and writes the heat transfer coefficient
+    as a volScalarField for a set of patches.
+
+    The field is stored on the mesh database so that it can be retrieved and
+    used for other applications.  Heat transfer coefficient, htc [W/m2/K]
+    can be evaluated using one of the following modes:
+    - ReynoldsAnalogy: Reynold's analogy
+    - localReferenceTemperature: local reference temperature
+    - fixedReferenceTemperature: specified reference temperature
+
+Usage
+    Example usage for mode 'ReynoldsAnalogy' for incompressible case
+    \verbatim
+    htc
+    {
+        type        heatTransferCoeff;
+        libs        ("libfieldFunctionObjects.so");
+
+        field       T;
+        patches     ("walls.*");
+
+        htcModel    ReynoldsAnalogy;
+        UInf        (20 0 0);
+        Cp          CpInf;
+        CpInf       1000;
+        rho         rhoInf;
+        rhoInf      1.2;
+    }
+    \endverbatim
+
+    Example usage for mode 'ReynoldsAnalogy' for compressible case
+    \verbatim
+    htc
+    {
+        type        heatTransferCoeff;
+        libs        ("libfieldFunctionObjects.so");
+
+        field       T;
+        patches     ("walls.*");
+
+        htcModel    ReynoldsAnalogy;
+        UInf        (20 0 0);
+    }
+    \endverbatim
+
+    Example usage for mode 'localReferenceTemperature' for compressible case
+    \verbatim
+    htc
+    {
+        type        heatTransferCoeff;
+        libs        ("libfieldFunctionObjects.so");
+
+        field       T;
+        patches     ("walls.*");
+        htcModel    local;
+    }
+    \endverbatim
+
+    Example usage for mode 'fixedReferenceTemperature' for compressible case
+    \verbatim
+    htc
+    {
+        type        heatTransferCoeff;
+        libs        ("libfieldFunctionObjects.so");
+
+        field       T;
+        patches     ("walls.*");
+        htcModel    local;
+        TRef        300;
+    }
+    \endverbatim
+
+See also
+    Foam::functionObjects::fieldExpression
+    Foam::heatTransferCoeffModels::fixedReferenceTemperature
+    Foam::heatTransferCoeffModels::localReferenceTemperature
+
+SourceFiles
+    heatTransferCoeff.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef functionObjects_heatTransferCoeff_H
+#define functionObjects_heatTransferCoeff_H
+
+#include "fieldExpression.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class heatTransferCoeffModel;
+
+namespace functionObjects
+{
+
+/*---------------------------------------------------------------------------*\
+                      Class heatTransferCoeff Declaration
+\*---------------------------------------------------------------------------*/
+
+class heatTransferCoeff
+:
+    public fieldExpression
+{
+
+private:
+
+    // Private data
+
+        //- Heat transfer coefficient model
+        autoPtr<heatTransferCoeffModel> htcModelPtr_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        heatTransferCoeff(const heatTransferCoeff&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const heatTransferCoeff&) = delete;
+
+
+protected:
+
+        //- Calculate the heat transfer coefficient field and return true
+        // if successful
+        virtual bool calc();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("heatTransferCoeff");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        heatTransferCoeff
+        (
+            const word& name,
+            const Time& runTime,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~heatTransferCoeff();
+
+
+    // Member Functions
+
+        //- Read the heatTransferCoeff data
+        virtual bool read(const dictionary&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace functionObjects
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/ReynoldsAnalogy/ReynoldsAnalogy.C

@@ -0,0 +1,271 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "ReynoldsAnalogy.H"
+#include "fluidThermo.H"
+#include "turbulentTransportModel.H"
+#include "turbulentFluidThermoModel.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace heatTransferCoeffModels
+{
+    defineTypeNameAndDebug(ReynoldsAnalogy, 0);
+    addToRunTimeSelectionTable
+    (
+        heatTransferCoeffModel,
+        ReynoldsAnalogy,
+        dictionary
+    );
+}
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+Foam::tmp<Foam::Field<Foam::scalar>>
+Foam::heatTransferCoeffModels::ReynoldsAnalogy::rho(const label patchi) const
+{
+    if (rhoName_ == "rhoInf")
+    {
+        const label n = mesh_.boundary()[patchi].size();
+        return tmp<Field<scalar>>(new Field<scalar>(n, rhoRef_));
+    }
+    else if (mesh_.foundObject<volScalarField>(rhoName_, false))
+    {
+        const volScalarField& rho =
+            mesh_.lookupObject<volScalarField>(rhoName_);
+        return rho.boundaryField()[patchi];
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Unable to set rho for patch " << patchi
+            << exit(FatalError);
+    }
+
+    return tmp<Field<scalar>>(nullptr);
+}
+
+
+Foam::tmp<Foam::Field<Foam::scalar>>
+Foam::heatTransferCoeffModels::ReynoldsAnalogy::Cp(const label patchi) const
+{
+    if (CpName_ == "CpInf")
+    {
+        const label n = mesh_.boundary()[patchi].size();
+        return tmp<Field<scalar>>(new Field<scalar>(n, CpRef_));
+    }
+    else if (mesh_.foundObject<fluidThermo>(fluidThermo::typeName))
+    {
+        const fluidThermo& thermo =
+            mesh_.lookupObject<fluidThermo>(fluidThermo::typeName);
+
+        const scalarField& pp = thermo.p().boundaryField()[patchi];
+        const scalarField& Tp = thermo.T().boundaryField()[patchi];
+
+        return thermo.Cp(pp, Tp, patchi);
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Unable to set Cp for patch " << patchi
+            << exit(FatalError);
+    }
+
+    return tmp<Field<scalar>>(nullptr);
+}
+
+
+Foam::tmp<Foam::volSymmTensorField>
+Foam::heatTransferCoeffModels::ReynoldsAnalogy::devReff() const
+{
+    typedef compressible::turbulenceModel cmpTurbModel;
+    typedef incompressible::turbulenceModel icoTurbModel;
+
+    if (mesh_.foundObject<cmpTurbModel>(cmpTurbModel::propertiesName))
+    {
+        const cmpTurbModel& turb =
+            mesh_.lookupObject<cmpTurbModel>(cmpTurbModel::propertiesName);
+
+        return turb.devRhoReff()/turb.rho();
+    }
+    else if (mesh_.foundObject<icoTurbModel>(icoTurbModel::propertiesName))
+    {
+        const incompressible::turbulenceModel& turb =
+            mesh_.lookupObject<icoTurbModel>(icoTurbModel::propertiesName);
+
+        return turb.devReff();
+    }
+    else if (mesh_.foundObject<fluidThermo>(fluidThermo::dictName))
+    {
+        const fluidThermo& thermo =
+            mesh_.lookupObject<fluidThermo>(fluidThermo::dictName);
+
+        const volVectorField& U = mesh_.lookupObject<volVectorField>(UName_);
+
+        return -thermo.nu()*dev(twoSymm(fvc::grad(U)));
+    }
+    else if (mesh_.foundObject<transportModel>("transportProperties"))
+    {
+        const transportModel& laminarT =
+            mesh_.lookupObject<transportModel>("transportProperties");
+
+        const volVectorField& U = mesh_.lookupObject<volVectorField>(UName_);
+
+        return -laminarT.nu()*dev(twoSymm(fvc::grad(U)));
+    }
+    else if (mesh_.foundObject<dictionary>("transportProperties"))
+    {
+        const dictionary& transportProperties =
+            mesh_.lookupObject<dictionary>("transportProperties");
+
+        dimensionedScalar nu(transportProperties.lookup("nu"));
+
+        const volVectorField& U = mesh_.lookupObject<volVectorField>(UName_);
+
+        return -nu*dev(twoSymm(fvc::grad(U)));
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "No valid model for viscous stress calculation"
+            << exit(FatalError);
+
+        return volSymmTensorField::null();
+    }
+}
+
+
+Foam::tmp<Foam::FieldField<Foam::Field, Foam::scalar>>
+Foam::heatTransferCoeffModels::ReynoldsAnalogy::Cf() const
+{
+    const volVectorField& U = mesh_.lookupObject<volVectorField>(UName_);
+    const volVectorField::Boundary& Ubf = U.boundaryField();
+
+    tmp<FieldField<Field, scalar>> tCf
+    (
+        new FieldField<Field, scalar>(Ubf.size())
+    );
+
+    FieldField<Field, scalar>& Cf = tCf.ref();
+
+    forAll(Cf, patchi)
+    {
+        Cf.set(patchi, new Field<scalar>(Ubf[patchi].size(), 0));
+    }
+
+    const volSymmTensorField R(devReff());
+    const volSymmTensorField::Boundary& Rbf = R.boundaryField();
+
+    for (label patchi : patchSet_)
+    {
+        const fvPatchVectorField& Up = Ubf[patchi];
+
+        const symmTensorField& Rp = Rbf[patchi];
+
+        const vectorField nHat(Up.patch().nf());
+
+        const scalarField tauByRhop(mag(nHat & Rp));
+
+        Cf[patchi] = 2*tauByRhop/magSqr(URef_);
+    }
+
+    return tCf;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::heatTransferCoeffModels::ReynoldsAnalogy::ReynoldsAnalogy
+(
+    const dictionary& dict,
+    const fvMesh& mesh,
+    const word& TName
+)
+:
+    heatTransferCoeffModel(dict, mesh, TName),
+    UName_("U"),
+    URef_(vector::zero),
+    rhoName_("rho"),
+    rhoRef_(0.0),
+    CpName_("Cp"),
+    CpRef_(0.0)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::heatTransferCoeffModels::ReynoldsAnalogy::read
+(
+    const dictionary& dict
+)
+{
+    if (heatTransferCoeffModel::read(dict))
+    {
+        dict.lookup("UInf") >> URef_;
+
+        dict.readIfPresent("Cp", CpName_);
+        if (CpName_ == "CpInf")
+        {
+            dict.lookup("CpInf") >> CpRef_;
+        }
+
+        dict.readIfPresent("rho", rhoName_);
+        if (rhoName_ == "rhoInf")
+        {
+            dict.lookup("rhoInf") >> rhoRef_;
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+
+void Foam::heatTransferCoeffModels::ReynoldsAnalogy::htc(volScalarField& htc)
+{
+    const FieldField<Field, scalar> CfBf(Cf());
+    const scalar magU = mag(URef_);
+
+    volScalarField::Boundary& htcBf = htc.boundaryFieldRef();
+    forAllConstIters(patchSet_, iter)
+    {
+        label patchi = iter.key();
+        const scalarField rhop(rho(patchi));
+        const scalarField Cpp(Cp(patchi));
+
+        htcBf[patchi] = 0.5*rhop*Cpp*magU*CfBf[patchi];
+    }
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/ReynoldsAnalogy/ReynoldsAnalogy.H

@@ -0,0 +1,182 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+Class
+    Foam::heatTransferCoeffModels::ReynoldsAnalogy
+
+Description
+    Heat transfer coefficient calculation based on Reynolds Analogy
+
+    The heat transfer coefficient is derived from the skin friction
+    coefficient:
+
+    \f[
+        C_f = \frac{\tau_w}{0.5 \rho_\infty |U|^2}
+    \f]
+
+    as:
+
+    \f[
+        h = 0.5 \rho_\infty \C_{p,\infty} |U_{\infty}| C_f
+    \f]
+
+Usage
+    Example of function object specification:
+    \verbatim
+        type            heatTransferCoeff;
+        libs            ("libfieldFunctionObjects.so");
+        ...
+    	htcModel	    ReynoldsAnalogy;
+        UInf            (20 0 0);
+        Cp              CpInf;
+        CpInf           1005;
+        ...
+    \endverbatim
+
+    Where the entries comprise:
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: heatTransferCoeff | yes    |
+        htcModel     | selected htc model      | yes         |
+        UInf         | reference velocity      | yes |
+        Cp           | specific heat capacity field name | no |
+        rho          | density field name      | no |
+    \endtable
+
+    Note:
+    - to use a reference \c Cp, set \c Cp to \c CpInf
+    - to use a reference \c rho, set \c rho to \c rhoInf
+
+SourceFiles
+    ReynoldsAnalogy.C
+
+SeeAlso
+    Foam::heatTransferCoeffModel
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef heatTransferCoeffModels_ReynoldsAnalogy_H
+#define heatTransferCoeffModels_ReynoldsAnalogy_H
+
+#include "heatTransferCoeffModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace heatTransferCoeffModels
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class ReynoldsAnalogy Declaration
+\*---------------------------------------------------------------------------*/
+
+class ReynoldsAnalogy
+:
+    public heatTransferCoeffModel
+{
+    // Private Member Functions
+
+        //- Disallow copy construct
+        ReynoldsAnalogy(const ReynoldsAnalogy&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const ReynoldsAnalogy&) = delete;
+
+
+protected:
+
+    // Protected data
+
+        //- Name of velocity field
+        word UName_;
+
+        //- Reference velocity
+        vector URef_;
+
+        //- Name of density field
+        word rhoName_;
+
+        //- Reference density
+        scalar rhoRef_;
+
+        //- Name of specific heat capacity field
+        word CpName_;
+
+        //- Reference specific heat capacity
+        scalar CpRef_;
+
+
+    // Protected Member Functions
+
+        virtual tmp<Field<scalar>> rho(const label patchi) const;
+
+        virtual tmp<Field<scalar>> Cp(const label patchi) const;
+
+        virtual tmp<volSymmTensorField> devReff() const;
+
+        tmp<FieldField<Field, scalar>> Cf() const;
+
+        //- Set the heat transfer coefficient
+        virtual void htc(volScalarField& htc);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("ReynoldsAnalogy");
+
+
+    // Constructors
+
+        //- Construct from components
+        ReynoldsAnalogy
+        (
+            const dictionary& dict,
+            const fvMesh& mesh,
+            const word& TName
+        );
+
+
+    //- Destructor
+    virtual ~ReynoldsAnalogy()
+    {}
+
+
+    // Member Functions
+
+        //- Read from dictionary
+        virtual bool read(const dictionary& dict);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace heatTransferCoeffModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/fixedReferenceTemperature/fixedReferenceTemperature.C

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fixedReferenceTemperature.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace heatTransferCoeffModels
+{
+    defineTypeNameAndDebug(fixedReferenceTemperature, 0);
+    addToRunTimeSelectionTable
+    (
+        heatTransferCoeffModel,
+        fixedReferenceTemperature,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::heatTransferCoeffModels::fixedReferenceTemperature::fixedReferenceTemperature
+(
+    const dictionary& dict,
+    const fvMesh& mesh,
+    const word& TName
+)
+:
+    heatTransferCoeffModel(dict, mesh, TName),
+    TRef_(0)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::heatTransferCoeffModels::fixedReferenceTemperature::read
+(
+    const dictionary& dict
+)
+{
+    if (heatTransferCoeffModel::read(dict))
+    {
+        dict.lookup("TRef") >> TRef_;
+
+        return true;
+    }
+
+    return false;
+}
+
+
+void Foam::heatTransferCoeffModels::fixedReferenceTemperature::htc
+(
+    volScalarField& htc
+)
+{
+    const FieldField<Field, scalar> qBf(q());
+    const volScalarField& T = mesh_.lookupObject<volScalarField>(TName_);
+    const volScalarField::Boundary& Tbf = T.boundaryField();
+    const scalar eps = ROOTVSMALL;
+
+    volScalarField::Boundary& htcBf = htc.boundaryFieldRef();
+    forAllConstIters(patchSet_, iter)
+    {
+        label patchi = iter.key();
+        htcBf[patchi] = qBf[patchi]/(TRef_ - Tbf[patchi] + eps);
+    }
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/fixedReferenceTemperature/fixedReferenceTemperature.H

@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+Class
+    Foam::heatTransferCoeffModels::fixedReferenceTemperature
+
+Description
+    Heat transfer coefficient calculation that employs a fixed reference
+    temperature
+
+    The heat transfer coefficient is specified by:
+    
+    \f[
+        h = \frac{q}{T_{ref} - T_w}
+    \f]
+
+Usage
+    Example of function object specification:
+    \verbatim
+        type            heatTransferCoeff;
+        libs            ("libfieldFunctionObjects.so");
+        ...
+    	htcModel	    fixedReferenceTemperature;
+	    TRef		    300;
+        ...
+    \endverbatim
+
+    Where the entries comprise:
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: heatTransferCoeff | yes    |
+        htcModel     | selected htc model      | yes         |
+        TRef         | reference temperature   | yes |
+    \endtable
+
+SourceFiles
+    fixedReferenceTemperature.C
+
+SeeAlso
+    Foam::heatTransferCoeffModel
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef heatTransferCoeffModels_fixedReferenceTemperature_H
+#define heatTransferCoeffModels_fixedReferenceTemperature_H
+
+#include "heatTransferCoeffModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace heatTransferCoeffModels
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class fixedReferenceTemperature Declaration
+\*---------------------------------------------------------------------------*/
+
+class fixedReferenceTemperature
+:
+    public heatTransferCoeffModel
+{
+    // Private Member Functions
+
+        //- Disallow copy construct
+        fixedReferenceTemperature(const fixedReferenceTemperature&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const fixedReferenceTemperature&) = delete;
+
+
+protected:
+
+    // Protected data
+
+        //- Reference tempetaure
+        scalar TRef_;
+
+
+    // Protected Member Functions
+
+        //- Set the heat transfer coefficient
+        virtual void htc(volScalarField& htc);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fixedReferenceTemperature");
+
+
+    // Constructors
+
+        //- Construct from components
+        fixedReferenceTemperature
+        (
+            const dictionary& dict,
+            const fvMesh& mesh,
+            const word& TName
+        );
+
+
+    //- Destructor
+    virtual ~fixedReferenceTemperature()
+    {}
+
+
+    // Member Functions
+
+        //- Read from dictionary
+        virtual bool read(const dictionary& dict);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace heatTransferCoeffModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModel.C

@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "heatTransferCoeffModel.H"
+#include "fvMesh.H"
+#include "fluidThermo.H"
+#include "turbulentTransportModel.H"
+#include "turbulentFluidThermoModel.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(heatTransferCoeffModel, 0);
+    defineRunTimeSelectionTable(heatTransferCoeffModel, dictionary);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+Foam::tmp<Foam::FieldField<Foam::Field, Foam::scalar>>
+Foam::heatTransferCoeffModel::q() const
+{
+    const volScalarField& T = mesh_.lookupObject<volScalarField>(TName_);
+    const volScalarField::Boundary& Tbf = T.boundaryField();
+
+    tmp<FieldField<Field, scalar>> tq
+    (
+        new FieldField<Field, scalar>(Tbf.size())
+    );
+
+    FieldField<Field, scalar>& q = tq.ref();
+
+    forAll(q, patchi)
+    {
+        q.set(patchi, new Field<scalar>(Tbf[patchi].size(), 0));
+    }
+
+    typedef compressible::turbulenceModel cmpTurbModel;
+
+    if (mesh_.foundObject<cmpTurbModel>(cmpTurbModel::propertiesName))
+    {
+        const cmpTurbModel& turb =
+            mesh_.lookupObject<cmpTurbModel>(cmpTurbModel::propertiesName);
+
+        const volScalarField& he = turb.transport().he();
+        const volScalarField::Boundary& hebf = he.boundaryField();
+
+        const volScalarField alphaEff(turb.alphaEff());
+        const volScalarField::Boundary& alphaEffbf = alphaEff.boundaryField();
+
+        for (label patchi : patchSet_)
+        {
+            q[patchi] = alphaEffbf[patchi]*hebf[patchi].snGrad();
+        }
+    }
+    else if (mesh_.foundObject<fluidThermo>(fluidThermo::dictName))
+    {
+        const fluidThermo& thermo =
+            mesh_.lookupObject<fluidThermo>(fluidThermo::dictName);
+
+        const volScalarField& he = thermo.he();
+        const volScalarField::Boundary& hebf = he.boundaryField();
+
+        const volScalarField& alpha(thermo.alpha());
+        const volScalarField::Boundary& alphabf = alpha.boundaryField();
+
+        for (label patchi : patchSet_)
+        {
+            q[patchi] = alphabf[patchi]*hebf[patchi].snGrad();
+        }
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "Unable to find a valid thermo model to evaluate q"
+            << exit(FatalError);
+    }
+
+    // Add radiative heat flux contribution if present
+    if (mesh_.foundObject<volScalarField>(qrName_))
+    {
+        const volScalarField& qr = mesh_.lookupObject<volScalarField>(qrName_);
+        const volScalarField::Boundary& qrbf = qr.boundaryField();
+
+        for (label patchi : patchSet_)
+        {
+            q[patchi] += qrbf[patchi];
+        }
+    }
+
+    return tq;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::heatTransferCoeffModel::heatTransferCoeffModel
+(
+    const dictionary& dict,
+    const fvMesh& mesh,
+    const word& TName
+)
+:
+    mesh_(mesh),
+    TName_(TName),
+    patchSet_(),
+    qrName_("qr")
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::heatTransferCoeffModel::read(const dictionary& dict)
+{
+    const wordReList patchNames(dict.lookup("patches"));
+    patchSet_ = mesh_.boundaryMesh().patchSet(patchNames);
+    dict.readIfPresent("qr", qrName_);
+
+    return true;
+}
+
+
+bool Foam::heatTransferCoeffModel::calc(volScalarField& result)
+{
+    htc(result);
+
+    return true;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModel.H

@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+Namespace
+    Foam::heatTransferCoeffModels
+
+Description
+    A namespace for various heat transfer coefficient model implementations.
+
+Class
+    Foam::heatTransferCoeffModel
+
+Description
+    An abstract base class for heat transfer coeffcient models.
+
+SourceFiles
+    heatTransferCoeffModel.C
+    heatTransferCoeffModelNew.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef heatTransferCoeffModel_H
+#define heatTransferCoeffModel_H
+
+#include "dictionary.H"
+#include "HashSet.H"
+#include "volFields.H"
+
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class fvMesh;
+
+/*---------------------------------------------------------------------------*\
+                   Class heatTransferCoeffModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class heatTransferCoeffModel
+{
+
+    // Private Member Functions
+
+        //- Disallow copy construct
+        heatTransferCoeffModel(const heatTransferCoeffModel&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const heatTransferCoeffModel&) = delete;
+
+
+protected:
+
+    // Protected data
+
+        const fvMesh& mesh_;
+
+        const word TName_;
+
+        labelHashSet patchSet_;
+
+        word qrName_;
+
+        tmp<FieldField<Field, scalar>> q() const;
+
+        //- Set the heat transfer coefficient
+        virtual void htc(volScalarField& htc) = 0;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("heatTransferCoeffModel");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            heatTransferCoeffModel,
+            dictionary,
+            (
+                const dictionary& dict,
+                const fvMesh& mesh,
+                const word& TName
+            ),
+            (dict, mesh, TName)
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected heat transfer coefficicent model
+        static autoPtr<heatTransferCoeffModel> New
+        (
+            const dictionary& dict,
+            const fvMesh& mesh,
+            const word& TName
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        heatTransferCoeffModel
+        (
+            const dictionary& dict,
+            const fvMesh& mesh,
+            const word& TName
+        );
+
+
+    //- Destructor
+    virtual ~heatTransferCoeffModel()
+    {}
+
+
+    // Member Functions
+
+        //- Read from dictionary
+        virtual bool read(const dictionary& dict);
+
+        virtual bool calc(volScalarField& result);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/heatTransferCoeffModel/heatTransferCoeffModelNew.C

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+
+\*---------------------------------------------------------------------------*/
+
+#include "heatTransferCoeffModel.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::heatTransferCoeffModel> Foam::heatTransferCoeffModel::New
+(
+    const dictionary& dict,
+    const fvMesh& mesh,
+    const word& TName
+)
+{
+    const word modelType(dict.lookup("htcModel"));
+
+    Info<< "Selecting heat transfer coefficient model " << modelType << endl;
+
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
+
+    if (!cstrIter.found())
+    {
+        FatalErrorInFunction
+            << "Unknown heatTransferCoeffModel type "
+            << modelType << nl << nl
+            << "Valid heatTransferCoeffModels :" << endl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<heatTransferCoeffModel>(cstrIter()(dict, mesh, TName));
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/localReferenceTemperature/localReferenceTemperature.C

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "localReferenceTemperature.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace heatTransferCoeffModels
+{
+    defineTypeNameAndDebug(localReferenceTemperature, 0);
+    addToRunTimeSelectionTable
+    (
+        heatTransferCoeffModel,
+        localReferenceTemperature,
+        dictionary
+    );
+}
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::heatTransferCoeffModels::localReferenceTemperature::
+localReferenceTemperature
+(
+    const dictionary& dict,
+    const fvMesh& mesh,
+    const word& TName
+)
+:
+    heatTransferCoeffModel(dict, mesh, TName)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+bool Foam::heatTransferCoeffModels::localReferenceTemperature::read
+(
+    const dictionary& dict
+)
+{
+    return heatTransferCoeffModel::read(dict);
+}
+
+
+void Foam::heatTransferCoeffModels::localReferenceTemperature::htc
+(
+    volScalarField& htc
+)
+{
+    const FieldField<Field, scalar> qBf(q());
+    const volScalarField& T = mesh_.lookupObject<volScalarField>(TName_);
+    const volScalarField::Boundary& Tbf = T.boundaryField();
+    const scalar eps = ROOTVSMALL;
+
+    volScalarField::Boundary& htcBf = htc.boundaryFieldRef();
+    forAllConstIters(patchSet_, iter)
+    {
+        label patchi = iter.key();
+        const scalarField Tc(Tbf[patchi].patchInternalField());
+        htcBf[patchi] = qBf[patchi]/(Tc - Tbf[patchi] + eps);
+    }
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/heatTransferCoeff/heatTransferCoeffModels/localReferenceTemperature/localReferenceTemperature.H

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     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/>.
+
+Class
+    Foam::heatTransferCoeffModels::localReferenceTemperature
+
+Description
+    Heat transfer coefficient calculation that employs the patch internal
+    field as the reference temperature
+
+    The heat transfer coefficient is specified by:
+    
+    \f[
+        h = \frac{q}{T_c - T_w}
+    \f]
+
+Usage
+    Example of function object specification:
+    \verbatim
+        type            heatTransferCoeff;
+        libs            ("libfieldFunctionObjects.so");
+        ...
+    	htcModel	    localReferenceTemperature;
+        ...
+    \endverbatim
+
+    Where the entries comprise:
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: heatTransferCoeff | yes    |
+        htcModel     | selected htc model      | yes         |
+    \endtable
+
+SourceFiles
+    localReferenceTemperature.C
+
+SeeAlso
+    Foam::heatTransferCoeffModel
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef heatTransferCoeffModels_localReferenceTemperature_H
+#define heatTransferCoeffModels_localReferenceTemperature_H
+
+#include "heatTransferCoeffModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace heatTransferCoeffModels
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class localReferenceTemperature Declaration
+\*---------------------------------------------------------------------------*/
+
+class localReferenceTemperature
+:
+    public heatTransferCoeffModel
+{
+    // Private Member Functions
+
+        //- Disallow copy construct
+        localReferenceTemperature(const localReferenceTemperature&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const localReferenceTemperature&) = delete;
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Set the heat transfer coefficient
+        virtual void htc(volScalarField& htc);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("localReferenceTemperature");
+
+
+    // Constructors
+
+        //- Construct from components
+        localReferenceTemperature
+        (
+            const dictionary& dict,
+            const fvMesh& mesh,
+            const word& TName
+        );
+
+
+    //- Destructor
+    virtual ~localReferenceTemperature()
+    {}
+
+
+    // Member Functions
+
+        //- Read from dictionary
+        virtual bool read(const dictionary& dict);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace heatTransferCoeffModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/wallHeatFlux/wallHeatFlux.C

@@ -85,7 +85,7 @@ void Foam::functionObjects::wallHeatFlux::calcHeatFlux
 
         forAll(wallHeatFluxBf, patchi)
         {
-            wallHeatFluxBf[patchi] += radHeatFluxBf[patchi];
+            wallHeatFluxBf[patchi] -= radHeatFluxBf[patchi];
         }
     }
 }

src/lagrangian/basic/Cloud/Cloud.C

@@ -76,10 +76,10 @@ Foam::Cloud<ParticleType>::Cloud
 :
     cloud(pMesh, cloudName),
     IDLList<ParticleType>(),
-    geometryType_(IOPosition<Cloud<ParticleType>>::geometryType::COORDINATES),
     polyMesh_(pMesh),
     labels_(),
-    globalPositionsPtr_()
+    globalPositionsPtr_(),
+    geometryType_(IOPosition<Cloud<ParticleType>>::geometryType::COORDINATES)
 {
     checkPatches();
 

src/lagrangian/basic/Cloud/Cloud.H

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -75,9 +75,6 @@ class Cloud
 {
     // Private data
 
-        //- Geometry type
-        typename IOPosition<Cloud<ParticleType>>::geometryType geometryType_;
-
         //- Reference to the mesh database
         const polyMesh& polyMesh_;
 
@@ -109,6 +106,12 @@ class Cloud
         void writeCloudUniformProperties() const;
 
 
+protected:
+
+        //- Geometry type
+        typename IOPosition<Cloud<ParticleType>>::geometryType geometryType_;
+
+
 public:
 
     friend class particle;

src/lagrangian/basic/Cloud/CloudIO.C

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -167,10 +167,10 @@ Foam::Cloud<ParticleType>::Cloud
 )
 :
     cloud(pMesh, cloudName),
-    geometryType_(IOPosition<Cloud<ParticleType>>::geometryType::COORDINATES),
     polyMesh_(pMesh),
     labels_(),
-    cellWallFacesPtr_()
+    cellWallFacesPtr_(),
+    geometryType_(IOPosition<Cloud<ParticleType>>::geometryType::COORDINATES)
 {
     checkPatches();
 

src/lagrangian/basic/injectedParticle/injectedParticle.C

@@ -38,6 +38,7 @@ namespace Foam
 Foam::injectedParticle::injectedParticle(const injectedParticle& p)
 :
     particle(p),
+    position_(p.position_),
     tag_(p.tag_),
     soi_(p.soi_),
     d_(p.d_),
@@ -52,6 +53,7 @@ Foam::injectedParticle::injectedParticle
 )
 :
     particle(p, mesh),
+    position_(p.position_),
     tag_(p.tag_),
     soi_(p.soi_),
     d_(p.d_),

src/lagrangian/basic/injectedParticle/injectedParticle.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,11 +25,18 @@ Class
     Foam::injectedParticle
 
 Description
+    Primarly stores particle properties so that it can be injected at a later
+    time.  Note that this stores its own local position as opposed to the
+    base particle class barycentric coordinates since the particle is not
+    (usually) attached to a mesh, and instead used for post-processing.
 
 SourceFiles
     injectedParticle.C
     injectedParticleIO.C
 
+SeeAlso
+    Foam::functionObjects::extractEulerianParticles
+
 \*---------------------------------------------------------------------------*/
 
 #ifndef injectedParticle_H
@@ -74,6 +81,9 @@ protected:
 
         // Particle properties
 
+            //- Position
+            point position_;
+
             //- Tag
             label tag_;
 
@@ -125,7 +135,8 @@ public:
             const label tag,
             const scalar soi,
             const scalar d,
-            const vector& U
+            const vector& U,
+            const bool doLocate = true
         );
 
         //- Construct from Istream
@@ -225,6 +236,11 @@ public:
                 objectRegistry& obr
             );
 
+            //- Write the particle position and cell
+            //  Note: This uses the local particle position, and bypasses the
+            //  barycentric description
+            virtual void writePosition(Ostream&) const;
+
 
     // Ostream Operator
 

src/lagrangian/basic/injectedParticle/injectedParticleCloud.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -41,6 +41,9 @@ Foam::injectedParticleCloud::injectedParticleCloud
 :
     Cloud<injectedParticle>(mesh, cloudName, false)
 {
+    geometryType_ =
+        IOPosition<Cloud<injectedParticle>>::geometryType::POSITIONS;
+
     if (readFields)
     {
         injectedParticle::readFields(*this);

src/lagrangian/basic/injectedParticle/injectedParticleI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,10 +33,12 @@ inline Foam::injectedParticle::injectedParticle
     const label tag,
     const scalar soi,
     const scalar d,
-    const vector& U
+    const vector& U,
+    const bool doLocate
 )
 :
-    particle(mesh, position, -1),
+    particle(mesh, position, -1, -1, -1, doLocate),
+    position_(position),
     tag_(tag),
     soi_(soi),
     d_(d),

src/lagrangian/basic/injectedParticle/injectedParticleIO.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -38,6 +38,7 @@ Foam::string Foam::injectedParticle::propertyTypes_ =
 
 const std::size_t Foam::injectedParticle::sizeofFields
 (
+    // Note: does not include position_
     sizeof(label) + sizeof(scalar) + sizeof(scalar) + sizeof(vector)
 );
 
@@ -52,7 +53,8 @@ Foam::injectedParticle::injectedParticle
     bool newFormat
 )
 :
-    particle(mesh, is, readFields, newFormat),
+    particle(mesh, is, readFields, false), // force to read old positions file
+    position_(Zero),
     tag_(-1),
     soi_(0.0),
     d_(0.0),
@@ -60,6 +62,11 @@ Foam::injectedParticle::injectedParticle
 {
     if (readFields)
     {
+        // After the base particle class has read the fields from file and
+        // constructed the necessary barcentric co-ordinates we can update the
+        // particle position on this mesh
+        position_ = particle::position();
+
         if (is.format() == IOstream::ASCII)
         {
             tag_ = readLabel(is);
@@ -84,6 +91,8 @@ void Foam::injectedParticle::readFields(Cloud<injectedParticle>& c)
         return;
     }
 
+    // Note: not reading local position_ - defer to base particle class
+
     particle::readFields(c);
 
     IOField<label> tag(c.fieldIOobject("tag", IOobject::MUST_READ));
@@ -100,7 +109,7 @@ void Foam::injectedParticle::readFields(Cloud<injectedParticle>& c)
 
     label i = 0;
 
-    forAllIter(Cloud<injectedParticle>, c, iter)
+    forAllIters(c, iter)
     {
         injectedParticle& p = iter();
 
@@ -116,8 +125,14 @@ void Foam::injectedParticle::readFields(Cloud<injectedParticle>& c)
 
 void Foam::injectedParticle::writeFields(const Cloud<injectedParticle>& c)
 {
+    // Force writing positions instead of coordinates
+    particle::writeLagrangianCoordinates = false;
+    particle::writeLagrangianPositions = true;
+
     particle::writeFields(c);
 
+    // Note: not writing local position_ - defer to base particle class
+
     label np =  c.size();
 
     IOField<label> tag(c.fieldIOobject("tag", IOobject::NO_READ), np);
@@ -127,7 +142,7 @@ void Foam::injectedParticle::writeFields(const Cloud<injectedParticle>& c)
 
     label i = 0;
 
-    forAllConstIter(Cloud<injectedParticle>, c, iter)
+    forAllConstIters(c, iter)
     {
         const injectedParticle& p = iter();
 
@@ -152,6 +167,10 @@ void Foam::injectedParticle::writeObjects
     objectRegistry& obr
 )
 {
+    // Force writing positions instead of coordinates
+    particle::writeLagrangianCoordinates = false;
+    particle::writeLagrangianPositions = true;
+
     particle::writeObjects(c, obr);
 
     label np = c.size();
@@ -163,7 +182,7 @@ void Foam::injectedParticle::writeObjects
 
     label i = 0;
 
-    forAllConstIter(Cloud<injectedParticle>, c, iter)
+    forAllConstIters(c, iter)
     {
         const injectedParticle& p = iter();
 
@@ -177,6 +196,40 @@ void Foam::injectedParticle::writeObjects
 }
 
 
+void Foam::injectedParticle::writePosition(Ostream& os) const
+{
+    if (os.format() == IOstream::ASCII)
+    {
+        os  << position_ << token::SPACE << cell();
+    }
+    else
+    {
+        struct oldParticle
+        {
+            vector position;
+            label celli;
+            label facei;
+            scalar stepFraction;
+            label tetFacei;
+            label tetPti;
+            label origProc;
+            label origId;
+        } p;
+
+        const size_t s =
+            offsetof(oldParticle, facei) - offsetof(oldParticle, position);
+
+        p.position = position_;
+        p.celli = cell();
+
+        os.write(reinterpret_cast<const char*>(&p.position), s);
+    }
+
+    // Check state of Ostream
+    os.check(FUNCTION_NAME);
+}
+
+
 // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
 
 Foam::Ostream& Foam::operator<<
@@ -185,6 +238,8 @@ Foam::Ostream& Foam::operator<<
     const injectedParticle& p
 )
 {
+    // Note: not writing local position_ - defer to base particle class
+
     if (os.format() == IOstream::ASCII)
     {
         os  << static_cast<const particle&>(p)

src/lagrangian/basic/particle/particle.C

@@ -37,6 +37,10 @@ Foam::label Foam::particle::particleCount_ = 0;
 namespace Foam
 {
     defineTypeNameAndDebug(particle, 0);
+    bool particle::writeLagrangianCoordinates
+    (
+        debug::infoSwitch("writeLagrangianCoordinates", 1)
+    );
     bool particle::writeLagrangianPositions
     (
         debug::infoSwitch("writeLagrangianPositions", 0)
@@ -388,7 +392,7 @@ void Foam::particle::changeFace(const label tetTriI)
         tetFacei_ = newFaceI;
         tetPti_ = edgeI;
 
-        // Exit the loop now that the the tet point has been found
+        // Exit the loop now that the tet point has been found
         break;
     }
 
@@ -890,11 +894,11 @@ Foam::scalar Foam::particle::trackToMovingTri
     // Calculate the hit fraction
     label iH = -1;
     scalar muH = std::isnormal(detA[0]) && detA[0] <= 0 ? VGREAT : 1/detA[0];
-    for (label i = 0; i < 4; ++ i)
+    for (label i = 0; i < 4; ++i)
     {
         const Roots<3> mu = hitEqn[i].roots();
 
-        for (label j = 0; j < 3; ++ j)
+        for (label j = 0; j < 3; ++j)
         {
             if (mu.type(j) == roots::real && hitEqn[i].derivative(mu[j]) < 0)
             {

src/lagrangian/basic/particle/particle.H

@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2017 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -87,9 +87,6 @@ class particle
 {
     // Private member data
 
-        //- Write particle positions file (v1706 format and earlier)
-        static bool writeLagrangianPositions;
-
         //- Size in bytes of the position data
         static const std::size_t sizeofPosition;
 
@@ -335,8 +332,8 @@ public:
         //- String representation of properties
         DefinePropertyList
         (
-            "(Px Py Pz) celli tetFacei tetPti "
-            "facei stepFraction origProc origId"
+            "(coordinatesa coordinatesb coordinatesc coordinatesd) "
+            "celli tetFacei tetPti facei stepFraction origProc origId"
         );
 
         //- String representation of property types
@@ -348,6 +345,14 @@ public:
         //- Cumulative particle counter - used to provide unique ID
         static label particleCount_;
 
+        //- Write particle coordinates file (v1712 and later)
+        //- Default is true
+        static bool writeLagrangianCoordinates;
+
+        //- Write particle positions file (v1706 format and earlier)
+        //- Default is false
+        static bool writeLagrangianPositions;
+
 
     // Constructors
 
@@ -685,7 +690,7 @@ public:
         void writeCoordinates(Ostream&) const;
 
         //- Write the particle position and cell
-        void writePosition(Ostream&) const;
+        virtual void writePosition(Ostream&) const;
 
 
     // Friend Operators

src/lagrangian/basic/particle/particleTemplates.C

@@ -72,6 +72,7 @@ void Foam::particle::writeFields(const TrackCloudType& c)
 {
     label np = c.size();
 
+    if (writeLagrangianCoordinates)
     {
         IOPosition<TrackCloudType> ioP(c);
         ioP.write(np > 0);

src/lagrangian/intermediate/submodels/Kinematic/CollisionModel/PairCollision/PairCollision.C

@@ -220,7 +220,7 @@ void Foam::PairCollision<CloudType>::wallInteraction()
             typename CloudType::parcelType& p =
                 *cellOccupancy[realCelli][cellParticleI];
 
-            const point& pos = p.position();
+            const point pos(p.position());
 
             scalar r = wallModel_->pREff(p);
 

src/lagrangian/intermediate/submodels/Kinematic/InjectionModel/InflationInjection/InflationInjection.C

@@ -292,7 +292,7 @@ Foam::label Foam::InflationInjection<CloudType>::parcelsToInject
                     continue;
                 }
 
-                const point& pP = pPtr->position();
+                const point pP(pPtr->position());
                 const vector& pU = pPtr->U();
 
                 // Generate a tetrahedron of new positions with the

src/lagrangian/intermediate/submodels/Kinematic/ParticleForces/SRF/SRFForce.C

@@ -93,7 +93,7 @@ Foam::forceSuSp Foam::SRFForce<CloudType>::calcNonCoupled
 
     const vector& omega = srf.omega().value();
 
-    const vector& r = p.position();
+    const vector r(p.position());
 
     // Coriolis and centrifugal acceleration terms
     value.Su() =

src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.C

@@ -172,7 +172,7 @@ void Foam::SprayParcel<ParcelType>::calcAtomization
 
     scalar soi = cloud.injectors().timeStart();
     scalar currentTime = cloud.db().time().value();
-    const vector& pos = this->position();
+    const vector pos(this->position());
     const vector& injectionPos = this->position0();
 
     // Disregard the continous phase when calculating the relative velocity

src/lagrangian/spray/submodels/StochasticCollision/TrajectoryCollision/TrajectoryCollision.C

@@ -50,15 +50,15 @@ bool Foam::TrajectoryCollision<CloudType>::collideParcels
 {
     bool coalescence = false;
 
-    const vector& pos1 = p1.position();
-    const vector& pos2 = p2.position();
+    const vector pos1(p1.position());
+    const vector pos2(p2.position());
 
     const vector& U1 = p1.U();
     const vector& U2 = p2.U();
 
-    vector URel = U1 - U2;
+    vector URel(U1 - U2);
 
-    vector d = pos2 - pos1;
+    vector d(pos2 - pos1);
     scalar magd = mag(d);
 
     scalar vAlign = URel & (d/(magd + ROOTVSMALL));

src/randomProcesses/fft/fft.C

@@ -29,20 +29,20 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-Foam::tmp<Foam::complexField> fft::realTransform1D(const scalarField& field)
+Foam::tmp<Foam::complexField>
+Foam::fft::realTransform1D(const scalarField& field)
 {
     const label n = field.size();
     const label nBy2 = n/2;
 
     // Copy of input field for use by fftw
-    // - fftw requires non-const access to input and output...
-    scalar in[n], out[n];
-    forAll(field, i)
+    // - require non-const access to input and output
+    // - use double to avoid additional libfftwf for single-precision
+
+    List<double> in(n);
+    List<double> out(n);
+
+    for (label i=0; i < n; ++i)
     {
         in[i] = field[i];
     }
@@ -51,8 +51,8 @@ Foam::tmp<Foam::complexField> fft::realTransform1D(const scalarField& field)
     fftw_plan plan = fftw_plan_r2r_1d
     (
         n,
-        in,
-        out,
+        in.data(),
+        out.data(),
         FFTW_R2HC,
         FFTW_ESTIMATE
     );
@@ -77,7 +77,7 @@ Foam::tmp<Foam::complexField> fft::realTransform1D(const scalarField& field)
 }
 
 
-Foam::tmp<Foam::complexField> fft::realTransform1D
+Foam::tmp<Foam::complexField> Foam::fft::realTransform1D
 (
     const tmp<scalarField>& tfield
 )
@@ -88,7 +88,7 @@ Foam::tmp<Foam::complexField> fft::realTransform1D
 }
 
 
-void fft::transform
+void Foam::fft::transform
 (
     complexField& field,
     const UList<int>& nn,
@@ -110,7 +110,7 @@ void fft::transform
     }
 
     // Copy field into fftw containers
-    label N = field.size();
+    const label N = field.size();
     fftw_complex in[N], out[N];
 
     forAll(field, i)
@@ -128,7 +128,7 @@ void fft::transform
     //    fftw_plan_dft_1d(N, in, out, FFTW_FORWARD, FFTW_ESTIMATE);
 
     // Generic 1..3-D plan
-    label rank = nn.size();
+    const label rank = nn.size();
     fftw_plan plan =
         fftw_plan_dft(rank, nn.begin(), in, out, dir, FFTW_ESTIMATE);
 
@@ -163,7 +163,7 @@ void fft::transform
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-tmp<complexField> fft::forwardTransform
+Foam::tmp<Foam::complexField> Foam::fft::forwardTransform
 (
     const tmp<complexField>& tfield,
     const UList<int>& nn
@@ -179,7 +179,7 @@ tmp<complexField> fft::forwardTransform
 }
 
 
-tmp<complexField> fft::reverseTransform
+Foam::tmp<Foam::complexField> Foam::fft::reverseTransform
 (
     const tmp<complexField>& tfield,
     const UList<int>& nn
@@ -195,7 +195,7 @@ tmp<complexField> fft::reverseTransform
 }
 
 
-tmp<complexVectorField> fft::forwardTransform
+Foam::tmp<Foam::complexVectorField> Foam::fft::forwardTransform
 (
     const tmp<complexVectorField>& tfield,
     const UList<int>& nn
@@ -224,7 +224,7 @@ tmp<complexVectorField> fft::forwardTransform
 }
 
 
-tmp<complexVectorField> fft::reverseTransform
+Foam::tmp<Foam::complexVectorField> Foam::fft::reverseTransform
 (
     const tmp<complexVectorField>& tfield,
     const UList<int>& nn
@@ -253,8 +253,4 @@ tmp<complexVectorField> fft::reverseTransform
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

src/randomProcesses/noise/noiseFFT/noiseFFT.C

@@ -285,8 +285,8 @@ Foam::tmp<Foam::scalarField> Foam::noiseFFT::Pf
                 << abort(FatalError);
         }
 
-        List<scalar>& in = planInfo_.in;
-        const List<scalar>& out = planInfo_.out;
+        List<double>& in = planInfo_.in;
+        const List<double>& out = planInfo_.out;
         forAll(in, i)
         {
             in[i] = pn[i];
@@ -305,8 +305,8 @@ Foam::tmp<Foam::scalarField> Foam::noiseFFT::Pf
         result[0] = out[0];
         for (label i = 1; i <= nBy2; ++i)
         {
-            scalar re = out[i];
-            scalar im = out[n - i];
+            const auto re = out[i];
+            const auto im = out[n - i];
             result[i] = sqrt(re*re + im*im);
         }
 
@@ -443,7 +443,7 @@ Foam::graph Foam::noiseFFT::PSD(const graph& gPSDf) const
 Foam::graph Foam::noiseFFT::octaves
 (
     const graph& g,
-    const labelList& freqBandIDs,
+    const labelUList& freqBandIDs,
     bool integrate
 ) const
 {

src/randomProcesses/noise/noiseFFT/noiseFFT.H

@@ -68,13 +68,14 @@ class noiseFFT
 :
     public scalarField
 {
-    //- FFTW planner information
+    //- FFTW planner information.
+    //  Storage as double for use directly with FFTW.
     struct planInfo
     {
         bool active;
         label windowSize;
-        scalarList in;
-        scalarList out;
+        List<double> in;
+        List<double> out;
         fftw_plan plan;
     };
 
@@ -174,7 +175,7 @@ public:
         graph octaves
         (
             const graph& g,
-            const labelList& freqBandIDs,
+            const labelUList& freqBandIDs,
             bool integrate
         ) const;
 

src/sampling/sampledSurface/sampledTriSurfaceMesh/sampledTriSurfaceMesh.C

@@ -787,6 +787,12 @@ bool Foam::sampledTriSurfaceMesh::update()
     {
         // Surface and mesh do not overlap at all. Guarantee a valid
         // bounding box so we don't get any 'invalid bounding box' errors.
+
+        WarningInFunction
+            << "Surface " << surface_.searchableSurface::name()
+            << " does not overlap bounding box of mesh " << mesh().bounds()
+            << endl;
+
         bb = treeBoundBox(mesh().bounds());
         const vector span(bb.span());
 

src/waveModels/Make/files

@@ -8,6 +8,7 @@ waveGenerationModels/derived/Boussinesq/BoussinesqWaveModel.C
 waveGenerationModels/derived/cnoidal/cnoidalWaveModel.C
 waveGenerationModels/derived/Grimshaw/GrimshawWaveModel.C
 waveGenerationModels/derived/McCowan/McCowanWaveModel.C
+waveGenerationModels/derived/streamFunction/streamFunctionWaveModel.C
 waveGenerationModels/derived/StokesII/StokesIIWaveModel.C
 waveGenerationModels/derived/StokesI/StokesIWaveModel.C
 waveGenerationModels/derived/StokesV/StokesVWaveModel.C

src/waveModels/waveGenerationModels/derived/streamFunction/streamFunctionWaveModel.C

@@ -0,0 +1,256 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2015 IH-Cantabria
+-------------------------------------------------------------------------------
+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 "streamFunctionWaveModel.H"
+#include "mathematicalConstants.H"
+#include "addToRunTimeSelectionTable.H"
+
+using namespace Foam::constant;
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace waveModels
+{
+    defineTypeNameAndDebug(streamFunction, 0);
+    addToRunTimeSelectionTable
+    (
+        waveModel,
+        streamFunction,
+        patch
+    );
+}
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+Foam::scalar Foam::waveModels::streamFunction::eta
+(
+    const scalar h,
+    const scalar kx,
+    const scalar ky,
+    const scalar T,
+    const scalar x,
+    const scalar y,
+    const scalar omega,
+    const scalar t,
+    const scalar phase
+) const
+{
+
+   const scalar k = sqrt(kx*kx + ky*ky);
+   scalar strfnAux = 0.0;
+   forAll(Ejs_, iterSF)
+   {
+        strfnAux +=
+            Ejs_[iterSF]*cos((iterSF + 1)
+		   *(kx*x + ky*y - omega*t + phase));
+   }
+
+   return (1/k)*strfnAux;
+}
+
+Foam::vector Foam::waveModels::streamFunction::Uf
+(
+    const scalar h,
+    const scalar kx,
+    const scalar ky,
+    const scalar T,
+    const scalar x,
+    const scalar y,
+    const scalar omega,
+    const scalar t,
+    const scalar phase,
+    const scalar z
+) const
+{
+    const scalar k = sqrt(kx*kx + ky*ky);
+    const scalar phaseTot = kx*x + ky*y - omega*t + phase;
+
+    scalar u = 0.0;
+    scalar w = 0.0;
+
+    forAll(Bjs_, iterSF2)
+    {
+        u +=
+            (iterSF2 + 1)*Bjs_[iterSF2]*cosh((iterSF2 + 1)*k*z)
+           /cosh((iterSF2 + 1)*k*h)*cos((iterSF2 + 1)*phaseTot);
+
+        w +=
+            (iterSF2 + 1)*Bjs_[iterSF2]*sinh((iterSF2 + 1)*k*z)
+           /cosh((iterSF2 + 1)*k*h)*sin((iterSF2 + 1)*phaseTot);
+    }
+
+    u = waveLength_/T - uMean_ + sqrt(mag(g_)/k)*u;
+    w = sqrt(mag(g_)/k)*w;
+
+    scalar v = u*sin(waveAngle_);
+    u *= cos(waveAngle_);
+
+    return vector(u, v, w);
+}
+
+
+// * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * * //
+
+void Foam::waveModels::streamFunction::setLevel
+(
+    const scalar t,
+    const scalar tCoeff,
+    scalarField& level
+) const
+{
+    const scalar waveOmega = mathematical::twoPi/wavePeriod_;
+    const scalar waveK = mathematical::twoPi/waveLength_;
+    const scalar waveKx = waveK*cos(waveAngle_);
+    const scalar waveKy = waveK*sin(waveAngle_);
+
+    forAll(level, paddlei)
+    {
+        const scalar eta =
+            this->eta
+            (
+                waterDepthRef_,
+        		waveKx,
+                waveKy,
+                wavePeriod_,
+                xPaddle_[paddlei],
+                yPaddle_[paddlei],
+		        waveOmega,
+                t,
+                wavePhase_
+            );
+
+        level[paddlei] = waterDepthRef_ + tCoeff*eta;
+    }
+}
+
+
+void Foam::waveModels::streamFunction::setVelocity
+(
+    const scalar t,
+    const scalar tCoeff,
+    const scalarField& level
+)
+{
+    const scalar waveOmega = mathematical::twoPi/wavePeriod_;
+    const scalar waveK = mathematical::twoPi/waveLength_;
+    const scalar waveKx = waveK*cos(waveAngle_);
+    const scalar waveKy = waveK*sin(waveAngle_);
+
+    forAll(U_, facei)
+    {
+        // Fraction of geometry represented by paddle - to be set
+        scalar fraction = 1;
+
+        // Height - to be set
+        scalar z = 0;
+
+        setPaddlePropeties(level, facei, fraction, z);
+
+        if (fraction > 0)
+        {
+            const label paddlei = faceToPaddle_[facei];
+
+            const vector Uf = this->Uf
+            (
+                waterDepthRef_,
+                waveKx,
+                waveKy,
+                wavePeriod_,
+                xPaddle_[paddlei],
+                yPaddle_[paddlei],
+		        waveOmega,
+                t,
+                wavePhase_,
+                z
+            );
+
+            U_[facei] = fraction*Uf*tCoeff;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::waveModels::streamFunction::streamFunction
+(
+    const dictionary& dict,
+    const fvMesh& mesh,
+    const polyPatch& patch,
+    const bool readFields
+)
+:
+    regularWaveModel(dict, mesh, patch, false),
+    uMean_(0),
+    Bjs_(),
+    Ejs_()
+{
+    if (readFields)
+    {
+        readDict(dict);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::waveModels::streamFunction::~streamFunction()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::waveModels::streamFunction::readDict(const dictionary& overrideDict)
+{
+    if (regularWaveModel::readDict(overrideDict))
+    {
+	    overrideDict.lookup("uMean") >> uMean_;
+	    overrideDict.lookup("waveLength") >> waveLength_;
+	    overrideDict.lookup("Bjs") >> Bjs_;
+	    overrideDict.lookup("Ejs") >> Ejs_;
+
+        return true;
+    }
+
+    return false;
+}
+
+
+void Foam::waveModels::streamFunction::info(Ostream& os) const
+{
+    regularWaveModel::info(os);
+
+    os  << "    uMean : " << uMean_ << nl
+        << "    Stream function wavelength : " << waveLength_ << nl
+        << "    Bj coefficients : " << Bjs_ << nl
+        << "    Ej coefficients : " << Ejs_ << nl;
+}
+
+
+// ************************************************************************* //

src/waveModels/waveGenerationModels/derived/streamFunction/streamFunctionWaveModel.H

@@ -0,0 +1,157 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2015 IH-Cantabria
+-------------------------------------------------------------------------------
+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::waveModels::streamFunction
+
+Description
+    streamFunction wave model
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef waveModels_streamFunction_H
+#define waveModels_streamFunction_H
+
+#include "regularWaveModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace waveModels
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class streamFunction Declaration
+\*---------------------------------------------------------------------------*/
+
+class streamFunction
+:
+    public regularWaveModel
+{
+private:
+
+    // Private Member Functions
+
+        //- Wave height
+        virtual scalar eta
+        (
+            const scalar h,
+            const scalar kx,
+            const scalar ky,
+            const scalar T,
+            const scalar x,
+            const scalar y,
+            const scalar omega,
+            const scalar t,
+            const scalar phase
+        ) const;
+
+        //- Wave velocity
+        virtual vector Uf
+        (
+            const scalar d,
+            const scalar kx,
+            const scalar ky,
+            const scalar T,
+            const scalar x,
+            const scalar y,
+            const scalar omega,
+            const scalar t,
+            const scalar phase,
+            const scalar z
+        ) const;
+
+
+protected:
+
+    // Protected data
+
+        //- Mean fluid speed in frame of reference (stream function)
+        scalar uMean_;
+
+        //- Stream Function Bj coefficients
+        scalarList Bjs_;
+
+        //- Stream Function Ej coefficients
+        scalarList Ejs_;
+
+
+    // Protected Member Functions
+
+
+        //- Set the water level
+        virtual void setLevel
+        (
+            const scalar t,
+            const scalar tCoeff,
+            scalarField& level
+        ) const;
+
+        //- Calculate the wave model velocity
+        virtual void setVelocity
+        (
+            const scalar t,
+            const scalar tCoeff,
+            const scalarField& level
+        );
+
+
+public:
+
+    //- Runtime type information
+    TypeName("streamFunction");
+
+    //- Constructor
+    streamFunction
+    (
+        const dictionary& dict,
+        const fvMesh& mesh,
+        const polyPatch& patch,
+        const bool readFields = true
+    );
+
+    //- Destructor
+    virtual ~streamFunction();
+
+
+    // Public Member Functions
+
+        //- Read from dictionary
+        virtual bool readDict(const dictionary& overrideDict);
+
+        //- Info
+        virtual void info(Ostream& os) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace waveModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //