Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

applications/solvers/multiphase/compressibleInterFoam/Make/files

@@ -1,4 +1,3 @@
-derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.C
 compressibleInterFoam.C
 
 EXE = $(FOAM_APPBIN)/compressibleInterFoam

applications/solvers/multiphase/compressibleInterFoam/Make/options

@@ -1,16 +1,19 @@
 EXE_INC = \
+    -ItwoPhaseThermo \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/lnInclude \
     -I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
-    -IphaseEquationsOfState/lnInclude \
     -I$(LIB_SRC)/turbulenceModels/incompressible/turbulenceModel \
     -I$(LIB_SRC)/finiteVolume/lnInclude
 
 EXE_LIBS = \
+    -ltwoPhaseThermo \
+    -lfluidThermophysicalModels \
+    -lspecie \
     -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \
-    -lphaseEquationsOfState \
     -lincompressibleTurbulenceModel \
     -lincompressibleRASModels \
     -lincompressibleLESModels \

applications/solvers/multiphase/compressibleInterFoam/TEqn.H

@@ -1,20 +1,14 @@
 {
-    volScalarField kByCv
-    (
-        "kByCv",
-        (alpha1*k1/Cv1 + alpha2*k2/Cv2)
-      + (alpha1*rho1 + alpha2*rho2)*turbulence->nut()
-    );
-
     solve
     (
         fvm::ddt(rho, T)
       + fvm::div(rhoPhi, T)
-      - fvm::laplacian(kByCv, T)
+      - fvm::laplacian(thermo.alphaEff(rho*turbulence->nut()), T)
-      + p*fvc::div(phi)*(alpha1/Cv1 + alpha2/Cv2)
+      + (
+            p*fvc::div(phi)
+          + fvc::ddt(rho, K) + fvc::div(rhoPhi, K)
+        )*(alpha1/thermo.thermo1().Cv() + alpha2/thermo.thermo2().Cv())
     );
 
-    // Update compressibilities
+    thermo.correct();
-    psi1 = eos1->psi(p, T);
-    psi2 = eos2->psi(p, T);
 }

applications/solvers/multiphase/compressibleInterFoam/UEqn.H

@@ -22,4 +22,6 @@
                 ) * mesh.magSf()
             )
         );
+
+        K = 0.5*magSqr(U);
     }

applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/Make/options

@@ -1,5 +1,7 @@
 EXE_INC = \
     -I.. \
+    -I../twoPhaseThermo \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
     -I$(LIB_SRC)/transportModels \
     -I$(LIB_SRC)/transportModels/incompressible/lnInclude \
     -I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
@@ -11,6 +13,9 @@ EXE_INC = \
     -I$(LIB_SRC)/dynamicFvMesh/lnInclude
 
 EXE_LIBS = \
+    -ltwoPhaseThermo \
+    -lfluidThermophysicalModels \
+    -lspecie \
     -linterfaceProperties \
     -ltwoPhaseInterfaceProperties \
     -lincompressibleTransportModels \

applications/solvers/multiphase/compressibleInterFoam/compressibleInterDyMFoam/compressibleInterDyMFoam.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,7 +43,7 @@ Description
 #include "subCycle.H"
 #include "interfaceProperties.H"
 #include "twoPhaseMixture.H"
-#include "phaseEquationOfState.H"
+#include "twoPhaseThermo.H"
 #include "turbulenceModel.H"
 #include "pimpleControl.H"
 

applications/solvers/multiphase/compressibleInterFoam/compressibleInterFoam.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -38,9 +38,10 @@ Description
 #include "fvCFD.H"
 #include "MULES.H"
 #include "subCycle.H"
+#include "rhoThermo.H"
 #include "interfaceProperties.H"
 #include "twoPhaseMixture.H"
-#include "phaseEquationOfState.H"
+#include "twoPhaseThermo.H"
 #include "turbulenceModel.H"
 #include "pimpleControl.H"
 

applications/solvers/multiphase/compressibleInterFoam/createFields.H

@@ -28,34 +28,6 @@
 
     #include "createPhi.H"
 
-    Info<< "Reading field T\n" << endl;
-    volScalarField T
-    (
-        IOobject
-        (
-            "T",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::AUTO_WRITE
-        ),
-        mesh
-    );
-
-    volScalarField p
-    (
-        IOobject
-        (
-            "p",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        p_rgh
-    );
-
-
     Info<< "Reading transportProperties\n" << endl;
     twoPhaseMixture twoPhaseProperties(U, phi);
 
@@ -69,91 +41,31 @@
         scalar(1) - alpha1
     );
 
-    dimensionedScalar k1
+    Info<< "Reading thermophysical properties\n" << endl;
-    (
-        "k",
-        dimensionSet(1, 1, -3, -1, 0),
-        twoPhaseProperties.subDict
-        (
-            twoPhaseProperties.phase1Name()
-        ).lookup("k")
-    );
 
-    dimensionedScalar k2
+    twoPhaseThermo thermo(mesh, alpha1, alpha2);
-    (
-        "k",
-        dimensionSet(1, 1, -3, -1, 0),
-        twoPhaseProperties.subDict
-        (
-            twoPhaseProperties.phase2Name()
-        ).lookup("k")
-    );
 
-    dimensionedScalar Cv1
+    volScalarField& rho = thermo.rho();
-    (
+    volScalarField& p = thermo.p();
-        "Cv",
+    volScalarField& T = thermo.T();
-        dimensionSet(0, 2, -2, -1, 0),
+    const volScalarField& rho1 = thermo.thermo1().rho();
-        twoPhaseProperties.subDict
+    const volScalarField& psi1 = thermo.thermo1().psi();
-        (
+    const volScalarField& rho2 = thermo.thermo2().rho();
-            twoPhaseProperties.phase1Name()
+    const volScalarField& psi2 = thermo.thermo2().psi();
-        ).lookup("Cv")
-    );
 
-    dimensionedScalar Cv2
+    // volScalarField rho
-    (
+    // (
-        "Cv",
+    //     IOobject
-        dimensionSet(0, 2, -2, -1, 0),
+    //     (
-        twoPhaseProperties.subDict
+    //         "rho",
-        (
+    //         runTime.timeName(),
-            twoPhaseProperties.phase2Name()
+    //         mesh,
-        ).lookup("Cv")
+    //         IOobject::READ_IF_PRESENT,
-    );
+    //         IOobject::AUTO_WRITE
+    //     ),
+    //     alpha1*rho1 + alpha2*rho2
+    // );
 
-    autoPtr<phaseEquationOfState> eos1
-    (
-        phaseEquationOfState::New
-        (
-            twoPhaseProperties.subDict
-            (
-                twoPhaseProperties.phase1Name()
-            )
-        )
-    );
-
-    autoPtr<phaseEquationOfState> eos2
-    (
-        phaseEquationOfState::New
-        (
-            twoPhaseProperties.subDict
-            (
-                twoPhaseProperties.phase2Name()
-            )
-        )
-    );
-
-    volScalarField psi1
-    (
-        IOobject
-        (
-            "psi1",
-            runTime.timeName(),
-            mesh
-        ),
-        eos1->psi(p, T)
-    );
-    psi1.oldTime();
-
-    volScalarField psi2
-    (
-        IOobject
-        (
-            "psi2",
-            runTime.timeName(),
-            mesh
-        ),
-        eos2->psi(p, T)
-    );
-    psi2.oldTime();
 
     dimensionedScalar pMin(twoPhaseProperties.lookup("pMin"));
 
@@ -161,23 +73,6 @@
     volScalarField gh("gh", g & mesh.C());
     surfaceScalarField ghf("ghf", g & mesh.Cf());
 
-    volScalarField rho1("rho1", eos1->rho(p, T));
-    volScalarField rho2("rho2", eos2->rho(p, T));
-
-    volScalarField rho
-    (
-        IOobject
-        (
-            "rho",
-            runTime.timeName(),
-            mesh,
-            IOobject::READ_IF_PRESENT,
-            IOobject::AUTO_WRITE
-        ),
-        alpha1*rho1 + alpha2*rho2
-    );
-
-
     // Mass flux
     // Initialisation does not matter because rhoPhi is reset after the
     // alpha1 solution before it is used in the U equation.
@@ -207,3 +102,19 @@
     (
         incompressible::turbulenceModel::New(U, phi, twoPhaseProperties)
     );
+
+    Info<< "Creating field dpdt\n" << endl;
+    volScalarField dpdt
+    (
+        IOobject
+        (
+            "dpdt",
+            runTime.timeName(),
+            mesh
+        ),
+        mesh,
+        dimensionedScalar("dpdt", p.dimensions()/dimTime, 0)
+    );
+
+    Info<< "Creating field kinetic energy K\n" << endl;
+    volScalarField K("K", 0.5*magSqr(U));

applications/solvers/multiphase/compressibleInterFoam/derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.C

@@ -1,184 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "wallHeatTransferFvPatchScalarField.H"
-#include "addToRunTimeSelectionTable.H"
-#include "fvPatchFieldMapper.H"
-#include "volFields.H"
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::wallHeatTransferFvPatchScalarField::wallHeatTransferFvPatchScalarField
-(
-    const fvPatch& p,
-    const DimensionedField<scalar, volMesh>& iF
-)
-:
-    mixedFvPatchScalarField(p, iF),
-    Tinf_(p.size(), 0.0),
-    alphaWall_(p.size(), 0.0)
-{
-    refValue() = 0.0;
-    refGrad() = 0.0;
-    valueFraction() = 0.0;
-}
-
-
-Foam::wallHeatTransferFvPatchScalarField::wallHeatTransferFvPatchScalarField
-(
-    const wallHeatTransferFvPatchScalarField& ptf,
-    const fvPatch& p,
-    const DimensionedField<scalar, volMesh>& iF,
-    const fvPatchFieldMapper& mapper
-)
-:
-    mixedFvPatchScalarField(ptf, p, iF, mapper),
-    Tinf_(ptf.Tinf_, mapper),
-    alphaWall_(ptf.alphaWall_, mapper)
-{}
-
-
-Foam::wallHeatTransferFvPatchScalarField::wallHeatTransferFvPatchScalarField
-(
-    const fvPatch& p,
-    const DimensionedField<scalar, volMesh>& iF,
-    const dictionary& dict
-)
-:
-    mixedFvPatchScalarField(p, iF),
-    Tinf_("Tinf", dict, p.size()),
-    alphaWall_("alphaWall", dict, p.size())
-{
-    refValue() = Tinf_;
-    refGrad() = 0.0;
-    valueFraction() = 0.0;
-
-    if (dict.found("value"))
-    {
-        fvPatchField<scalar>::operator=
-        (
-            scalarField("value", dict, p.size())
-        );
-    }
-    else
-    {
-        evaluate();
-    }
-}
-
-
-Foam::wallHeatTransferFvPatchScalarField::wallHeatTransferFvPatchScalarField
-(
-    const wallHeatTransferFvPatchScalarField& tppsf
-)
-:
-    mixedFvPatchScalarField(tppsf),
-    Tinf_(tppsf.Tinf_),
-    alphaWall_(tppsf.alphaWall_)
-{}
-
-
-Foam::wallHeatTransferFvPatchScalarField::wallHeatTransferFvPatchScalarField
-(
-    const wallHeatTransferFvPatchScalarField& tppsf,
-    const DimensionedField<scalar, volMesh>& iF
-)
-:
-    mixedFvPatchScalarField(tppsf, iF),
-    Tinf_(tppsf.Tinf_),
-    alphaWall_(tppsf.alphaWall_)
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-void Foam::wallHeatTransferFvPatchScalarField::autoMap
-(
-    const fvPatchFieldMapper& m
-)
-{
-    scalarField::autoMap(m);
-    Tinf_.autoMap(m);
-    alphaWall_.autoMap(m);
-}
-
-
-void Foam::wallHeatTransferFvPatchScalarField::rmap
-(
-    const fvPatchScalarField& ptf,
-    const labelList& addr
-)
-{
-    mixedFvPatchScalarField::rmap(ptf, addr);
-
-    const wallHeatTransferFvPatchScalarField& tiptf =
-        refCast<const wallHeatTransferFvPatchScalarField>(ptf);
-
-    Tinf_.rmap(tiptf.Tinf_, addr);
-    alphaWall_.rmap(tiptf.alphaWall_, addr);
-}
-
-
-void Foam::wallHeatTransferFvPatchScalarField::updateCoeffs()
-{
-    if (updated())
-    {
-        return;
-    }
-
-    const fvPatchScalarField& Cpw =
-        patch().lookupPatchField<volScalarField, scalar>("Cp");
-
-    const fvPatchScalarField& kByCpw =
-        patch().lookupPatchField<volScalarField, scalar>("kByCp");
-
-    valueFraction() =
-        1.0/
-        (
-            1.0
-          + Cpw*kByCpw*patch().deltaCoeffs()/alphaWall_
-        );
-
-    mixedFvPatchScalarField::updateCoeffs();
-}
-
-
-void Foam::wallHeatTransferFvPatchScalarField::write(Ostream& os) const
-{
-    fvPatchScalarField::write(os);
-    Tinf_.writeEntry("Tinf", os);
-    alphaWall_.writeEntry("alphaWall", os);
-    writeEntry("value", os);
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    makePatchTypeField(fvPatchScalarField, wallHeatTransferFvPatchScalarField);
-}
-
-// ************************************************************************* //

applications/solvers/multiphase/compressibleInterFoam/derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.H

@@ -1,194 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::wallHeatTransferFvPatchScalarField
-
-Description
-    Enthalpy boundary conditions for wall heat transfer
-
-SourceFiles
-    wallHeatTransferFvPatchScalarField.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef wallHeatTransferFvPatchScalarField_H
-#define wallHeatTransferFvPatchScalarField_H
-
-#include "mixedFvPatchFields.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                  Class wallHeatTransferFvPatch Declaration
-\*---------------------------------------------------------------------------*/
-
-class wallHeatTransferFvPatchScalarField
-:
-    public mixedFvPatchScalarField
-{
-    // Private data
-
-        //- Tinf
-        scalarField Tinf_;
-
-        //- alphaWall
-        scalarField alphaWall_;
-
-
-public:
-
-    //- Runtime type information
-    TypeName("wallHeatTransfer");
-
-
-    // Constructors
-
-        //- Construct from patch and internal field
-        wallHeatTransferFvPatchScalarField
-        (
-            const fvPatch&,
-            const DimensionedField<scalar, volMesh>&
-        );
-
-        //- Construct from patch, internal field and dictionary
-        wallHeatTransferFvPatchScalarField
-        (
-            const fvPatch&,
-            const DimensionedField<scalar, volMesh>&,
-            const dictionary&
-        );
-
-        //- Construct by mapping given wallHeatTransferFvPatchScalarField
-        // onto a new patch
-        wallHeatTransferFvPatchScalarField
-        (
-            const wallHeatTransferFvPatchScalarField&,
-            const fvPatch&,
-            const DimensionedField<scalar, volMesh>&,
-            const fvPatchFieldMapper&
-        );
-
-        //- Construct as copy
-        wallHeatTransferFvPatchScalarField
-        (
-            const wallHeatTransferFvPatchScalarField&
-        );
-
-        //- Construct and return a clone
-        virtual tmp<fvPatchScalarField> clone() const
-        {
-            return tmp<fvPatchScalarField>
-            (
-                new wallHeatTransferFvPatchScalarField(*this)
-            );
-        }
-
-        //- Construct as copy setting internal field reference
-        wallHeatTransferFvPatchScalarField
-        (
-            const wallHeatTransferFvPatchScalarField&,
-            const DimensionedField<scalar, volMesh>&
-        );
-
-        //- Construct and return a clone setting internal field reference
-        virtual tmp<fvPatchScalarField> clone
-        (
-            const DimensionedField<scalar, volMesh>& iF
-        ) const
-        {
-            return tmp<fvPatchScalarField>
-            (
-                new wallHeatTransferFvPatchScalarField(*this, iF)
-            );
-        }
-
-
-    // Member functions
-
-        // Access
-
-            //- Return Tinf
-            const scalarField& Tinf() const
-            {
-                return Tinf_;
-            }
-
-            //- Return reference to Tinf to allow adjustment
-            scalarField& Tinf()
-            {
-                return Tinf_;
-            }
-
-            //- Return alphaWall
-            const scalarField& alphaWall() const
-            {
-                return alphaWall_;
-            }
-
-            //- Return reference to alphaWall to allow adjustment
-            scalarField& alphaWall()
-            {
-                return alphaWall_;
-            }
-
-
-        // Mapping functions
-
-            //- Map (and resize as needed) from self given a mapping object
-            virtual void autoMap
-            (
-                const fvPatchFieldMapper&
-            );
-
-            //- Reverse map the given fvPatchField onto this fvPatchField
-            virtual void rmap
-            (
-                const fvPatchScalarField&,
-                const labelList&
-            );
-
-
-        // Evaluation functions
-
-            //- Update the coefficients associated with the patch field
-            virtual void updateCoeffs();
-
-
-        //- Write
-        virtual void write(Ostream&) const;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

applications/solvers/multiphase/compressibleInterFoam/pEqn.H

@@ -1,7 +1,4 @@
 {
-    rho1 = eos1->rho(p, T);
-    rho2 = eos2->rho(p, T);
-
     volScalarField rAU("rAU", 1.0/UEqn.A());
     surfaceScalarField rAUf("Dp", fvc::interpolate(rAU));
 
@@ -91,9 +88,15 @@
 
     p = max(p_rgh + (alpha1*rho1 + alpha2*rho2)*gh, pMin);
 
-    rho1 = eos1->rho(p, T);
+    // thermo.correct();
-    rho2 = eos2->rho(p, T);
 
     Info<< "max(U) " << max(mag(U)).value() << endl;
     Info<< "min(p_rgh) " << min(p_rgh).value() << endl;
+
+    K = 0.5*magSqr(U);
+
+    if (thermo.dpdt())
+    {
+        dpdt = fvc::ddt(p);
+    }
 }

applications/solvers/multiphase/compressibleInterFoam/twoPhaseThermo/Make/files

@@ -0,0 +1,3 @@
+twoPhaseThermo.C
+
+LIB = $(FOAM_LIBBIN)/libtwoPhaseThermo

applications/solvers/multiphase/compressibleInterFoam/twoPhaseThermo/Make/options

@@ -0,0 +1,8 @@
+EXE_INC = \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude
+
+LIB_LIBS = \
+    -lfluidThermophysicalModels \
+    -lspecie \
+    -lfiniteVolume

applications/solvers/multiphase/compressibleInterFoam/twoPhaseThermo/twoPhaseThermo.C

@@ -0,0 +1,365 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "twoPhaseThermo.H"
+#include "gradientEnergyFvPatchScalarField.H"
+#include "mixedEnergyFvPatchScalarField.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(twoPhaseThermo, 0);
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::twoPhaseThermo::twoPhaseThermo
+(
+    const fvMesh& mesh,
+    const volScalarField& alpha1,
+    const volScalarField& alpha2,
+    const word& phaseName
+)
+:
+    rhoThermo(mesh, phaseName),
+    phaseName1_("1"),
+    phaseName2_("2"),
+    alpha1_(alpha1),
+    alpha2_(alpha2),
+    thermo1_(rhoThermo::New(mesh, phaseName1_)),
+    thermo2_(rhoThermo::New(mesh, phaseName2_)),
+    he_
+    (
+        IOobject
+        (
+            phasePropertyName
+            (
+                "he"
+            ),
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimEnergy/dimMass,
+        heBoundaryTypes(),
+        heBoundaryBaseTypes()
+    )
+{
+    thermo1_->validate("phaseModel 1", "e");
+    thermo2_->validate("phaseModel 2", "e");
+
+    rho_ = alpha1_*thermo1_->rho() + alpha2_*thermo2_->rho();
+
+    he_ =
+    (
+        alpha1_*thermo1_->rho()*thermo1_->he()
+      + alpha2_*thermo2_->rho()*thermo2_->he()
+    )/rho_;
+
+    volScalarField::GeometricBoundaryField& hbf = he_.boundaryField();
+
+    forAll(hbf, patchi)
+    {
+        if (isA<gradientEnergyFvPatchScalarField>(hbf[patchi]))
+        {
+            refCast<gradientEnergyFvPatchScalarField>(hbf[patchi]).gradient()
+                = hbf[patchi].fvPatchField::snGrad();
+        }
+        else if (isA<mixedEnergyFvPatchScalarField>(hbf[patchi]))
+        {
+            refCast<mixedEnergyFvPatchScalarField>(hbf[patchi]).refGrad()
+                = hbf[patchi].fvPatchField::snGrad();
+        }
+    }
+
+    correct();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::twoPhaseThermo::~twoPhaseThermo()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::twoPhaseThermo::correct()
+{
+    thermo1_->he() = thermo1_->he(p_, T_);
+    thermo1_->correct();
+
+    thermo2_->he() = thermo2_->he(p_, T_);
+    thermo2_->correct();
+
+    psi_ = alpha1_*thermo1_->psi() + alpha2_*thermo2_->psi();
+    mu_ = alpha1_*thermo1_->mu() + alpha2_*thermo2_->mu();
+    alpha_ = alpha1_*thermo1_->alpha() + alpha2_*thermo2_->alpha();
+}
+
+
+bool Foam::twoPhaseThermo::incompressible() const
+{
+    return thermo1_->incompressible() && thermo2_->incompressible();
+}
+
+
+bool Foam::twoPhaseThermo::isochoric() const
+{
+    return thermo1_->isochoric() && thermo2_->isochoric();
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::he
+(
+    const volScalarField& p,
+    const volScalarField& T
+) const
+{
+    return alpha1_*thermo1_->he(p, T) + alpha2_*thermo2_->he(p, T);
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::he
+(
+    const scalarField& p,
+    const scalarField& T,
+    const labelList& cells
+) const
+{
+    return
+        scalarField(alpha1_, cells)*thermo1_->he(p, T, cells)
+      + scalarField(alpha2_, cells)*thermo2_->he(p, T, cells);
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::he
+(
+    const scalarField& p,
+    const scalarField& T,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->he(p, T, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->he(p, T, patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::hc() const
+{
+    return alpha1_*thermo1_->hc() + alpha2_*thermo2_->hc();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::THE
+(
+    const scalarField& h,
+    const scalarField& p,
+    const scalarField& T0,
+    const labelList& cells
+) const
+{
+    notImplemented("Foam::twoPhaseThermo::THE");
+    return T0;
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::THE
+(
+    const scalarField& h,
+    const scalarField& p,
+    const scalarField& T0,
+    const label patchi
+) const
+{
+    notImplemented("Foam::twoPhaseThermo::THE");
+    return T0;
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::Cp() const
+{
+    return alpha1_*thermo1_->Cp() + alpha2_*thermo2_->Cp();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::Cp
+(
+    const scalarField& p,
+    const scalarField& T,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->Cp(p, T, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->Cp(p, T, patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::Cv() const
+{
+    return alpha1_*thermo1_->Cv() + alpha2_*thermo2_->Cv();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::Cv
+(
+    const scalarField& p,
+    const scalarField& T,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->Cv(p, T, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->Cv(p, T, patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::gamma() const
+{
+    return alpha1_*thermo1_->gamma() + alpha2_*thermo2_->gamma();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::gamma
+(
+    const scalarField& p,
+    const scalarField& T,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->gamma(p, T, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->gamma(p, T, patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::Cpv() const
+{
+    return alpha1_*thermo1_->Cpv() + alpha2_*thermo2_->Cpv();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::Cpv
+(
+    const scalarField& p,
+    const scalarField& T,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->Cpv(p, T, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->Cpv(p, T, patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::CpByCpv() const
+{
+    return alpha1_*thermo1_->CpByCpv() + alpha2_*thermo2_->CpByCpv();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::CpByCpv
+(
+    const scalarField& p,
+    const scalarField& T,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->CpByCpv(p, T, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->CpByCpv(p, T, patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::kappa() const
+{
+    return alpha1_*thermo1_->kappa() + alpha2_*thermo2_->kappa();
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::kappa
+(
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->kappa(patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->kappa(patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::kappaEff
+(
+    const volScalarField& alphat
+) const
+{
+    return
+        alpha1_*thermo1_->kappaEff(alphat)
+      + alpha2_*thermo2_->kappaEff(alphat);
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::kappaEff
+(
+    const scalarField& alphat,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->kappaEff(alphat, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->kappaEff(alphat, patchi);
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::twoPhaseThermo::alphaEff
+(
+    const volScalarField& alphat
+) const
+{
+    return
+        alpha1_*thermo1_->alphaEff(alphat)
+      + alpha2_*thermo2_->alphaEff(alphat);
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::twoPhaseThermo::alphaEff
+(
+    const scalarField& alphat,
+    const label patchi
+) const
+{
+    return
+        alpha1_.boundaryField()[patchi]*thermo1_->alphaEff(alphat, patchi)
+      + alpha2_.boundaryField()[patchi]*thermo2_->alphaEff(alphat, patchi);
+}
+
+
+// ************************************************************************* //

applications/solvers/multiphase/compressibleInterFoam/twoPhaseThermo/twoPhaseThermo.H

@@ -0,0 +1,290 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::twoPhaseThermo
+
+Description
+
+SourceFiles
+    twoPhaseThermoI.H
+    twoPhaseThermo.C
+    twoPhaseThermoIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef twoPhaseThermo_H
+#define twoPhaseThermo_H
+
+#include "rhoThermo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class twoPhaseThermo Declaration
+\*---------------------------------------------------------------------------*/
+
+class twoPhaseThermo
+:
+    public rhoThermo
+{
+    // Private data
+
+        //- Name of phase 1
+        word phaseName1_;
+
+        //- Name of phase 2
+        word phaseName2_;
+
+        //- Phase-fraction of phase 1
+        const volScalarField& alpha1_;
+
+        //- Phase-fraction of phase2
+        const volScalarField& alpha2_;
+
+        //- Thermo-package of phase 1
+        autoPtr<rhoThermo> thermo1_;
+
+        //- Thermo-package of phase 2
+        autoPtr<rhoThermo> thermo2_;
+
+        //- Energy field
+        volScalarField he_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("twoPhaseThermo");
+
+
+    // Constructors
+
+        //- Construct from mesh and phase fractions
+        twoPhaseThermo
+        (
+            const fvMesh&,
+            const volScalarField& alpha1,
+            const volScalarField& alpha2,
+            const word& phaseName=word::null
+        );
+
+
+    //- Destructor
+    virtual ~twoPhaseThermo();
+
+
+    // Member Functions
+
+        const rhoThermo& thermo1() const
+        {
+            return thermo1_();
+        }
+
+        const rhoThermo& thermo2() const
+        {
+            return thermo2_();
+        }
+
+        //- Update properties
+        virtual void correct();
+
+        //- Return true if the equation of state is incompressible
+        //  i.e. rho != f(p)
+        virtual bool incompressible() const;
+
+        //- Return true if the equation of state is isochoric
+        //  i.e. rho = const
+        virtual bool isochoric() const;
+
+
+        // Access to thermodynamic state variables
+
+            //- Enthalpy/Internal energy [J/kg]
+            //  Non-const access allowed for transport equations
+            virtual volScalarField& he()
+            {
+                return he_;
+            }
+
+            //- Enthalpy/Internal energy [J/kg]
+            virtual const volScalarField& he() const
+            {
+                return he_;
+            }
+
+            //- Enthalpy/Internal energy
+            //  for given pressure and temperature [J/kg]
+            virtual tmp<volScalarField> he
+            (
+                const volScalarField& p,
+                const volScalarField& T
+            ) const;
+
+            //- Enthalpy/Internal energy for cell-set [J/kg]
+            virtual tmp<scalarField> he
+            (
+                const scalarField& p,
+                const scalarField& T,
+                const labelList& cells
+            ) const;
+
+            //- Enthalpy/Internal energy for patch [J/kg]
+            virtual tmp<scalarField> he
+            (
+                const scalarField& p,
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+            //- Chemical enthalpy [J/kg]
+            virtual tmp<volScalarField> hc() const;
+
+            //- Temperature from enthalpy/internal energy for cell-set
+            virtual tmp<scalarField> THE
+            (
+                const scalarField& h,
+                const scalarField& p,
+                const scalarField& T0,      // starting temperature
+                const labelList& cells
+            ) const;
+
+            //- Temperature from enthalpy/internal energy for patch
+            virtual tmp<scalarField> THE
+            (
+                const scalarField& h,
+                const scalarField& p,
+                const scalarField& T0,      // starting temperature
+                const label patchi
+            ) const;
+
+
+        // Fields derived from thermodynamic state variables
+
+            //- Heat capacity at constant pressure [J/kg/K]
+            virtual tmp<volScalarField> Cp() const;
+
+            //- Heat capacity at constant pressure for patch [J/kg/K]
+            virtual tmp<scalarField> Cp
+            (
+                const scalarField& p,
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+            //- Heat capacity at constant volume [J/kg/K]
+            virtual tmp<volScalarField> Cv() const;
+
+            //- Heat capacity at constant volume for patch [J/kg/K]
+            virtual tmp<scalarField> Cv
+            (
+                const scalarField& p,
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+            //- gamma = Cp/Cv []
+            virtual tmp<volScalarField> gamma() const;
+
+            //- gamma = Cp/Cv for patch []
+            virtual tmp<scalarField> gamma
+            (
+                const scalarField& p,
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+            //- Heat capacity at constant pressure/volume [J/kg/K]
+            virtual tmp<volScalarField> Cpv() const;
+
+            //- Heat capacity at constant pressure/volume for patch [J/kg/K]
+            virtual tmp<scalarField> Cpv
+            (
+                const scalarField& p,
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+            //- Heat capacity ratio []
+            virtual tmp<volScalarField> CpByCpv() const;
+
+            //- Heat capacity ratio for patch []
+            virtual tmp<scalarField> CpByCpv
+            (
+                const scalarField& p,
+                const scalarField& T,
+                const label patchi
+            ) const;
+
+
+        // Fields derived from transport state variables
+
+            //- Thermal diffusivity for temperature of mixture [J/m/s/K]
+            virtual tmp<volScalarField> kappa() const;
+
+            //- Thermal diffusivity of mixture for patch [J/m/s/K]
+            virtual tmp<scalarField> kappa
+            (
+                const label patchi
+            ) const;
+
+            //- Effective thermal diffusivity of mixture [J/m/s/K]
+            virtual tmp<volScalarField> kappaEff
+            (
+                const volScalarField& alphat
+            ) const;
+
+            //- Effective thermal diffusivity of mixture for patch [J/m/s/K]
+            virtual tmp<scalarField> kappaEff
+            (
+                const scalarField& alphat,
+                const label patchi
+            ) const;
+
+            //- Effective thermal diffusivity of mixture [J/m/s/K]
+            virtual tmp<volScalarField> alphaEff
+            (
+                const volScalarField& alphat
+            ) const;
+
+            //- Effective thermal diffusivity of mixture for patch [J/m/s/K]
+            virtual tmp<scalarField> alphaEff
+            (
+                const scalarField& alphat,
+                const label patchi
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/multiphase/interPhaseChangeFoam/pEqn.H

@@ -49,8 +49,6 @@
         }
     }
 
-    #include "continuityErrs.H"
-
     p == p_rgh + rho*gh;
 
     if (p_rgh.needReference())

src/regionModels/Allwclean

@@ -6,7 +6,7 @@ set -x
 wclean $makeType regionModel
 wclean $makeType pyrolysisModels
 wclean $makeType surfaceFilmModels
-wclean $makeType thermoBaffleModels
+wclean $makeType thermalBaffleModels
 wclean $makeType regionCoupling
 
 

src/regionModels/Allwmake

@@ -6,7 +6,7 @@ set -x
 wmake $makeType regionModel
 wmake $makeType pyrolysisModels
 wmake $makeType surfaceFilmModels
-wmake $makeType thermoBaffleModels
+wmake $makeType thermalBaffleModels
 wmake $makeType regionCoupling
 
 

src/regionModels/regionModel/derivedFvPatches/mappedVariableThicknessWall/mappedVariableThicknessWallFvPatch.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -54,7 +54,7 @@ makeDeltaCoeffs(scalarField& dc) const
     const modelType& region1D =
         patch().boundaryMesh().mesh().time().lookupObject<modelType>
         (
-            "thermoBaffleProperties"
+            "thermalBaffleProperties"
         );
 
     dc = 2.0/(pp.thickness()/region1D.nLayers());

src/regionModels/thermalBaffleModels/Make/files

@@ -0,0 +1,9 @@
+thermalBaffleModel/thermalBaffleModel.C
+thermalBaffleModel/thermalBaffleModelNew.C
+thermalBaffle/thermalBaffle.C
+noThermo/noThermo.C
+
+derivedFvPatchFields/thermalBaffle/thermalBaffleFvPatchScalarField.C
+
+
+LIB = $(FOAM_LIBBIN)/libthermalBaffleModels

src/regionModels/thermalBaffleModels/derivedFvPatchFields/doc/thermalBaffleBoundaryConditionsDoc.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/regionModels/thermalBaffleModels/derivedFvPatchFields/thermalBaffle/thermalBaffleFvPatchScalarField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "thermoBaffleFvPatchScalarField.H"
+#include "thermalBaffleFvPatchScalarField.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -35,8 +35,8 @@ namespace compressible
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-thermoBaffleFvPatchScalarField::
+thermalBaffleFvPatchScalarField::
-thermoBaffleFvPatchScalarField
+thermalBaffleFvPatchScalarField
 (
     const fvPatch& p,
     const DimensionedField<scalar, volMesh>& iF
@@ -49,10 +49,10 @@ thermoBaffleFvPatchScalarField
 {}
 
 
-thermoBaffleFvPatchScalarField::
+thermalBaffleFvPatchScalarField::
-thermoBaffleFvPatchScalarField
+thermalBaffleFvPatchScalarField
 (
-    const thermoBaffleFvPatchScalarField& ptf,
+    const thermalBaffleFvPatchScalarField& ptf,
     const fvPatch& p,
     const DimensionedField<scalar, volMesh>& iF,
     const fvPatchFieldMapper& mapper
@@ -71,8 +71,8 @@ thermoBaffleFvPatchScalarField
 {}
 
 
-thermoBaffleFvPatchScalarField::
+thermalBaffleFvPatchScalarField::
-thermoBaffleFvPatchScalarField
+thermalBaffleFvPatchScalarField
 (
     const fvPatch& p,
     const DimensionedField<scalar, volMesh>& iF,
@@ -88,8 +88,8 @@ thermoBaffleFvPatchScalarField
     {
         FatalErrorIn
         (
-            "thermoBaffleFvPatchScalarField::"
+            "thermalBaffleFvPatchScalarField::"
-            "thermoBaffleFvPatchScalarField\n"
+            "thermalBaffleFvPatchScalarField\n"
             "(\n"
             "    const fvPatch& p,\n"
             "    const DimensionedField<scalar, volMesh>& iF,\n"
@@ -110,7 +110,7 @@ thermoBaffleFvPatchScalarField
 
     const fvMesh& thisMesh = patch().boundaryMesh().mesh();
 
-    typedef regionModels::thermoBaffleModels::thermoBaffleModel baffle;
+    typedef regionModels::thermalBaffleModels::thermalBaffleModel baffle;
 
     if
     (
@@ -127,10 +127,10 @@ thermoBaffleFvPatchScalarField
 }
 
 
-thermoBaffleFvPatchScalarField::
+thermalBaffleFvPatchScalarField::
-thermoBaffleFvPatchScalarField
+thermalBaffleFvPatchScalarField
 (
-    const thermoBaffleFvPatchScalarField& ptf,
+    const thermalBaffleFvPatchScalarField& ptf,
     const DimensionedField<scalar, volMesh>& iF
 )
 :
@@ -144,7 +144,7 @@ thermoBaffleFvPatchScalarField
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 
-void thermoBaffleFvPatchScalarField::autoMap
+void thermalBaffleFvPatchScalarField::autoMap
 (
     const fvPatchFieldMapper& m
 )
@@ -153,7 +153,7 @@ void thermoBaffleFvPatchScalarField::autoMap
 }
 
 
-void thermoBaffleFvPatchScalarField::rmap
+void thermalBaffleFvPatchScalarField::rmap
 (
     const fvPatchScalarField& ptf,
     const labelList& addr
@@ -163,7 +163,7 @@ void thermoBaffleFvPatchScalarField::rmap
 }
 
 
-void thermoBaffleFvPatchScalarField::updateCoeffs()
+void thermalBaffleFvPatchScalarField::updateCoeffs()
 {
     if (this->updated())
     {
@@ -181,7 +181,7 @@ void thermoBaffleFvPatchScalarField::updateCoeffs()
 }
 
 
-void thermoBaffleFvPatchScalarField::write(Ostream& os) const
+void thermalBaffleFvPatchScalarField::write(Ostream& os) const
 {
     turbulentTemperatureCoupledBaffleMixedFvPatchScalarField::write(os);
 
@@ -189,9 +189,9 @@ void thermoBaffleFvPatchScalarField::write(Ostream& os) const
 
     if (thisMesh.name() == polyMesh::defaultRegion && owner_)
     {
-        word thermoModel = dict_.lookup("thermoBaffleModel");
+        word thermoModel = dict_.lookup("thermalBaffleModel");
 
-        os.writeKeyword("thermoBaffleModel")
+        os.writeKeyword("thermalBaffleModel")
             << thermoModel
             << token::END_STATEMENT << nl;
 
@@ -227,7 +227,7 @@ void thermoBaffleFvPatchScalarField::write(Ostream& os) const
 makePatchTypeField
 (
     fvPatchScalarField,
-    thermoBaffleFvPatchScalarField
+    thermalBaffleFvPatchScalarField
 );
 
 

src/regionModels/thermalBaffleModels/derivedFvPatchFields/thermalBaffle/thermalBaffleFvPatchScalarField.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermoBaffleFvPatchScalarField
+    Foam::thermalBaffleFvPatchScalarField
 
 Group
     grpThermoBoundaryConditions
@@ -56,11 +56,11 @@ Description
 
 
         // Thermo baffle model
-        thermoBaffleModel   thermoBaffle;
+        thermalBaffleModel   thermalBaffle;
         regionName          baffleRegion;
         infoOutput          yes;
         active              yes;
-        thermoBaffleCoeffs
+        thermalBaffleCoeffs
         {
         }
 
@@ -112,20 +112,20 @@ Description
 
 SeeAlso
     Foam::turbulentTemperatureCoupledBaffleMixedFvPatchScalarField
-    Foam::regionModels::thermoBaffleModels::thermoBaffleModel
+    Foam::regionModels::thermalBaffleModels::thermalBaffleModel
 
 SourceFiles
-    thermoBaffleFvPatchScalarField.C
+    thermalBaffleFvPatchScalarField.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef thermoBaffleFvPatchScalarField_H
+#ifndef thermalBaffleFvPatchScalarField_H
-#define thermoBaffleFvPatchScalarField_H
+#define thermalBaffleFvPatchScalarField_H
 
 
 #include "autoPtr.H"
 #include "regionModel.H"
-#include "thermoBaffleModel.H"
+#include "thermalBaffleModel.H"
 #include "turbulentTemperatureCoupledBaffleMixedFvPatchScalarField.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -137,10 +137,10 @@ namespace compressible
 {
 
 /*---------------------------------------------------------------------------*\
-        Class thermoBaffleFvPatchScalarField Declaration
+        Class thermalBaffleFvPatchScalarField Declaration
 \*---------------------------------------------------------------------------*/
 
-class thermoBaffleFvPatchScalarField
+class thermalBaffleFvPatchScalarField
 :
     public turbulentTemperatureCoupledBaffleMixedFvPatchScalarField
 {
@@ -150,7 +150,7 @@ class thermoBaffleFvPatchScalarField
         bool owner_;
 
         //- Thermal baffle
-        autoPtr<regionModels::thermoBaffleModels::thermoBaffleModel> baffle_;
+        autoPtr<regionModels::thermalBaffleModels::thermalBaffleModel> baffle_;
 
         //- Dictionary
         dictionary dict_;
@@ -159,20 +159,20 @@ class thermoBaffleFvPatchScalarField
 public:
 
     //- Runtime type information
-    TypeName("compressible::thermoBaffle");
+    TypeName("compressible::thermalBaffle");
 
 
     // Constructors
 
         //- Construct from patch and internal field
-        thermoBaffleFvPatchScalarField
+        thermalBaffleFvPatchScalarField
         (
             const fvPatch&,
             const DimensionedField<scalar, volMesh>&
         );
 
         //- Construct from patch, internal field and dictionary
-        thermoBaffleFvPatchScalarField
+        thermalBaffleFvPatchScalarField
         (
             const fvPatch&,
             const DimensionedField<scalar, volMesh>&,
@@ -180,10 +180,10 @@ public:
         );
 
         //- Construct by mapping given
-        //  thermoBaffleFvPatchScalarField onto a new patch
+        //  thermalBaffleFvPatchScalarField onto a new patch
-        thermoBaffleFvPatchScalarField
+        thermalBaffleFvPatchScalarField
         (
-            const thermoBaffleFvPatchScalarField&,
+            const thermalBaffleFvPatchScalarField&,
             const fvPatch&,
             const DimensionedField<scalar, volMesh>&,
             const fvPatchFieldMapper&
@@ -195,14 +195,14 @@ public:
         {
             return tmp<fvPatchScalarField>
             (
-                new thermoBaffleFvPatchScalarField(*this)
+                new thermalBaffleFvPatchScalarField(*this)
             );
         }
 
         //- Construct as copy setting internal field reference
-        thermoBaffleFvPatchScalarField
+        thermalBaffleFvPatchScalarField
         (
-            const thermoBaffleFvPatchScalarField&,
+            const thermalBaffleFvPatchScalarField&,
             const DimensionedField<scalar, volMesh>&
         );
 
@@ -214,7 +214,7 @@ public:
         {
             return tmp<fvPatchScalarField>
             (
-                new thermoBaffleFvPatchScalarField(*this, iF)
+                new thermalBaffleFvPatchScalarField(*this, iF)
             );
         }
 

src/regionModels/thermalBaffleModels/noThermo/noThermo.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,15 +33,15 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 defineTypeNameAndDebug(noThermo, 0);
 
-addToRunTimeSelectionTable(thermoBaffleModel, noThermo, mesh);
+addToRunTimeSelectionTable(thermalBaffleModel, noThermo, mesh);
-addToRunTimeSelectionTable(thermoBaffleModel, noThermo, dictionary);
+addToRunTimeSelectionTable(thermalBaffleModel, noThermo, dictionary);
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
@@ -55,7 +55,7 @@ bool noThermo::read()
 
 noThermo::noThermo(const word& modelType, const fvMesh& mesh)
 :
-    thermoBaffleModel(mesh)
+    thermalBaffleModel(mesh)
 {}
 
 
@@ -66,7 +66,7 @@ noThermo::noThermo
     const dictionary& dict
 )
 :
-    thermoBaffleModel(modelType, mesh, dict)
+    thermalBaffleModel(modelType, mesh, dict)
 {}
 
 
@@ -157,7 +157,7 @@ const solidThermo& noThermo::thermo() const
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace thermoBaffleModels
+} // End namespace thermalBaffleModels
 } // End namespace regionModels
 } // End namespace Foam
 

src/regionModels/thermalBaffleModels/noThermo/noThermo.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -35,7 +35,7 @@ SourceFiles
 #ifndef noThermo_H
 #define noThermo_H
 
-#include "thermoBaffleModel.H"
+#include "thermalBaffleModel.H"
 #include "volFieldsFwd.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -44,7 +44,7 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 /*---------------------------------------------------------------------------*\
@@ -53,7 +53,7 @@ namespace thermoBaffleModels
 
 class noThermo
 :
-    public thermoBaffleModel
+    public thermalBaffleModel
 {
 private:
 
@@ -139,7 +139,7 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace thermoBaffleModels
+} // End namespace thermalBaffleModels
 } // End namespace regionModels
 } // End namespace Foam
 

src/regionModels/thermalBaffleModels/thermalBaffle/thermalBaffle.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "thermoBaffle.H"
+#include "thermalBaffle.H"
 
 #include "fvm.H"
 #include "fvcDiv.H"
@@ -39,37 +39,37 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(thermoBaffle, 0);
+defineTypeNameAndDebug(thermalBaffle, 0);
 
-addToRunTimeSelectionTable(thermoBaffleModel, thermoBaffle, mesh);
+addToRunTimeSelectionTable(thermalBaffleModel, thermalBaffle, mesh);
-addToRunTimeSelectionTable(thermoBaffleModel, thermoBaffle, dictionary);
+addToRunTimeSelectionTable(thermalBaffleModel, thermalBaffle, dictionary);
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-bool thermoBaffle::read()
+bool thermalBaffle::read()
 {
     this->solution().lookup("nNonOrthCorr") >> nNonOrthCorr_;
     return regionModel1D::read();
 }
 
 
-bool thermoBaffle::read(const dictionary& dict)
+bool thermalBaffle::read(const dictionary& dict)
 {
     this->solution().lookup("nNonOrthCorr") >> nNonOrthCorr_;
     return regionModel1D::read(dict);
 }
 
 
-void thermoBaffle::solveEnergy()
+void thermalBaffle::solveEnergy()
 {
     if (debug)
     {
-        Info<< "thermoBaffle::solveEnergy()" << endl;
+        Info<< "thermalBaffle::solveEnergy()" << endl;
     }
 
     const polyBoundaryMesh& rbm = regionMesh().boundaryMesh();
@@ -157,14 +157,14 @@ void thermoBaffle::solveEnergy()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-thermoBaffle::thermoBaffle
+thermalBaffle::thermalBaffle
 (
     const word& modelType,
     const fvMesh& mesh,
     const dictionary& dict
 )
 :
-    thermoBaffleModel(modelType, mesh, dict),
+    thermalBaffleModel(modelType, mesh, dict),
     nNonOrthCorr_(readLabel(solution().lookup("nNonOrthCorr"))),
     thermo_(solidThermo::New(regionMesh(), dict)),
     h_(thermo_->he()),
@@ -218,13 +218,13 @@ thermoBaffle::thermoBaffle
 }
 
 
-thermoBaffle::thermoBaffle
+thermalBaffle::thermalBaffle
 (
     const word& modelType,
     const fvMesh& mesh
 )
 :
-    thermoBaffleModel(modelType, mesh),
+    thermalBaffleModel(modelType, mesh),
     nNonOrthCorr_(readLabel(solution().lookup("nNonOrthCorr"))),
     thermo_(solidThermo::New(regionMesh())),
     h_(thermo_->he()),
@@ -279,13 +279,13 @@ thermoBaffle::thermoBaffle
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-thermoBaffle::~thermoBaffle()
+thermalBaffle::~thermalBaffle()
 {}
 
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-void thermoBaffle::init()
+void thermalBaffle::init()
 {
     if (oneD_ && !constantThickness_)
     {
@@ -294,7 +294,7 @@ void thermoBaffle::init()
 
         if (Qsb!= thickness_.size())
         {
-            FatalErrorIn("thermoBaffle::init()")
+            FatalErrorIn("thermalBaffle::init()")
                 << "the boundary field of Qs is "
                 << Qsb << " and " << nl
                 << "the field 'thickness' is " << thickness_.size() << nl
@@ -304,11 +304,11 @@ void thermoBaffle::init()
 }
 
 
-void thermoBaffle::preEvolveRegion()
+void thermalBaffle::preEvolveRegion()
 {}
 
 
-void thermoBaffle::evolveRegion()
+void thermalBaffle::evolveRegion()
 {
     for (int nonOrth=0; nonOrth<=nNonOrthCorr_; nonOrth++)
     {
@@ -317,43 +317,43 @@ void thermoBaffle::evolveRegion()
 }
 
 
-const tmp<volScalarField> thermoBaffle::Cp() const
+const tmp<volScalarField> thermalBaffle::Cp() const
 {
     return thermo_->Cp();
 }
 
 
-const volScalarField& thermoBaffle::kappaRad() const
+const volScalarField& thermalBaffle::kappaRad() const
 {
     return radiation_->absorptionEmission().a();
 }
 
 
-const volScalarField& thermoBaffle::rho() const
+const volScalarField& thermalBaffle::rho() const
 {
     return thermo_->rho();
 }
 
 
-const volScalarField& thermoBaffle::kappa() const
+const volScalarField& thermalBaffle::kappa() const
 {
     return thermo_->kappa();
 }
 
 
-const volScalarField& thermoBaffle::T() const
+const volScalarField& thermalBaffle::T() const
 {
     return thermo_->T();
 }
 
 
-const solidThermo& thermoBaffle::thermo() const
+const solidThermo& thermalBaffle::thermo() const
 {
     return thermo_;
 }
 
 
-void thermoBaffle::info() const
+void thermalBaffle::info() const
 {
     const labelList& coupledPatches = intCoupledPatchIDs();
 
@@ -375,7 +375,7 @@ void thermoBaffle::info() const
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // end namespace thermoBaffleModels
+} // end namespace thermalBaffleModels
 } // end namespace regionModels
 } // end namespace Foam
 

src/regionModels/thermalBaffleModels/thermalBaffle/thermalBaffle.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,21 +22,21 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermoBaffle
+    Foam::thermalBaffle
 
 Description
     2D thermal baffle
 
 SourceFiles
-    thermoBaffle.C
+    thermalBaffle.C
-    thermoBaffleI.H
+    thermalBaffleI.H
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef thermoBaffle_H
+#ifndef thermalBaffle_H
-#define thermoBaffle_H
+#define thermalBaffle_H
 
-#include "thermoBaffleModel.H"
+#include "thermalBaffleModel.H"
 #include "volFieldsFwd.H"
 
 
@@ -46,29 +46,29 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 
 /*---------------------------------------------------------------------------*\
-                        Class thermoBaffle Declaration
+                        Class thermalBaffle Declaration
 \*---------------------------------------------------------------------------*/
 
-class thermoBaffle
+class thermalBaffle
 :
-    public thermoBaffleModel
+    public thermalBaffleModel
 {
 private:
 
     // Private member functions
 
         //- Disallow default bitwise copy construct
-        thermoBaffle(const thermoBaffle&);
+        thermalBaffle(const thermalBaffle&);
 
         //- Disallow default bitwise assignment
-        void operator=(const thermoBaffle&);
+        void operator=(const thermalBaffle&);
 
-        //- Initialize thermoBaffle
+        //- Initialize thermalBaffle
         void init();
 
 
@@ -124,16 +124,16 @@ protected:
 public:
 
     //- Runtime type information
-    TypeName("thermoBaffle");
+    TypeName("thermalBaffle");
 
 
     // Constructors
 
         //- Construct from components
-        thermoBaffle(const word& modelType, const fvMesh& mesh);
+        thermalBaffle(const word& modelType, const fvMesh& mesh);
 
         //- Construct from components and dict
-        thermoBaffle
+        thermalBaffle
         (
             const word& modelType,
             const fvMesh& mesh,
@@ -142,7 +142,7 @@ public:
 
 
     //- Destructor
-    virtual ~thermoBaffle();
+    virtual ~thermalBaffle();
 
 
     // Member Functions
@@ -205,13 +205,13 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace thermoBaffleModels
+} // End namespace thermalBaffleModels
 } // End namespace regionModels
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "thermoBaffleI.H"
+#include "thermalBaffleI.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/regionModels/thermalBaffleModels/thermalBaffle/thermalBaffleI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "thermoBaffle.H"
+#include "thermalBaffle.H"
 #include "zeroGradientFvPatchFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -33,12 +33,12 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-inline tmp<scalarField> thermoBaffle::he
+inline tmp<scalarField> thermalBaffle::he
 (
     const scalarField& p,
     const scalarField& T,
@@ -49,7 +49,7 @@ inline tmp<scalarField> thermoBaffle::he
 }
 
 
-inline tmp<volScalarField> thermoBaffle::he() const
+inline tmp<volScalarField> thermalBaffle::he() const
 {
     return thermo_->he();
 }
@@ -57,7 +57,7 @@ inline tmp<volScalarField> thermoBaffle::he() const
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace thermoBaffleModels
+} // End namespace thermalBaffleModels
 } // End namespace regionModels
 } // End namespace Foam
 

src/regionModels/thermalBaffleModels/thermalBaffleModel/thermalBaffleModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "thermoBaffleModel.H"
+#include "thermalBaffleModel.H"
 #include "fvMesh.H"
 #include "mappedVariableThicknessWallPolyPatch.H"
 #include "wedgePolyPatch.H"
@@ -34,33 +34,33 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(thermoBaffleModel, 0);
+defineTypeNameAndDebug(thermalBaffleModel, 0);
-defineRunTimeSelectionTable(thermoBaffleModel, mesh);
+defineRunTimeSelectionTable(thermalBaffleModel, mesh);
-defineRunTimeSelectionTable(thermoBaffleModel, dictionary);
+defineRunTimeSelectionTable(thermalBaffleModel, dictionary);
 
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-bool thermoBaffleModel::read()
+bool thermalBaffleModel::read()
 {
     regionModel1D::read();
     return true;
 }
 
 
-bool thermoBaffleModel::read(const dictionary& dict)
+bool thermalBaffleModel::read(const dictionary& dict)
 {
     regionModel1D::read(dict);
     return true;
 }
 
 
-void thermoBaffleModel::init()
+void thermalBaffleModel::init()
 {
     if (active_)
     {
@@ -116,7 +116,7 @@ void thermoBaffleModel::init()
             {
                 FatalErrorIn
                 (
-                    "thermoBaffleModel::thermoBaffleModel"
+                    "thermalBaffleModel::thermalBaffleModel"
                     "("
                     "   const word&,"
                     "   const fvMesh&"
@@ -133,7 +133,7 @@ void thermoBaffleModel::init()
             {
                 FatalErrorIn
                 (
-                    "thermoBaffleModel::thermoBaffleModel"
+                    "thermalBaffleModel::thermalBaffleModel"
                     "("
                     "   const word&,"
                     "   const fvMesh&"
@@ -164,12 +164,12 @@ void thermoBaffleModel::init()
             {
                 FatalErrorIn
                 (
-                    "thermoBaffleModel::thermoBaffleModel"
+                    "thermalBaffleModel::thermalBaffleModel"
                     "("
                     "   const word&,"
                     "   const fvMesh&"
                     ")"
-                )   << " coupled patches in thermoBaffle are " << nl
+                )   << " coupled patches in thermalBaffle are " << nl
                     << " different sizes from list thickness" << nl
                     << exit(FatalError);
             }
@@ -199,7 +199,7 @@ void thermoBaffleModel::init()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-thermoBaffleModel::thermoBaffleModel(const fvMesh& mesh)
+thermalBaffleModel::thermalBaffleModel(const fvMesh& mesh)
 :
     regionModel1D(mesh),
     thickness_(),
@@ -209,7 +209,7 @@ thermoBaffleModel::thermoBaffleModel(const fvMesh& mesh)
 {}
 
 
-thermoBaffleModel::thermoBaffleModel
+thermalBaffleModel::thermalBaffleModel
 (
     const word& modelType,
     const fvMesh& mesh,
@@ -217,7 +217,7 @@ thermoBaffleModel::thermoBaffleModel
 
 )
 :
-    regionModel1D(mesh, "thermoBaffle", modelType, dict, true),
+    regionModel1D(mesh, "thermalBaffle", modelType, dict, true),
     thickness_(),
     delta_("delta", dimLength, 0.0),
     oneD_(false),
@@ -227,9 +227,13 @@ thermoBaffleModel::thermoBaffleModel
 }
 
 
-thermoBaffleModel::thermoBaffleModel(const word& modelType, const fvMesh& mesh)
+thermalBaffleModel::thermalBaffleModel
+(
+    const word& modelType,
+    const fvMesh& mesh
+)
 :
-    regionModel1D(mesh, "thermoBaffle", modelType),
+    regionModel1D(mesh, "thermalBaffle", modelType),
     thickness_(),
     delta_("delta", dimLength, 0.0),
     oneD_(false),
@@ -241,19 +245,19 @@ thermoBaffleModel::thermoBaffleModel(const word& modelType, const fvMesh& mesh)
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-thermoBaffleModel::~thermoBaffleModel()
+thermalBaffleModel::~thermalBaffleModel()
 {}
 
 
 // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 
-void thermoBaffleModel::preEvolveRegion()
+void thermalBaffleModel::preEvolveRegion()
 {}
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace thermoBaffleModels
+} // End namespace thermalBaffleModels
 } // End namespace regionModels
 } // End namespace Foam
 

src/regionModels/thermalBaffleModels/thermalBaffleModel/thermalBaffleModel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,17 +22,17 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermoBaffleModel
+    Foam::thermalBaffleModel
 
 Description
 
 SourceFiles
-    thermoBaffleModel.C
+    thermalBaffleModel.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef thermoBaffleModel_H
+#ifndef thermalBaffleModel_H
-#define thermoBaffleModel_H
+#define thermalBaffleModel_H
 
 #include "runTimeSelectionTables.H"
 #include "scalarIOField.H"
@@ -49,14 +49,14 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 /*---------------------------------------------------------------------------*\
-                      Class thermoBaffleModel Declaration
+                      Class thermalBaffleModel Declaration
 \*---------------------------------------------------------------------------*/
 
-class thermoBaffleModel
+class thermalBaffleModel
 :
     public regionModel1D
 {
@@ -65,10 +65,10 @@ private:
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
-        thermoBaffleModel(const thermoBaffleModel&);
+        thermalBaffleModel(const thermalBaffleModel&);
 
         //- Disallow default bitwise assignment
-        void operator=(const thermoBaffleModel&);
+        void operator=(const thermalBaffleModel&);
 
         //- Initialize thermal Baffle
         void init();
@@ -103,7 +103,7 @@ protected:
 public:
 
     //- Runtime type information
-    TypeName("thermoBaffleModel");
+    TypeName("thermalBaffleModel");
 
 
     // Declare runtime constructor selection tables
@@ -111,7 +111,7 @@ public:
          declareRunTimeSelectionTable
          (
              autoPtr,
-             thermoBaffleModel,
+             thermalBaffleModel,
              mesh,
              (
                 const word& modelType,
@@ -123,7 +123,7 @@ public:
          declareRunTimeSelectionTable
          (
              autoPtr,
-             thermoBaffleModel,
+             thermalBaffleModel,
              dictionary,
              (
                 const word& modelType,
@@ -137,13 +137,13 @@ public:
     // Constructors
 
         //- Construct null from mesh
-        thermoBaffleModel(const fvMesh& mesh);
+        thermalBaffleModel(const fvMesh& mesh);
 
         //- Construct from type name and mesh
-        thermoBaffleModel(const word& modelType, const fvMesh& mesh);
+        thermalBaffleModel(const word& modelType, const fvMesh& mesh);
 
         //- Construct from type name and mesh and dict
-        thermoBaffleModel
+        thermalBaffleModel
         (
             const word& modelType,
             const fvMesh& mesh,
@@ -154,10 +154,10 @@ public:
     // Selectors
 
         //- Return a reference to the selected model
-        static autoPtr<thermoBaffleModel> New(const fvMesh& mesh);
+        static autoPtr<thermalBaffleModel> New(const fvMesh& mesh);
 
         //- Return a reference to the selected model using dictionary
-        static autoPtr<thermoBaffleModel> New
+        static autoPtr<thermalBaffleModel> New
         (
             const fvMesh& mesh,
             const dictionary& dict
@@ -165,7 +165,7 @@ public:
 
 
     //- Destructor
-    virtual ~thermoBaffleModel();
+    virtual ~thermalBaffleModel();
 
 
     // Member Functions
@@ -227,7 +227,7 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace thermoBaffleModels
+} // End namespace thermalBaffleModels
 } // End namespace regionModels
 } // End namespace Foam
 

src/regionModels/thermalBaffleModels/thermalBaffleModel/thermalBaffleModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "thermoBaffleModel.H"
+#include "thermalBaffleModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -31,20 +31,20 @@ namespace Foam
 {
 namespace regionModels
 {
-namespace thermoBaffleModels
+namespace thermalBaffleModels
 {
 
 // * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
 
-autoPtr<thermoBaffleModel> thermoBaffleModel::New(const fvMesh& mesh)
+autoPtr<thermalBaffleModel> thermalBaffleModel::New(const fvMesh& mesh)
 {
     word modelType;
     {
-        IOdictionary thermoBafflePropertiesDict
+        IOdictionary thermalBafflePropertiesDict
         (
             IOobject
             (
-                "thermoBaffleProperties",
+                "thermalBaffleProperties",
                 mesh.time().constant(),
                 mesh,
                 IOobject::MUST_READ_IF_MODIFIED,
@@ -53,7 +53,7 @@ autoPtr<thermoBaffleModel> thermoBaffleModel::New(const fvMesh& mesh)
             )
         );
 
-        thermoBafflePropertiesDict.lookup("thermoBaffleModel") >> modelType;
+        thermalBafflePropertiesDict.lookup("thermalBaffleModel") >> modelType;
     }
 
     Info<< "Selecting baffle model " << modelType << endl;
@@ -64,25 +64,25 @@ autoPtr<thermoBaffleModel> thermoBaffleModel::New(const fvMesh& mesh)
     if (cstrIter == meshConstructorTablePtr_->end())
     {
 
-        FatalErrorIn("thermoBaffleModel::New(const fvMesh&)")
+        FatalErrorIn("thermalBaffleModel::New(const fvMesh&)")
-            << "Unknown thermoBaffleModel type " << modelType
+            << "Unknown thermalBaffleModel type " << modelType
             << nl << nl
-            <<  "Valid thermoBaffleModel types are:" << nl
+            <<  "Valid thermalBaffleModel types are:" << nl
             << meshConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }
 
-    return autoPtr<thermoBaffleModel>(cstrIter()(modelType, mesh));
+    return autoPtr<thermalBaffleModel>(cstrIter()(modelType, mesh));
 }
 
 
-autoPtr<thermoBaffleModel> thermoBaffleModel::New
+autoPtr<thermalBaffleModel> thermalBaffleModel::New
 (
     const fvMesh& mesh,
     const dictionary& dict
 )
 {
-    word modelType = dict.lookup("thermoBaffleModel");
+    word modelType = dict.lookup("thermalBaffleModel");
 
     Info<< "Selecting baffle model " << modelType << endl;
 
@@ -92,21 +92,23 @@ autoPtr<thermoBaffleModel> thermoBaffleModel::New
     if (cstrIter == dictionaryConstructorTablePtr_->end())
     {
 
-        FatalErrorIn("thermoBaffleModel::New(const fvMesh&, const dictionary&)")
+        FatalErrorIn
-            << "Unknown thermoBaffleModel type " << modelType
+        (
+            "thermalBaffleModel::New(const fvMesh&, const dictionary&)"
+        )   << "Unknown thermalBaffleModel type " << modelType
             << nl << nl
-            <<  "Valid thermoBaffleModel types are:" << nl
+            <<  "Valid thermalBaffleModel types are:" << nl
             << dictionaryConstructorTablePtr_->sortedToc()
             << exit(FatalError);
     }
 
-    return autoPtr<thermoBaffleModel>(cstrIter()(modelType, mesh, dict));
+    return autoPtr<thermalBaffleModel>(cstrIter()(modelType, mesh, dict));
 }
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace thermoBaffleModels
+} // End namespace thermalBaffleModels
 } // End namespace regionModels
 } // End namespace Foam
 

src/regionModels/thermoBaffleModels/Make/files

@@ -1,9 +0,0 @@
-thermoBaffleModel/thermoBaffleModel.C
-thermoBaffleModel/thermoBaffleModelNew.C
-thermoBaffle/thermoBaffle.C
-noThermo/noThermo.C
-
-derivedFvPatchFields/thermoBaffle/thermoBaffleFvPatchScalarField.C
-
-
-LIB = $(FOAM_LIBBIN)/libthermoBaffleModels

src/thermophysicalModels/basic/Make/files

@@ -14,6 +14,4 @@ derivedFvPatchFields/mixedEnergy/mixedEnergyFvPatchScalarField.C
 derivedFvPatchFields/energyJump/energyJump/energyJumpFvPatchScalarField.C
 derivedFvPatchFields/energyJump/energyJumpAMI/energyJumpAMIFvPatchScalarField.C
 
-derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.C
-
 LIB = $(FOAM_LIBBIN)/libfluidThermophysicalModels

src/thermophysicalModels/basic/basicThermo/basicThermo.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,6 +24,14 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "basicThermo.H"
+#include "zeroGradientFvPatchFields.H"
+#include "fixedEnergyFvPatchScalarField.H"
+#include "gradientEnergyFvPatchScalarField.H"
+#include "mixedEnergyFvPatchScalarField.H"
+#include "fixedJumpFvPatchFields.H"
+#include "fixedJumpAMIFvPatchFields.H"
+#include "energyJumpFvPatchScalarField.H"
+#include "energyJumpAMIFvPatchScalarField.H"
 
 
 /* * * * * * * * * * * * * * * private static data * * * * * * * * * * * * * */
@@ -36,6 +44,84 @@ namespace Foam
 
 const Foam::word Foam::basicThermo::dictName("thermophysicalProperties");
 
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+Foam::wordList Foam::basicThermo::heBoundaryBaseTypes()
+{
+    const volScalarField::GeometricBoundaryField& tbf =
+        this->T_.boundaryField();
+
+    wordList hbt(tbf.size(), word::null);
+
+    forAll(tbf, patchi)
+    {
+        if (isA<fixedJumpFvPatchScalarField>(tbf[patchi]))
+        {
+            const fixedJumpFvPatchScalarField& pf =
+                dynamic_cast<const fixedJumpFvPatchScalarField&>(tbf[patchi]);
+
+            hbt[patchi] = pf.interfaceFieldType();
+        }
+        else if (isA<fixedJumpAMIFvPatchScalarField>(tbf[patchi]))
+        {
+            const fixedJumpAMIFvPatchScalarField& pf =
+                dynamic_cast<const fixedJumpAMIFvPatchScalarField&>
+                (
+                    tbf[patchi]
+                );
+
+            hbt[patchi] = pf.interfaceFieldType();
+        }
+    }
+
+    return hbt;
+}
+
+
+Foam::wordList Foam::basicThermo::heBoundaryTypes()
+{
+    const volScalarField::GeometricBoundaryField& tbf =
+        this->T_.boundaryField();
+
+    wordList hbt = tbf.types();
+
+    forAll(tbf, patchi)
+    {
+        if (isA<fixedValueFvPatchScalarField>(tbf[patchi]))
+        {
+            hbt[patchi] = fixedEnergyFvPatchScalarField::typeName;
+        }
+        else if
+        (
+            isA<zeroGradientFvPatchScalarField>(tbf[patchi])
+         || isA<fixedGradientFvPatchScalarField>(tbf[patchi])
+        )
+        {
+            hbt[patchi] = gradientEnergyFvPatchScalarField::typeName;
+        }
+        else if (isA<mixedFvPatchScalarField>(tbf[patchi]))
+        {
+            hbt[patchi] = mixedEnergyFvPatchScalarField::typeName;
+        }
+        else if (isA<fixedJumpFvPatchScalarField>(tbf[patchi]))
+        {
+            hbt[patchi] = energyJumpFvPatchScalarField::typeName;
+        }
+        else if (isA<fixedJumpAMIFvPatchScalarField>(tbf[patchi]))
+        {
+            hbt[patchi] = energyJumpAMIFvPatchScalarField::typeName;
+        }
+        else if (tbf[patchi].type() == "energyRegionCoupledFvPatchScalarField")
+        {
+            hbt[patchi] = "energyRegionCoupledFvPatchScalarField";
+        }
+    }
+
+    return hbt;
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::volScalarField& Foam::basicThermo::lookupOrConstruct
@@ -395,6 +481,12 @@ const Foam::volScalarField& Foam::basicThermo::T() const
 }
 
 
+Foam::volScalarField& Foam::basicThermo::T()
+{
+    return T_;
+}
+
+
 const Foam::volScalarField& Foam::basicThermo::alpha() const
 {
     return alpha_;

src/thermophysicalModels/basic/basicThermo/basicThermo.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2012-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -77,6 +77,9 @@ protected:
         //- Should the dpdt term be included in the enthalpy equation
         Switch dpdt_;
 
+
+    // Protected Member Functions
+
         //- Construct as copy (not implemented)
         basicThermo(const basicThermo&);
 
@@ -86,6 +89,14 @@ protected:
             const char* name
         ) const;
 
+        //- Return the enthalpy/internal energy field boundary types
+        //  by interrogating the temperature field boundary types
+        wordList heBoundaryTypes();
+
+        //- Return the enthalpy/internal energy field boundary base types
+        //  by interrogating the temperature field boundary types
+        wordList heBoundaryBaseTypes();
+
 
 public:
 
@@ -314,6 +325,10 @@ public:
             //- Temperature [K]
             virtual const volScalarField& T() const;
 
+            //- Temperature [K]
+            //  Non-const access allowed for transport equations
+            virtual volScalarField& T();
+
             //- Heat capacity at constant pressure [J/kg/K]
             virtual tmp<volScalarField> Cp() const = 0;
 

src/thermophysicalModels/basic/heThermo/heThermo.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,94 +24,11 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "heThermo.H"
-#include "zeroGradientFvPatchFields.H"
-#include "fixedEnergyFvPatchScalarField.H"
 #include "gradientEnergyFvPatchScalarField.H"
 #include "mixedEnergyFvPatchScalarField.H"
-#include "fixedJumpFvPatchFields.H"
-#include "fixedJumpAMIFvPatchFields.H"
-#include "energyJumpFvPatchScalarField.H"
-#include "energyJumpAMIFvPatchScalarField.H"
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-template<class BasicThermo, class MixtureType>
-Foam::wordList Foam::heThermo<BasicThermo, MixtureType>::heBoundaryBaseTypes()
-{
-    const volScalarField::GeometricBoundaryField& tbf =
-        this->T_.boundaryField();
-
-    wordList hbt(tbf.size(), word::null);
-
-    forAll(tbf, patchi)
-    {
-        if (isA<fixedJumpFvPatchScalarField>(tbf[patchi]))
-        {
-            const fixedJumpFvPatchScalarField& pf =
-                dynamic_cast<const fixedJumpFvPatchScalarField&>(tbf[patchi]);
-
-            hbt[patchi] = pf.interfaceFieldType();
-        }
-        else if (isA<fixedJumpAMIFvPatchScalarField>(tbf[patchi]))
-        {
-            const fixedJumpAMIFvPatchScalarField& pf =
-                dynamic_cast<const fixedJumpAMIFvPatchScalarField&>
-                (
-                    tbf[patchi]
-                );
-
-            hbt[patchi] = pf.interfaceFieldType();
-        }
-    }
-
-    return hbt;
-}
-
-
-template<class BasicThermo, class MixtureType>
-Foam::wordList Foam::heThermo<BasicThermo, MixtureType>::heBoundaryTypes()
-{
-    const volScalarField::GeometricBoundaryField& tbf =
-        this->T_.boundaryField();
-
-    wordList hbt = tbf.types();
-
-    forAll(tbf, patchi)
-    {
-        if (isA<fixedValueFvPatchScalarField>(tbf[patchi]))
-        {
-            hbt[patchi] = fixedEnergyFvPatchScalarField::typeName;
-        }
-        else if
-        (
-            isA<zeroGradientFvPatchScalarField>(tbf[patchi])
-         || isA<fixedGradientFvPatchScalarField>(tbf[patchi])
-        )
-        {
-            hbt[patchi] = gradientEnergyFvPatchScalarField::typeName;
-        }
-        else if (isA<mixedFvPatchScalarField>(tbf[patchi]))
-        {
-            hbt[patchi] = mixedEnergyFvPatchScalarField::typeName;
-        }
-        else if (isA<fixedJumpFvPatchScalarField>(tbf[patchi]))
-        {
-            hbt[patchi] = energyJumpFvPatchScalarField::typeName;
-        }
-        else if (isA<fixedJumpAMIFvPatchScalarField>(tbf[patchi]))
-        {
-            hbt[patchi] = energyJumpAMIFvPatchScalarField::typeName;
-        }
-        else if (tbf[patchi].type() == "energyRegionCoupledFvPatchScalarField")
-        {
-            hbt[patchi] = "energyRegionCoupledFvPatchScalarField";
-        }
-    }
-
-    return hbt;
-}
-
-
 template<class BasicThermo, class MixtureType>
 void Foam::heThermo<BasicThermo, MixtureType>::
 heBoundaryCorrection(volScalarField& h)

src/thermophysicalModels/basic/heThermo/heThermo.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -64,14 +64,6 @@ protected:
 
         // Enthalpy/Internal energy
 
-            //- Return the enthalpy/internal energy field boundary types
-            //  by interrogating the temperature field boundary types
-            wordList heBoundaryTypes();
-
-            //- Return the enthalpy/internal energy field boundary base types
-            //  by interrogating the temperature field boundary types
-            wordList heBoundaryBaseTypes();
-
             //- Correct the enthalpy/internal energy field boundaries
             void heBoundaryCorrection(volScalarField& he);
 

src/turbulenceModels/compressible/turbulenceModel/Make/files

@@ -4,10 +4,10 @@ laminar/laminar.C
 derivedFvPatchFields/turbulentHeatFluxTemperature/turbulentHeatFluxTemperatureFvPatchScalarField.C
 derivedFvPatchFields/temperatureCoupledBase/temperatureCoupledBase.C
 derivedFvPatchFields/turbulentTemperatureCoupledBaffleMixed/turbulentTemperatureCoupledBaffleMixedFvPatchScalarField.C
-derivedFvPatchFields/thermoBaffle1D/thermoBaffle1DFvPatchScalarFields.C
+derivedFvPatchFields/thermalBaffle1D/thermalBaffle1DFvPatchScalarFields.C
 derivedFvPatchFields/totalFlowRateAdvectiveDiffusive/totalFlowRateAdvectiveDiffusiveFvPatchScalarField.C
 derivedFvPatchFields/turbulentTemperatureRadCoupledMixed/turbulentTemperatureRadCoupledMixedFvPatchScalarField.C
 derivedFvPatchFields/externalWallHeatFluxTemperature/externalWallHeatFluxTemperatureFvPatchScalarField.C
-
+derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.C
 
 LIB = $(FOAM_LIBBIN)/libcompressibleTurbulenceModel

src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/thermalBaffle1D/thermalBaffle1DFvPatchScalarField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,8 +39,8 @@ namespace compressible
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class solidType>
-thermoBaffle1DFvPatchScalarField<solidType>::
+thermalBaffle1DFvPatchScalarField<solidType>::
-thermoBaffle1DFvPatchScalarField
+thermalBaffle1DFvPatchScalarField
 (
     const fvPatch& p,
     const DimensionedField<scalar, volMesh>& iF
@@ -56,10 +56,10 @@ thermoBaffle1DFvPatchScalarField
 
 
 template<class solidType>
-thermoBaffle1DFvPatchScalarField<solidType>::
+thermalBaffle1DFvPatchScalarField<solidType>::
-thermoBaffle1DFvPatchScalarField
+thermalBaffle1DFvPatchScalarField
 (
-    const thermoBaffle1DFvPatchScalarField& ptf,
+    const thermalBaffle1DFvPatchScalarField& ptf,
     const fvPatch& p,
     const DimensionedField<scalar, volMesh>& iF,
     const fvPatchFieldMapper& mapper
@@ -75,8 +75,8 @@ thermoBaffle1DFvPatchScalarField
 
 
 template<class solidType>
-thermoBaffle1DFvPatchScalarField<solidType>::
+thermalBaffle1DFvPatchScalarField<solidType>::
-thermoBaffle1DFvPatchScalarField
+thermalBaffle1DFvPatchScalarField
 (
     const fvPatch& p,
     const DimensionedField<scalar, volMesh>& iF,
@@ -94,8 +94,8 @@ thermoBaffle1DFvPatchScalarField
     {
         FatalErrorIn
         (
-            "thermoBaffle1DFvPatchScalarField::"
+            "thermalBaffle1DFvPatchScalarField::"
-            "thermoBaffle1DFvPatchScalarField"
+            "thermalBaffle1DFvPatchScalarField"
             "("
                 "const fvPatch&,\n"
                 "const DimensionedField<scalar, volMesh>&, "
@@ -130,10 +130,10 @@ thermoBaffle1DFvPatchScalarField
 
 
 template<class solidType>
-thermoBaffle1DFvPatchScalarField<solidType>::
+thermalBaffle1DFvPatchScalarField<solidType>::
-thermoBaffle1DFvPatchScalarField
+thermalBaffle1DFvPatchScalarField
 (
-    const thermoBaffle1DFvPatchScalarField& ptf
+    const thermalBaffle1DFvPatchScalarField& ptf
 )
 :
     mixedFvPatchScalarField(ptf),
@@ -146,10 +146,10 @@ thermoBaffle1DFvPatchScalarField
 
 
 template<class solidType>
-thermoBaffle1DFvPatchScalarField<solidType>::
+thermalBaffle1DFvPatchScalarField<solidType>::
-thermoBaffle1DFvPatchScalarField
+thermalBaffle1DFvPatchScalarField
 (
-    const thermoBaffle1DFvPatchScalarField& ptf,
+    const thermalBaffle1DFvPatchScalarField& ptf,
     const DimensionedField<scalar, volMesh>& iF
 )
 :
@@ -165,7 +165,7 @@ thermoBaffle1DFvPatchScalarField
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class solidType>
-void thermoBaffle1DFvPatchScalarField<solidType>::autoMap
+void thermalBaffle1DFvPatchScalarField<solidType>::autoMap
 (
     const fvPatchFieldMapper& m
 )
@@ -174,7 +174,7 @@ void thermoBaffle1DFvPatchScalarField<solidType>::autoMap
 }
 
 template<class solidType>
-void thermoBaffle1DFvPatchScalarField<solidType>::rmap
+void thermalBaffle1DFvPatchScalarField<solidType>::rmap
 (
     const fvPatchScalarField& ptf,
     const labelList& addr
@@ -185,7 +185,7 @@ void thermoBaffle1DFvPatchScalarField<solidType>::rmap
 
 
 template<class solidType>
-void thermoBaffle1DFvPatchScalarField<solidType>::updateCoeffs()
+void thermalBaffle1DFvPatchScalarField<solidType>::updateCoeffs()
 {
     if (updated())
     {
@@ -242,8 +242,8 @@ void thermoBaffle1DFvPatchScalarField<solidType>::updateCoeffs()
         );
         mpp.map().distribute(nbrQDot);
 
-        const thermoBaffle1DFvPatchScalarField& nbrField =
+        const thermalBaffle1DFvPatchScalarField& nbrField =
-        refCast<const thermoBaffle1DFvPatchScalarField>
+        refCast<const thermalBaffle1DFvPatchScalarField>
         (
             nbrPatch.template lookupPatchField<volScalarField, scalar>(TName_)
         );
@@ -347,7 +347,7 @@ void thermoBaffle1DFvPatchScalarField<solidType>::updateCoeffs()
 }
 
 template <class solidType>
-void thermoBaffle1DFvPatchScalarField<solidType>::
+void thermalBaffle1DFvPatchScalarField<solidType>::
 write(Ostream& os) const
 {
     mixedFvPatchScalarField::write(os);

src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/thermalBaffle1D/thermalBaffle1DFvPatchScalarField.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,19 +22,19 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermoBaffle1DFvPatchScalarField
+    Foam::thermalBaffle1DFvPatchScalarField
 
 Description
     Boundary which solves the 1D steady state heat transfer equation
     through a baffle.
 
 SourceFiles
-    thermoBaffle1DFvPatchScalarField.C
+    thermalBaffle1DFvPatchScalarField.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef thermoBaffle1DFvPatchScalarField_H
+#ifndef thermalBaffle1DFvPatchScalarField_H
-#define thermoBaffle1DFvPatchScalarField_H
+#define thermalBaffle1DFvPatchScalarField_H
 
 #include "mixedFvPatchFields.H"
 #include "autoPtr.H"
@@ -48,11 +48,11 @@ namespace compressible
 {
 
 /*---------------------------------------------------------------------------*\
-            Class thermoBaffle1DFvPatchScalarField Declaration
+            Class thermalBaffle1DFvPatchScalarField Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class solidType>
-class thermoBaffle1DFvPatchScalarField
+class thermalBaffle1DFvPatchScalarField
 :
     public mixedFvPatchScalarField
 {
@@ -77,20 +77,20 @@ class thermoBaffle1DFvPatchScalarField
 public:
 
     //- Runtime type information
-    TypeName("compressible::thermoBaffle1D");
+    TypeName("compressible::thermalBaffle1D");
 
 
     // Constructors
 
         //- Construct from patch and internal field
-        thermoBaffle1DFvPatchScalarField
+        thermalBaffle1DFvPatchScalarField
         (
             const fvPatch&,
             const DimensionedField<scalar, volMesh>&
         );
 
         //- Construct from patch, internal field and dictionary
-        thermoBaffle1DFvPatchScalarField
+        thermalBaffle1DFvPatchScalarField
         (
             const fvPatch&,
             const DimensionedField<scalar, volMesh>&,
@@ -98,19 +98,19 @@ public:
         );
 
         //- Construct by mapping given
-        //  thermoBaffle1DFvPatchScalarField onto a new patch
+        //  thermalBaffle1DFvPatchScalarField onto a new patch
-        thermoBaffle1DFvPatchScalarField
+        thermalBaffle1DFvPatchScalarField
         (
-            const thermoBaffle1DFvPatchScalarField&,
+            const thermalBaffle1DFvPatchScalarField&,
             const fvPatch&,
             const DimensionedField<scalar, volMesh>&,
             const fvPatchFieldMapper&
         );
 
         //- Construct as copy
-        thermoBaffle1DFvPatchScalarField
+        thermalBaffle1DFvPatchScalarField
         (
-            const thermoBaffle1DFvPatchScalarField&
+            const thermalBaffle1DFvPatchScalarField&
         );
 
         //- Construct and return a clone
@@ -118,14 +118,14 @@ public:
         {
             return tmp<fvPatchScalarField>
             (
-                new thermoBaffle1DFvPatchScalarField(*this)
+                new thermalBaffle1DFvPatchScalarField(*this)
             );
         }
 
         //- Construct as copy setting internal field reference
-        thermoBaffle1DFvPatchScalarField
+        thermalBaffle1DFvPatchScalarField
         (
-            const thermoBaffle1DFvPatchScalarField&,
+            const thermalBaffle1DFvPatchScalarField&,
             const DimensionedField<scalar, volMesh>&
         );
 
@@ -137,7 +137,7 @@ public:
         {
             return tmp<fvPatchScalarField>
             (
-                new thermoBaffle1DFvPatchScalarField(*this, iF)
+                new thermalBaffle1DFvPatchScalarField(*this, iF)
             );
         }
 
@@ -176,7 +176,7 @@ public:
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
-#   include "thermoBaffle1DFvPatchScalarField.C"
+#   include "thermalBaffle1DFvPatchScalarField.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/thermalBaffle1D/thermalBaffle1DFvPatchScalarFields.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "thermoBaffle1DFvPatchScalarFields.H"
+#include "thermalBaffle1DFvPatchScalarFields.H"
 #include "addToRunTimeSelectionTable.H"
 
 
@@ -38,28 +38,28 @@ namespace compressible
 
 defineTemplateTypeNameAndDebugWithName
 (
-    constSolid_thermoBaffle1DFvPatchScalarField,
+    constSolid_thermalBaffle1DFvPatchScalarField,
-    "compressible::thermoBaffle1D<hConstSolidThermoPhysics>",
+    "compressible::thermalBaffle1D<hConstSolidThermoPhysics>",
     0
 );
 
 addToPatchFieldRunTimeSelection
 (
     fvPatchScalarField,
-    constSolid_thermoBaffle1DFvPatchScalarField
+    constSolid_thermalBaffle1DFvPatchScalarField
 );
 
 defineTemplateTypeNameAndDebugWithName
 (
-    expoSolid_thermoBaffle1DFvPatchScalarField,
+    expoSolid_thermalBaffle1DFvPatchScalarField,
-    "compressible::thermoBaffle1D<hExponentialSolidThermoPhysics>",
+    "compressible::thermalBaffle1D<hExponentialSolidThermoPhysics>",
     0
 );
 
 addToPatchFieldRunTimeSelection
 (
     fvPatchScalarField,
-    expoSolid_thermoBaffle1DFvPatchScalarField
+    expoSolid_thermalBaffle1DFvPatchScalarField
 );
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/thermalBaffle1D/thermalBaffle1DFvPatchScalarFields.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,10 +23,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef thermoBaffle1DFvPatchScalarFields_H
+#ifndef thermalBaffle1DFvPatchScalarFields_H
-#define thermoBaffle1DFvPatchScalarFields_H
+#define thermalBaffle1DFvPatchScalarFields_H
 
-#include "thermoBaffle1DFvPatchScalarField.H"
+#include "thermalBaffle1DFvPatchScalarField.H"
 #include "solidThermoPhysicsTypes.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -38,15 +38,15 @@ namespace compressible
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-    typedef thermoBaffle1DFvPatchScalarField
+    typedef thermalBaffle1DFvPatchScalarField
     <
         hConstSolidThermoPhysics
-    >constSolid_thermoBaffle1DFvPatchScalarField;
+    >constSolid_thermalBaffle1DFvPatchScalarField;
 
-    typedef thermoBaffle1DFvPatchScalarField
+    typedef thermalBaffle1DFvPatchScalarField
     <
         hExponentialSolidThermoPhysics
-    >expoSolid_thermoBaffle1DFvPatchScalarField;
+    >expoSolid_thermalBaffle1DFvPatchScalarField;
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,8 +26,7 @@ License
 #include "wallHeatTransferFvPatchScalarField.H"
 #include "addToRunTimeSelectionTable.H"
 #include "fvPatchFieldMapper.H"
-#include "volFields.H"
+#include "turbulenceModel.H"
-#include "basicThermo.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -149,19 +148,19 @@ void Foam::wallHeatTransferFvPatchScalarField::updateCoeffs()
         return;
     }
 
-    const basicThermo& thermo = basicThermo::lookupThermo(*this);
+    const compressible::turbulenceModel& turbModel =
-    const label patchi = patch().index();
+        db().lookupObject<compressible::turbulenceModel>
+        (
+            "turbulenceModel"
+        );
 
-    const scalarField& pw = thermo.p().boundaryField()[patchi];
+    const label patchi = patch().index();
-    const scalarField& Tw = thermo.T().boundaryField()[patchi];
-    const scalarField Cpw(thermo.Cp(pw, Tw, patchi));
 
     valueFraction() =
         1.0/
         (
             1.0
-          + Cpw*thermo.alpha().boundaryField()[patchi]
+          + turbModel.kappaEff(patchi)*patch().deltaCoeffs()/alphaWall_
-           *patch().deltaCoeffs()/alphaWall_
         );
 
     mixedFvPatchScalarField::updateCoeffs();

src/turbulenceModels/compressible/turbulenceModel/derivedFvPatchFields/wallHeatTransfer/wallHeatTransferFvPatchScalarField.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/constant/thermalBaffleProperties

@@ -11,17 +11,17 @@ FoamFile
     format      ascii;
     class       dictionary;
     location    "constant";
-    object      thermoBaffleProperties;
+    object      thermalBaffleProperties;
 }
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-thermoBaffleModel  none;
+thermalBaffleModel  none;
 
 active          no;
 
 regionName      none;
 
-thermoBaffleCoeffs
+thermalBaffleCoeffs
 {
 }
 

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/baffleRegion/changeDictionaryDict

@@ -22,7 +22,7 @@ dictionaryReplacement
         {
             "region0_to.*"
             {
-                type                compressible::thermoBaffle;
+                type                compressible::thermalBaffle;
                 neighbourFieldName  T;
                 kappa               solidThermo;
                 kappaName           none;

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/changeDictionaryDict

@@ -88,7 +88,7 @@ dictionaryReplacement
         {
             "baffle.*"
             {
-                type        compressible::thermoBaffle1D<hConstSolidThermoPhysics>;
+                type        compressible::thermalBaffle1D<hConstSolidThermoPhysics>;
                 baffleActivated yes;
                 thickness       uniform 0.005;  // thickness [m]
                 Qs              uniform 100;    // heat flux [W/m2]

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/changeDictionaryDict.baffle

@@ -88,7 +88,7 @@ dictionaryReplacement
         {
             "baffle1Wall.*"
             {
-                type   compressible::thermoBaffle1D<hConstSolidThermoPhysics>;
+                type   compressible::thermalBaffle1D<hConstSolidThermoPhysics>;
                 baffleActivated yes;
                 thickness       uniform 0.005;  // thickness [m]
                 Qs              uniform 100;    // heat flux [W/m2]

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/changeDictionaryDict.baffleRegion

@@ -91,7 +91,7 @@ dictionaryReplacement
 
             "region0_to.*"
             {
-                type                compressible::thermoBaffle;
+                type                compressible::thermalBaffle;
 
                 // Coupled BC.
                 neighbourFieldName  T;
@@ -99,11 +99,11 @@ dictionaryReplacement
                 kappaName           none;
 
                 // Thermo baffle model
-                thermoBaffleModel   thermoBaffle;
+                thermalBaffleModel   thermalBaffle;
                 regionName          baffleRegion;
                 infoOutput          no;
                 active              yes;
-                thermoBaffleCoeffs
+                thermalBaffleCoeffs
                 {
                 }
 

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/controlDict

@@ -44,6 +44,6 @@ timePrecision   6;
 
 runTimeModifiable true;
 
-libs ("libthermoBaffleModels.so" "libcompressibleRASModels.so");
+libs ("libthermalBaffleModels.so" "libcompressibleRASModels.so");
 
 // ************************************************************************* //

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/createBafflesDict

@@ -52,7 +52,7 @@ baffles
                 {
                     T
                     {
-                        type   compressible::thermoBaffle1D<hConstSolidThermoPhysics>;
+                        type   compressible::thermalBaffle1D<hConstSolidThermoPhysics>;
                         baffleActivated yes;
                         thickness       uniform 0.005;  // thickness [m]
                         Qs              uniform 100;    // heat flux [W/m2]

tutorials/multiphase/compressibleInterFoam/les/depthCharge2D/constant/thermophysicalProperties

@@ -0,0 +1,19 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

tutorials/multiphase/compressibleInterFoam/les/depthCharge2D/constant/thermophysicalProperties1

@@ -0,0 +1,53 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+thermoType
+{
+    type            heRhoThermo;
+    mixture         pureMixture;
+    transport       const;
+    thermo          hConst;
+    equationOfState perfectFluid;
+    specie          specie;
+    energy          sensibleInternalEnergy;
+}
+
+mixture
+{
+    specie
+    {
+        nMoles      1;
+        molWeight   28.9; //2.77;
+    }
+    equationOfState
+    {
+        rho0        1027;
+    }
+    thermodynamics
+    {
+        Cp          4195;
+        Hf          0;
+    }
+    transport
+    {
+        mu          3.645e-4;
+        Pr          2.289;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/multiphase/compressibleInterFoam/les/depthCharge2D/constant/thermophysicalProperties2

@@ -0,0 +1,49 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+thermoType
+{
+    type            heRhoThermo;
+    mixture         pureMixture;
+    transport       const;
+    thermo          hConst;
+    equationOfState perfectGas;
+    specie          specie;
+    energy          sensibleInternalEnergy;
+}
+
+mixture
+{
+    specie
+    {
+        nMoles      1;
+        molWeight   28.9;
+    }
+    thermodynamics
+    {
+        Cp          1007;
+        Hf          0;
+    }
+    transport
+    {
+        mu          1.84e-05;
+        Pr          0.7;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/multiphase/compressibleInterFoam/les/depthCharge2D/constant/transportProperties

@@ -22,16 +22,6 @@ water
     transportModel  Newtonian;
     nu              1e-06;
     rho             1000;
-    k               0; // 0.613;
-    Cv              4179;
-
-    equationOfState
-    {
-        type            perfectFluid;
-
-        rho0            1000;
-        R               3000;
-    }
 }
 
 air
@@ -39,16 +29,6 @@ air
     transportModel  Newtonian;
     nu              1.589e-05;
     rho             1;
-    k               0; // 2.63e-2;
-    Cv              721;
-
-    equationOfState
-    {
-        type            perfectFluid;
-
-        rho0            0;
-        R               287;
-    }
 }
 
 pMin            pMin [ 1 -1 -2 0 0 0 0 ] 10000;

tutorials/multiphase/compressibleInterFoam/les/depthCharge2D/system/fvSchemes

@@ -33,6 +33,7 @@ divSchemes
     div(phid1,p_rgh) Gauss upwind;
     div(phid2,p_rgh) Gauss upwind;
     div(rho*phi,T)  Gauss upwind;
+    div(rho*phi,K)  Gauss upwind;
     div(phi,k)      Gauss vanLeer;
     div((muEff*dev(T(grad(U))))) Gauss linear;
 }

tutorials/multiphase/compressibleInterFoam/les/depthCharge2D/system/fvSolution

@@ -39,7 +39,7 @@ solvers
         maxIter         100;
     }
 
-    "(rho|rhoFinal)"
+    ".*(rho|rhoFinal)"
     {
         solver          diagonal;
     }