Merge branch 'master' of ssh://dm/home/dm4/OpenFOAM/OpenFOAM-dev

applications/utilities/mesh/generation/snappyHexMesh/snappyHexMesh.C

@@ -40,6 +40,7 @@ Description
 #include "refinementFeatures.H"
 #include "shellSurfaces.H"
 #include "decompositionMethod.H"
+#include "noDecomp.H"
 #include "fvMeshDistribute.H"
 #include "wallPolyPatch.H"
 #include "refinementParameters.H"
@@ -176,17 +177,27 @@ int main(int argc, char *argv[])
 
 
     // Read decomposePar dictionary
-    IOdictionary decomposeDict
+    dictionary decomposeDict;
-    (
+    {
-        IOobject
+        IOobject io
         (
             "decomposeParDict",
             runTime.system(),
             mesh,
             IOobject::MUST_READ_IF_MODIFIED,
             IOobject::NO_WRITE
-        )
+        );
-    );
+
+        if (io.headerOk())
+        {
+            decomposeDict = IOdictionary(io);
+        }
+        else
+        {
+            decomposeDict.add("method", "none");
+            decomposeDict.add("numberOfSubdomains", 1);
+        }
+    }
 
 
     // Debug

applications/utilities/miscellaneous/patchSummary/patchSummary.C

@@ -191,6 +191,22 @@ int main(int argc, char *argv[])
                     outputFieldList<tensor>(vtf, patchIDs[0]);
                     Info<< endl;
                 }
+                else
+                {
+                    // No group.
+                    forAll(patchIDs, i)
+                    {
+                        label patchI = patchIDs[i];
+                        Info<< bm[patchI].type()
+                            << "\t: " << bm[patchI].name() << nl;
+                        outputFieldList<scalar>(vsf, patchI);
+                        outputFieldList<vector>(vvf, patchI);
+                        outputFieldList<sphericalTensor>(vsptf, patchI);
+                        outputFieldList<symmTensor>(vsytf, patchI);
+                        outputFieldList<tensor>(vtf, patchI);
+                        Info<< endl;
+                    }
+                }
             }
         }
     }

applications/utilities/postProcessing/wall/solidWallHeatFlux/createFields.H

@@ -3,4 +3,4 @@ autoPtr<solidThermo> thermo
     solidThermo::New(mesh)
 );
 
-volScalarField& T = thermo->T();
+const volScalarField& T = thermo->T();

src/finiteVolume/finiteVolume/gradSchemes/extendedLeastSquaresGrad/extendedLeastSquaresVectors.C

@@ -110,6 +110,38 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
     const labelUList& owner = mesh_.owner();
     const labelUList& neighbour = mesh_.neighbour();
 
+
+    // Determine number of dimensions and (for 2D) missing dimension
+    label nDims = 0;
+    label twoD = -1;
+    for (direction dir = 0; dir < vector::nComponents; dir++)
+    {
+        if (mesh.geometricD()[dir] == 1)
+        {
+            nDims++;
+        }
+        else
+        {
+            twoD = dir;
+        }
+    }
+
+    if (nDims == 1)
+    {
+        FatalErrorIn
+        (
+            "extendedLeastSquaresVectors::makeLeastSquaresVectors() const"
+        )   << "Found a mesh with only one geometric dimension : "
+            << mesh.geometricD()
+            << exit(FatalError);
+    }
+    else if (nDims == 2)
+    {
+        Info<< "extendedLeastSquares : detected " << nDims
+            << " valid directions. Missing direction " << twoD << nl << endl;
+    }
+
+
     const volVectorField& C = mesh.C();
 
     // Set up temporary storage for the dd tensor (before inversion)
@@ -122,7 +154,7 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
 
         vector d = C[nei] - C[own];
 
-        const symmTensor wdd(1.0/magSqr(d[facei])*sqr(d[facei]));
+        const symmTensor wdd(1.0/magSqr(d)*sqr(d));
 
         dd[own] += wdd;
         dd[nei] += wdd;
@@ -147,6 +179,28 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
         }
     }
 
+
+    // Check for missing dimensions
+    // Add the missing eigenvector (such that it does not
+    // affect the determinant)
+    if (nDims == 2)
+    {
+        forAll(dd, cellI)
+        {
+            if (twoD == 0)
+            {
+                dd[cellI].xx() = 1;
+            }
+            else if (twoD == 1)
+            {
+                dd[cellI].yy() = 1;
+            }
+            else
+            {
+                dd[cellI].zz() = 1;
+            }
+        }
+    }
     scalarField detdd(det(dd));
 
     Info<< "max(detdd) = " << max(detdd) << nl
@@ -170,7 +224,8 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
                 (
                     "extendedLeastSquaresVectors::"
                     "makeLeastSquaresVectors() const"
-                )   << "nAddCells exceeds maxNaddCells"
+                )   << "nAddCells exceeds maxNaddCells ("
+                    << maxNaddCells << ")"
                     << exit(FatalError);
             }
 
@@ -188,20 +243,35 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
 
                     if (cellj != i)
                     {
-                        if (cellj != -1)
+                        vector dCij = (mesh.C()[cellj] - mesh.C()[i]);
+
+                        symmTensor ddij =
+                            dd[i] + (1.0/magSqr(dCij))*sqr(dCij);
+
+                        // Add the missing eigenvector (such that it does not
+                        // affect the determinant)
+                        if (nDims == 2)
                         {
-                            vector dCij = (mesh.C()[cellj] - mesh.C()[i]);
+                            if (twoD == 0)
-
-                            symmTensor ddij =
-                                dd[i] + (1.0/magSqr(dCij))*sqr(dCij);
-
-                            scalar detddij = det(ddij);
-
-                            if (detddij > maxDetddij)
                             {
-                                addCell = cellj;
+                                ddij.xx() = 1;
-                                maxDetddij = detddij;
                             }
+                            else if (twoD == 1)
+                            {
+                                ddij.yy() = 1;
+                            }
+                            else
+                            {
+                                ddij.zz() = 1;
+                            }
+                        }
+
+                        scalar detddij = det(ddij);
+
+                        if (detddij > maxDetddij)
+                        {
+                            addCell = cellj;
+                            maxDetddij = detddij;
                         }
                     }
                 }
@@ -213,6 +283,25 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
                 additionalCells_[nAddCells++][1] = addCell;
                 vector dCij = mesh.C()[addCell] - mesh.C()[i];
                 dd[i] += (1.0/magSqr(dCij))*sqr(dCij);
+
+                // Add the missing eigenvector (such that it does not
+                // affect the determinant)
+                if (nDims == 2)
+                {
+                    if (twoD == 0)
+                    {
+                        dd[i].xx() = 1;
+                    }
+                    else if (twoD == 1)
+                    {
+                        dd[i].yy() = 1;
+                    }
+                    else
+                    {
+                        dd[i].zz() = 1;
+                    }
+                }
+
                 detdd[i] = det(dd[i]);
             }
         }
@@ -220,10 +309,16 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
 
     additionalCells_.setSize(nAddCells);
 
-    Info<< "max(detdd) = " << max(detdd) << nl
+    reduce(nAddCells, sumOp<label>());
-        << "min(detdd) = " << min(detdd) << nl
+    if (nAddCells)
-        << "average(detdd) = " << average(detdd) << nl
+    {
-        << "nAddCells/nCells = " << scalar(nAddCells)/mesh.nCells() << endl;
+        Info<< "max(detdd) = " << max(detdd) << nl
+            << "min(detdd) = " << min(detdd) << nl
+            << "average(detdd) = " << average(detdd) << nl
+            << "nAddCells/nCells = "
+            << scalar(nAddCells)/mesh.globalData().nTotalCells()
+            << endl;
+    }
 
     // Invert the dd tensor
     const symmTensorField invDd(inv(dd));
@@ -237,11 +332,8 @@ void Foam::extendedLeastSquaresVectors::makeLeastSquaresVectors() const
 
         vector d = C[nei] - C[own];
 
-        lsP[facei] =
+        lsP[facei] = (1.0/magSqr(d))*(invDd[own] & d);
-            (1.0/magSqr(d[facei]))*(invDd[owner[facei]] & d);
+        lsN[facei] = ((-1.0)/magSqr(d))*(invDd[nei] & d);
-
-        lsN[facei] =
-            ((-1.0)/magSqr(d[facei]))*(invDd[neighbour[facei]] & d);
     }
 
     forAll(blsP, patchI)

src/meshTools/algorithms/MeshWave/FaceCellWave.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-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -814,7 +814,27 @@ Foam::FaceCellWave<Type, TrackingData>::FaceCellWave
     nEvals_(0),
     nUnvisitedCells_(mesh_.nCells()),
     nUnvisitedFaces_(mesh_.nFaces())
-{}
+{
+    if
+    (
+        allFaceInfo.size() != mesh_.nFaces()
+     || allCellInfo.size() != mesh_.nCells()
+    )
+    {
+        FatalErrorIn
+        (
+            "FaceCellWave<Type, TrackingData>::FaceCellWave"
+            "(const polyMesh&, const labelList&, const List<Type>,"
+            " UList<Type>&, UList<Type>&, const label maxIter)"
+        )   << "face and cell storage not the size of mesh faces, cells:"
+            << endl
+            << "    allFaceInfo   :" << allFaceInfo.size() << endl
+            << "    mesh_.nFaces():" << mesh_.nFaces() << endl
+            << "    allCellInfo   :" << allCellInfo.size() << endl
+            << "    mesh_.nCells():" << mesh_.nCells()
+            << exit(FatalError);
+    }
+}
 
 
 // Iterate, propagating changedFacesInfo across mesh, until no change (or
@@ -850,6 +870,26 @@ Foam::FaceCellWave<Type, TrackingData>::FaceCellWave
     nUnvisitedCells_(mesh_.nCells()),
     nUnvisitedFaces_(mesh_.nFaces())
 {
+    if
+    (
+        allFaceInfo.size() != mesh_.nFaces()
+     || allCellInfo.size() != mesh_.nCells()
+    )
+    {
+        FatalErrorIn
+        (
+            "FaceCellWave<Type, TrackingData>::FaceCellWave"
+            "(const polyMesh&, const labelList&, const List<Type>,"
+            " UList<Type>&, UList<Type>&, const label maxIter)"
+        )   << "face and cell storage not the size of mesh faces, cells:"
+            << endl
+            << "    allFaceInfo   :" << allFaceInfo.size() << endl
+            << "    mesh_.nFaces():" << mesh_.nFaces() << endl
+            << "    allCellInfo   :" << allCellInfo.size() << endl
+            << "    mesh_.nCells():" << mesh_.nCells()
+            << exit(FatalError);
+    }
+
     // Copy initial changed faces data
     setFaceInfo(changedFaces, changedFacesInfo);
 

src/parallel/decompose/decompositionMethods/Make/files

@@ -6,5 +6,6 @@ manualDecomp/manualDecomp.C
 multiLevelDecomp/multiLevelDecomp.C
 structuredDecomp/topoDistanceData.C
 structuredDecomp/structuredDecomp.C
+noDecomp/noDecomp.C
 
 LIB = $(FOAM_LIBBIN)/libdecompositionMethods

src/parallel/decompose/decompositionMethods/manualDecomp/manualDecomp.H

@@ -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-2012 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -111,7 +111,7 @@ public:
             notImplemented
             (
                 "decompose(const labelListList&, const pointField&"
-                ", const scalarField)"
+                ", const scalarField&)"
             );
             return labelList(0);
         }

src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.C

@@ -0,0 +1,53 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "noDecomp.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeName(noDecomp);
+
+    addNamedToRunTimeSelectionTable
+    (
+        decompositionMethod,
+        noDecomp,
+        dictionary,
+        none
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::noDecomp::noDecomp(const dictionary& decompositionDict)
+:
+    decompositionMethod(decompositionDict)
+{}
+
+
+// ************************************************************************* //

src/parallel/decompose/decompositionMethods/noDecomp/noDecomp.H

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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::noDecomp
+
+Description
+    Dummy decomposition method
+
+SourceFiles
+    noDecomp.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef noDecomp_H
+#define noDecomp_H
+
+#include "decompositionMethod.H"
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class noDecomp Declaration
+\*---------------------------------------------------------------------------*/
+
+class noDecomp
+:
+    public decompositionMethod
+{
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct and assignment
+        void operator=(const noDecomp&);
+        noDecomp(const noDecomp&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("noDecomp");
+
+
+    // Constructors
+
+        //- Construct given the decomposition dictionary
+        noDecomp(const dictionary& decompositionDict);
+
+    //- Destructor
+    virtual ~noDecomp()
+    {}
+
+
+    // Member Functions
+
+        //- manual decompose does not care about proc boundaries - is all
+        //  up to the user.
+        virtual bool parallelAware() const
+        {
+            return false;
+        }
+
+        //- Return for every coordinate the wanted processor number. Use the
+        //  mesh connectivity (if needed)
+        virtual labelList decompose
+        (
+            const polyMesh& mesh,
+            const pointField& cc,
+            const scalarField& cWeights
+        )
+        {
+            notImplemented
+            (
+                "decompose(const polyMesh&, const pointField&"
+                ", const scalarField&)"
+            );
+            return labelList(0);
+        }
+
+        //- Return for every coordinate the wanted processor number. Explicitly
+        //  provided connectivity - does not use mesh_.
+        //  The connectivity is equal to mesh.cellCells() except for
+        //  - in parallel the cell numbers are global cell numbers (starting
+        //    from 0 at processor0 and then incrementing all through the
+        //    processors)
+        //  - the connections are across coupled patches
+        virtual labelList decompose
+        (
+            const labelListList& globalCellCells,
+            const pointField& cc,
+            const scalarField& cWeights
+        )
+        {
+            notImplemented
+            (
+                "decompose(const labelListList&, const pointField&"
+                ", const scalarField&)"
+            );
+            return labelList(0);
+        }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMaxTemplates.C

@@ -73,16 +73,16 @@ void Foam::fieldMinMax::calcMinMaxFields
                 Pstream::gatherList(maxVs);
                 Pstream::gatherList(maxCs);
 
-                label minI = findMin(minVs);
-                scalar minValue = minVs[minI];
-                const vector& minC = minCs[minI];
-
-                label maxI = findMax(maxVs);
-                scalar maxValue = maxVs[maxI];
-                const vector& maxC = maxCs[maxI];
-
                 if (Pstream::master())
                 {
+                    label minI = findMin(minVs);
+                    scalar minValue = minVs[minI];
+                    const vector& minC = minCs[minI];
+
+                    label maxI = findMax(maxVs);
+                    scalar maxValue = maxVs[maxI];
+                    const vector& maxC = maxCs[maxI];
+
                     if (write_)
                     {
                         fieldMinMaxFilePtr_()
@@ -153,17 +153,16 @@ void Foam::fieldMinMax::calcMinMaxFields
                 Pstream::gatherList(maxVs);
                 Pstream::gatherList(maxCs);
 
-                label minI = findMin(minVs);
-                Type minValue = minVs[minI];
-                const vector& minC = minCs[minI];
-
-                label maxI = findMax(maxVs);
-                Type maxValue = maxVs[maxI];
-                const vector& maxC = maxCs[maxI];
-
-
                 if (Pstream::master())
                 {
+                    label minI = findMin(minVs);
+                    Type minValue = minVs[minI];
+                    const vector& minC = minCs[minI];
+
+                    label maxI = findMax(maxVs);
+                    Type maxValue = maxVs[maxI];
+                    const vector& maxC = maxCs[maxI];
+
                     if (write_)
                     {
                         fieldMinMaxFilePtr_()

src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C

@@ -349,7 +349,7 @@ reactingOneDim::reactingOneDim(const word& modelType, const fvMesh& mesh)
     pyrolysisModel(modelType, mesh),
     solidChemistry_(solidChemistryModel::New(regionMesh())),
     solidThermo_(solidChemistry_->solid()),
-    rho_(solidThermo_.rhos()),
+    rho_(solidThermo_.rho()),
     Ys_(solidThermo_.composition().Y()),
     h_(solidThermo_.he()),
     primaryRadFluxName_(coeffs().lookupOrDefault<word>("radFluxName", "Qr")),
@@ -449,7 +449,7 @@ reactingOneDim::reactingOneDim
     pyrolysisModel(modelType, mesh, dict),
     solidChemistry_(solidChemistryModel::New(regionMesh())),
     solidThermo_(solidChemistry_->solid()),
-    rho_(solidThermo_.rhos()),
+    rho_(solidThermo_.rho()),
     Ys_(solidThermo_.composition().Y()),
     h_(solidThermo_.he()),
     primaryRadFluxName_(dict.lookupOrDefault<word>("radFluxName", "Qr")),

src/regionModels/thermoBaffleModels/thermoBaffle2D/thermoBaffle2D.C

@@ -359,7 +359,7 @@ void thermoBaffle2D::info() const
             (
                 mag(regionMesh().Sf().boundaryField()[patchI])
               * ph.snGrad()
-              * thermo_->alpha(patchI)
+              * thermo_->alpha().boundaryField()[patchI]
             ) << endl;
     }
 }

src/thermophysicalModels/basic/basicThermo/basicThermo.C

@@ -40,62 +40,7 @@ namespace Foam
     defineTypeNameAndDebug(basicThermo, 0);
     defineRunTimeSelectionTable(basicThermo, fvMesh);
 }
-/*
-// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-Foam::wordList Foam::basicThermo::heBoundaryTypes()
-{
-    const volScalarField::GeometricBoundaryField& tbf = 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<temperatureJumpFvPatchScalarField>(tbf[patchi]))
-        {
-            hbt[patchi] = energyJumpFvPatchScalarField::typeName;
-        }
-    }
-
-    return hbt;
-}
-
-
-void Foam::basicThermo::heBoundaryCorrection(volScalarField& h)
-{
-    volScalarField::GeometricBoundaryField& hbf = h.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();
-        }
-    }
-}
-*/
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 

src/thermophysicalModels/basic/rhoThermo/rhoThermo/rhoThermo.C

@@ -55,6 +55,25 @@ Foam::rhoThermo::rhoThermo(const fvMesh& mesh)
 {}
 
 
+Foam::rhoThermo::rhoThermo(const fvMesh& mesh, const dictionary& dict)
+:
+    basicThermo(mesh, dict),
+    rho_
+    (
+        IOobject
+        (
+            "rhoThermo",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh,
+        dimDensity
+    )
+{}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::rhoThermo::~rhoThermo()

src/thermophysicalModels/basic/rhoThermo/rhoThermo/rhoThermo.H

@@ -90,6 +90,9 @@ public:
         //- Construct from mesh
         rhoThermo(const fvMesh&);
 
+        //- Construct from mesh
+        rhoThermo(const fvMesh&, const dictionary&);
+
 
     //- Selector
     static autoPtr<rhoThermo> New(const fvMesh&);

src/thermophysicalModels/basicSolidThermo/heSolidThermo/heSolidThermo.H

@@ -89,9 +89,6 @@ public:
 
         // Derived thermal properties
 
-            //- Isotropic thermal conductivity [W/m/K]
-            //virtual tmp<volScalarField> kappa() const;
-
             //- Anisotropic thermal conductivity [W/m/K]
             virtual tmp<volVectorField> Kappa() const;
 

src/thermophysicalModels/basicSolidThermo/solidReactionThermo/solidReactionThermo.C

@@ -35,6 +35,7 @@ namespace Foam
     defineRunTimeSelectionTable(solidReactionThermo, dictionary);
 }
 
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::solidReactionThermo::solidReactionThermo(const fvMesh& mesh)
@@ -52,6 +53,7 @@ Foam::solidReactionThermo::solidReactionThermo
     solidThermo(mesh, dict)
 {}
 
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::solidReactionThermo::~solidReactionThermo()

src/thermophysicalModels/basicSolidThermo/solidThermo/solidThermo.C

@@ -42,20 +42,7 @@ namespace Foam
 
 Foam::solidThermo::solidThermo(const fvMesh& mesh)
 :
-    basicThermo(mesh),
+    rhoThermo(mesh)
-    rho_
-    (
-        IOobject
-        (
-            "rho",
-            mesh.time().timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh,
-        dimMass/dimVolume
-    )
 {}
 
 
@@ -65,20 +52,7 @@ Foam::solidThermo::solidThermo
     const dictionary& dict
 )
 :
-    basicThermo(mesh, dict),
+    rhoThermo(mesh, dict)
-    rho_
-    (
-        IOobject
-        (
-            "rho",
-            mesh.time().timeName(),
-            mesh,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh,
-        dimMass/dimVolume
-    )
 {}
 
 
@@ -90,57 +64,10 @@ Foam::solidThermo::~solidThermo()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-Foam::volScalarField& Foam::solidThermo::T()
-{
-    return this->T_;
-}
-
-
-const Foam::volScalarField& Foam::solidThermo::T() const
-{
-    return this->T_;
-}
-
-
-const Foam::volScalarField& Foam::solidThermo::rhos() const
-{
-    return rho_;
-}
-
-
-Foam::volScalarField& Foam::solidThermo::rhos()
-{
-    return rho_;
-}
-
-
-const Foam::volScalarField& Foam::solidThermo::p() const
-{
-    return this->p_;
-}
-
-
-Foam::volScalarField& Foam::solidThermo::p()
-{
-    return this->p_;
-}
-
-
-const Foam::volScalarField& Foam::solidThermo::alpha() const
-{
-    return this->alpha_;
-}
-
-
-Foam::tmp<Foam::volScalarField> Foam::solidThermo::rho() const
-{
-    return tmp<volScalarField>(rho_);
-}
-
-
 bool Foam::solidThermo::read()
 {
     return regIOobject::read();
 }
 
+
 // ************************************************************************* //

src/thermophysicalModels/basicSolidThermo/solidThermo/solidThermo.H

@@ -41,7 +41,7 @@ SourceFiles
 #include "IOdictionary.H"
 #include "autoPtr.H"
 #include "basicSolidMixture.H"
-#include "basicThermo.H"
+#include "rhoThermo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -54,18 +54,9 @@ namespace Foam
 
 class solidThermo
 :
-    public basicThermo
+    public rhoThermo
 {
 
-protected:
-
-
-        // Fields
-
-            //- Density [kg/m3]
-            volScalarField rho_;
-
-
 public:
 
     //- Runtime type information
@@ -116,50 +107,9 @@ public:
 
     // Member functions
 
-        //- Update properties
-        virtual void correct() = 0;
-
-
-        // Access to thermodynamic state variables
-
-            //- Constant access to temperature [K]
-            virtual const volScalarField& T() const;
-
-            //- Non constant access to temperature [K]
-            virtual volScalarField& T();
-
-            //- Solid density [kg/m3]
-            virtual const volScalarField& rhos() const;
-
-            //- Non-const access for solid density [kg/m3]
-            virtual volScalarField& rhos();
-
-
-            //- Constant access to p [Pa]
-            virtual const volScalarField& p() const;
-
-            //- Non-constant access to p [Pa]
-            virtual volScalarField& p();
-
-
-        // Access to transport state variables
-
-            //- Thermal diffusivity for enthalpy of mixture [kg/m/s]
-            virtual const volScalarField& alpha() const;
-
 
         // Derived thermal properties
 
-            //- Enthalpy/Internal energy [J/kg]
-            virtual const volScalarField& he() const = 0;
-
-            //- Enthalpy/Internal energy [J/kg]
-            //  Non-const access allowed for transport equations
-            virtual volScalarField& he() = 0;
-
-            //- Thermal conductivity [W/m/K]
-            virtual tmp<volScalarField> kappa() const = 0;
-
             //- Thermal conductivity [W/m/K]
             virtual tmp<volVectorField> Kappa() const = 0;
 
@@ -172,50 +122,12 @@ public:
             //- Emissivity coefficient [1/m]
             virtual tmp<volScalarField> emissivity() const = 0;
 
-            //- Specific heat capacity [J/kg/K]
-            virtual tmp<volScalarField> Cp() const = 0;
-
-            //- Heat of formation [J/kg]
-            virtual tmp<volScalarField> hc() const = 0;
-
-             //- Density [kg/m^3]
-            virtual tmp<volScalarField> rho() const;
-
 
         // Per patch calculation
 
-            //- Enthalpy/Internal energy [J/kg]
-            virtual tmp<scalarField> he
-            (
-                const scalarField& p,
-                const scalarField& T,
-                const label patchi
-            ) const = 0;
-
-
-            //- Specific heat capacity [J/kg/K)]
-            virtual tmp<scalarField> Cp
-            (
-                const scalarField& p,
-                const scalarField& T,
-                const label patchI
-            ) const = 0;
-
-
-            //- Isotropic thermal conductivity [W//m/K]
-            virtual tmp<scalarField> kappa
-            (
-                const label patchI
-            ) const = 0;
 
             //- Anisotropic thermal conductivity [W/m/K]
             virtual tmp<vectorField> Kappa
-            (
-                const label patchI
-            ) const = 0;
-
-            //- Thermal diffusivity for enthalpy of mixture [kg/m/s]
-            virtual tmp<scalarField> alpha
             (
                 const label patchI
             ) const = 0;

tutorials/incompressible/pisoFoam/les/motorBike/motorBike/system/controlDict

@@ -17,7 +17,7 @@ FoamFile
 
 libs            ("libOpenFOAM.so" "libfieldFunctionObjects.so");
 
-application     simpleFoam;
+application     pisoFoam;
 
 startFrom       latestTime;