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

applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C

@@ -1026,7 +1026,7 @@ void Foam::ensightMesh::write
 
     if (timeIndex == 0)
     {
-        timeFile += "000.";
+        timeFile += "0000.";
     }
     else if (meshMoving)
     {

src/edgeMesh/extendedFeatureEdgeMesh/extendedFeatureEdgeMeshTemplates.C

@@ -65,8 +65,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     labelListList featurePointFeatureEdges(nFeatPts);
     forAll(featurePointFeatureEdges, pI)
     {
-        featurePointFeatureEdges[pI] =
+        featurePointFeatureEdges[pI] = pointEdges[featurePoints[pI]];
-            labelList(pointEdges[featurePoints[pI]].size(), -1);
     }
 
     // Mapping between old and new indices, there is entry in the map for each
@@ -74,6 +73,10 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     // >= 0 corresponds to the index
     labelList pointMap(sFeatLocalPts.size(), -1);
 
+    // Mapping between surface edge index and its feature edge index. -1 if it
+    // is not a feature edge
+    labelList edgeMap(sFeatEds.size(), -1);
+
     // Noting when the normal of a face has been used so not to duplicate
     labelList faceMap(surf.size(), -1);
 
@@ -98,6 +101,8 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     {
         label sFEI = featureEdges[i];
 
+        edgeMap[sFEI] = i;
+
         const edge& fE(sFeatEds[sFEI]);
 
         // Check to see if the points have been already used
@@ -156,43 +161,31 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
         {
             regionEdges.append(i);
         }
+    }
 
-        forAll(featurePointFeatureEdges, pI)
+    // Populate feature point feature edges
-        {
+    DynamicList<label> newFeatureEdges;
-            const labelList& fpfEdges = pointEdges[featurePoints[pI]];
-
-            labelList& fpfe = featurePointFeatureEdges[pI];
-
-            forAll(fpfEdges, eI)
-            {
-                if (sFEI == fpfEdges[eI])
-                {
-                    fpfe[eI] = i;
-                }
-            }
-        }
-    }
 
     forAll(featurePointFeatureEdges, pI)
     {
         const labelList& fpfe = featurePointFeatureEdges[pI];
 
-        DynamicList<label> newFeatureEdges(fpfe.size());
+        newFeatureEdges.setCapacity(fpfe.size());
 
         forAll(fpfe, eI)
         {
-            const label edgeIndex = fpfe[eI];
+            const label oldEdgeIndex = fpfe[eI];
+            const label newFeatureEdgeIndex = edgeMap[oldEdgeIndex];
 
-            if (edgeIndex != -1)
+            if (newFeatureEdgeIndex != -1)
             {
-                newFeatureEdges.append(edgeIndex);
+                newFeatureEdges.append(newFeatureEdgeIndex);
             }
         }
 
-        featurePointFeatureEdges[pI] = newFeatureEdges;
+        featurePointFeatureEdges[pI].transfer(newFeatureEdges);
     }
 
-
     // Reorder the edges by classification
 
     List<DynamicList<label> > allEds(nEdgeTypes);
@@ -277,7 +270,7 @@ void Foam::extendedFeatureEdgeMesh::sortPointsAndEdges
     edgeMesh::operator=(edgeMesh(pts, eds));
 
     // Initialise sorted edge related data
-    edgeDirections_ = edgeDirections/mag(edgeDirections);
+    edgeDirections_ = edgeDirections/(mag(edgeDirections) + VSMALL);
     edgeNormals_ = edgeNormals;
     regionEdges_ = regionEdges;
 

src/finiteVolume/Make/files

@@ -356,6 +356,8 @@ $(snGradSchemes)/faceCorrectedSnGrad/faceCorrectedSnGrads.C
 $(snGradSchemes)/limitedSnGrad/limitedSnGrads.C
 $(snGradSchemes)/uncorrectedSnGrad/uncorrectedSnGrads.C
 $(snGradSchemes)/orthogonalSnGrad/orthogonalSnGrads.C
+$(snGradSchemes)/quadraticFitSnGrad/quadraticFitSnGrads.C
+$(snGradSchemes)/linearFitSnGrad/linearFitSnGrads.C
 
 convectionSchemes = finiteVolume/convectionSchemes
 $(convectionSchemes)/convectionScheme/convectionSchemes.C

src/finiteVolume/finiteVolume/gradSchemes/fourthGrad/fourthGrad.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
@@ -62,7 +62,11 @@ Foam::fv::fourthGrad<Type>::calcGrad
     // Assemble the second-order least-square gradient
     // Calculate the second-order least-square gradient
     tmp<GeometricField<GradType, fvPatchField, volMesh> > tsecondfGrad
-        = leastSquaresGrad<Type>(mesh).grad(vsf);
+      = leastSquaresGrad<Type>(mesh).grad
+        (
+            vsf,
+            "leastSquaresGrad(" + vsf.name() + ")"
+        );
     const GeometricField<GradType, fvPatchField, volMesh>& secondfGrad =
         tsecondfGrad();
 

src/finiteVolume/finiteVolume/snGradSchemes/CentredFitSnGrad/CentredFitSnGradData.C

@@ -0,0 +1,270 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "CentredFitSnGradData.H"
+#include "surfaceFields.H"
+#include "SVD.H"
+#include "extendedCentredCellToFaceStencil.H"
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+template<class Polynomial>
+Foam::CentredFitSnGradData<Polynomial>::CentredFitSnGradData
+(
+    const fvMesh& mesh,
+    const extendedCentredCellToFaceStencil& stencil,
+    const scalar linearLimitFactor,
+    const scalar centralWeight
+)
+:
+    FitData
+    <
+        CentredFitSnGradData<Polynomial>,
+        extendedCentredCellToFaceStencil,
+        Polynomial
+    >
+    (
+        mesh, stencil, true, linearLimitFactor, centralWeight
+    ),
+    coeffs_(mesh.nFaces())
+{
+    if (debug)
+    {
+        Info<< "Contructing CentredFitSnGradData<Polynomial>" << endl;
+    }
+
+    calcFit();
+
+    if (debug)
+    {
+        Info<< "CentredFitSnGradData<Polynomial>::CentredFitSnGradData() :"
+            << "Finished constructing polynomialFit data"
+            << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Polynomial>
+void Foam::CentredFitSnGradData<Polynomial>::calcFit
+(
+    scalarList& coeffsi,
+    const List<point>& C,
+    const scalar wLin,
+    const scalar deltaCoeff,
+    const label facei
+)
+{
+    vector idir(1,0,0);
+    vector jdir(0,1,0);
+    vector kdir(0,0,1);
+    this->findFaceDirs(idir, jdir, kdir, facei);
+
+    // Setup the point weights
+    scalarList wts(C.size(), scalar(1));
+    wts[0] = this->centralWeight();
+    wts[1] = this->centralWeight();
+
+    // Reference point
+    point p0 = this->mesh().faceCentres()[facei];
+
+    // p0 -> p vector in the face-local coordinate system
+    vector d;
+
+    // Local coordinate scaling
+    scalar scale = 1;
+
+    // Matrix of the polynomial components
+    scalarRectangularMatrix B(C.size(), this->minSize(), scalar(0));
+
+    forAll(C, ip)
+    {
+        const point& p = C[ip];
+        const vector p0p = p - p0;
+
+        d.x() = p0p & idir;
+        d.y() = p0p & jdir;
+        d.z() = p0p & kdir;
+
+        if (ip == 0)
+        {
+            scale = cmptMax(cmptMag((d)));
+        }
+
+        // Scale the radius vector
+        d /= scale;
+
+        Polynomial::addCoeffs(B[ip], d, wts[ip], this->dim());
+    }
+
+    // Additional weighting for constant and linear terms
+    for (label i = 0; i < B.n(); i++)
+    {
+        B[i][0] *= wts[0];
+        B[i][1] *= wts[0];
+    }
+
+    // Set the fit
+    label stencilSize = C.size();
+    coeffsi.setSize(stencilSize);
+
+    bool goodFit = false;
+    for (int iIt = 0; iIt < 8 && !goodFit; iIt++)
+    {
+        SVD svd(B, SMALL);
+
+        for (label i=0; i<stencilSize; i++)
+        {
+            coeffsi[i] = wts[1]*wts[i]*svd.VSinvUt()[1][i]/scale;
+        }
+
+        goodFit =
+        (
+            mag(wts[0]*wts[0]*svd.VSinvUt()[0][0] - wLin)
+          < this->linearLimitFactor()*wLin)
+         && (mag(wts[0]*wts[1]*svd.VSinvUt()[0][1] - (1 - wLin)
+        ) < this->linearLimitFactor()*(1 - wLin))
+         && coeffsi[0] < 0 && coeffsi[1] > 0
+         && mag(coeffsi[0] + deltaCoeff) < 0.5*deltaCoeff
+         && mag(coeffsi[1] - deltaCoeff) < 0.5*deltaCoeff;
+
+        if (!goodFit)
+        {
+            // (not good fit so increase weight in the centre and weight
+            //  for constant and linear terms)
+
+            WarningIn
+            (
+                "CentredFitSnGradData<Polynomial>::calcFit"
+                "(const List<point>& C, const label facei"
+            )   << "Cannot fit face " << facei << " iteration " << iIt
+                << " with sum of weights " << sum(coeffsi) << nl
+                << "    Weights " << coeffsi << nl
+                << "    Linear weights " << wLin << " " << 1 - wLin << nl
+                << "    deltaCoeff " << deltaCoeff << nl
+                << "    sing vals " << svd.S() << nl
+                << "Components of goodFit:\n"
+                << "    wts[0]*wts[0]*svd.VSinvUt()[0][0] = "
+                << wts[0]*wts[0]*svd.VSinvUt()[0][0] << nl
+                << "    wts[0]*wts[1]*svd.VSinvUt()[0][1] = "
+                << wts[0]*wts[1]*svd.VSinvUt()[0][1]
+                << " dim = " << this->dim() << endl;
+
+            wts[0] *= 10;
+            wts[1] *= 10;
+
+            for (label j = 0; j < B.m(); j++)
+            {
+                B[0][j] *= 10;
+                B[1][j] *= 10;
+            }
+
+            for (label i = 0; i < B.n(); i++)
+            {
+                B[i][0] *= 10;
+                B[i][1] *= 10;
+            }
+        }
+    }
+
+    if (goodFit)
+    {
+        // Remove the uncorrected coefficients
+        coeffsi[0] += deltaCoeff;
+        coeffsi[1] -= deltaCoeff;
+    }
+    else
+    {
+        WarningIn
+        (
+            "CentredFitSnGradData<Polynomial>::calcFit(..)"
+        )   << "Could not fit face " << facei
+            << "    Coefficients = " << coeffsi
+            << ", reverting to uncorrected." << endl;
+
+        coeffsi = 0;
+    }
+}
+
+
+template<class Polynomial>
+void Foam::CentredFitSnGradData<Polynomial>::calcFit()
+{
+    const fvMesh& mesh = this->mesh();
+
+    // Get the cell/face centres in stencil order.
+    // Centred face stencils no good for triangles or tets.
+    // Need bigger stencils
+    List<List<point> > stencilPoints(mesh.nFaces());
+    this->stencil().collectData(mesh.C(), stencilPoints);
+
+    // find the fit coefficients for every face in the mesh
+
+    const surfaceScalarField& w = mesh.surfaceInterpolation::weights();
+    const surfaceScalarField& dC = mesh.nonOrthDeltaCoeffs();
+
+    for (label facei = 0; facei < mesh.nInternalFaces(); facei++)
+    {
+        calcFit
+        (
+            coeffs_[facei],
+            stencilPoints[facei],
+            w[facei],
+            dC[facei],
+            facei
+        );
+    }
+
+    const surfaceScalarField::GeometricBoundaryField& bw = w.boundaryField();
+    const surfaceScalarField::GeometricBoundaryField& bdC = dC.boundaryField();
+
+    forAll(bw, patchi)
+    {
+        const fvsPatchScalarField& pw = bw[patchi];
+        const fvsPatchScalarField& pdC = bdC[patchi];
+
+        if (pw.coupled())
+        {
+            label facei = pw.patch().start();
+
+            forAll(pw, i)
+            {
+                calcFit
+                (
+                    coeffs_[facei],
+                    stencilPoints[facei],
+                    pw[i],
+                    pdC[i],
+                    facei
+                );
+                facei++;
+            }
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/finiteVolume/finiteVolume/snGradSchemes/CentredFitSnGrad/CentredFitSnGradData.H

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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::CentredFitSnGradData
+
+Description
+    Data for centred fit snGrad schemes
+
+SourceFiles
+    CentredFitSnGradData.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef CentredFitSnGradData_H
+#define CentredFitSnGradData_H
+
+#include "FitData.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class extendedCentredCellToFaceStencil;
+
+/*---------------------------------------------------------------------------*\
+                    Class CentredFitSnGradData Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Polynomial>
+class CentredFitSnGradData
+:
+    public FitData
+    <
+        CentredFitSnGradData<Polynomial>,
+        extendedCentredCellToFaceStencil,
+        Polynomial
+    >
+{
+    // Private data
+
+        //- For each cell in the mesh store the values which multiply the
+        //  values of the stencil to obtain the gradient for each direction
+        List<scalarList> coeffs_;
+
+
+public:
+
+    TypeName("CentredFitSnGradData");
+
+
+    // Constructors
+
+        //- Construct from components
+        CentredFitSnGradData
+        (
+            const fvMesh& mesh,
+            const extendedCentredCellToFaceStencil& stencil,
+            const scalar linearLimitFactor,
+            const scalar centralWeight
+        );
+
+
+    //- Destructor
+    virtual ~CentredFitSnGradData()
+    {}
+
+
+    // Member functions
+
+        //- Return reference to fit coefficients
+        const List<scalarList>& coeffs() const
+        {
+            return coeffs_;
+        }
+
+        //- Calculate the fit for the specified face and set the coefficients
+        void calcFit
+        (
+            scalarList& coeffsi, // coefficients to be set
+            const List<point>&,  // Stencil points
+            const scalar wLin,   // Weight for linear approximation (weights
+                                 // nearest neighbours)
+            const scalar deltaCoeff, // uncorrected delta coefficient
+            const label faci     // Current face index
+        );
+
+        void calcFit();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "CentredFitSnGradData.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/finiteVolume/snGradSchemes/CentredFitSnGrad/CentredFitSnGradScheme.H

@@ -0,0 +1,183 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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::CentredFitSnGradScheme
+
+Description
+    Centred fit snGrad scheme which applies an explicit correction to snGrad
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef CentredFitSnGradScheme_H
+#define CentredFitSnGradScheme_H
+
+#include "CentredFitSnGradData.H"
+#include "snGradScheme.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class fvMesh;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace fv
+{
+/*---------------------------------------------------------------------------*\
+                           Class CentredFitSnGradSnGradScheme Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type, class Polynomial, class Stencil>
+class CentredFitSnGradScheme
+:
+    public snGradScheme<Type>
+{
+    // Private Data
+
+        //- Factor the fit is allowed to deviate from linear.
+        //  This limits the amount of high-order correction and increases
+        //  stability on bad meshes
+        const scalar linearLimitFactor_;
+
+        //- Weights for central stencil
+        const scalar centralWeight_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        CentredFitSnGradScheme(const CentredFitSnGradScheme&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const CentredFitSnGradScheme&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("CentredFitSnGradScheme");
+
+
+    // Constructors
+
+        //- Construct from mesh and Istream
+        CentredFitSnGradScheme(const fvMesh& mesh, Istream& is)
+        :
+            snGradScheme<Type>(mesh),
+            linearLimitFactor_(readScalar(is)),
+            centralWeight_(1000)
+        {}
+
+
+    // Member Functions
+
+        //- Return the interpolation weighting factors for the given field
+        virtual tmp<surfaceScalarField> deltaCoeffs
+        (
+            const GeometricField<Type, fvPatchField, volMesh>&
+        ) const
+        {
+            return this->mesh().nonOrthDeltaCoeffs();
+        }
+
+        //- Return true if this scheme uses an explicit correction
+        virtual bool corrected() const
+        {
+            return true;
+        }
+
+        //- Return the explicit correction to the face-interpolate
+        virtual tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
+        correction
+        (
+            const GeometricField<Type, fvPatchField, volMesh>& vf
+        ) const
+        {
+            const fvMesh& mesh = this->mesh();
+
+            const extendedCentredCellToFaceStencil& stencil = Stencil::New
+            (
+                mesh
+            );
+
+            const CentredFitSnGradData<Polynomial>& cfd =
+                CentredFitSnGradData<Polynomial>::New
+                (
+                    mesh,
+                    stencil,
+                    linearLimitFactor_,
+                    centralWeight_
+                );
+
+            tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > sft
+            (
+                stencil.weightedSum(vf, cfd.coeffs())
+            );
+
+            sft().dimensions() /= dimLength;
+
+            return sft;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fv
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Add the patch constructor functions to the hash tables
+
+#define makeCentredFitSnGradTypeScheme(SS, POLYNOMIAL, STENCIL, TYPE) \
+                                                                      \
+typedef CentredFitSnGradScheme<TYPE, POLYNOMIAL, STENCIL>             \
+    CentredFitSnGradScheme##TYPE##POLYNOMIAL##STENCIL##_;             \
+defineTemplateTypeNameAndDebugWithName                                \
+    (CentredFitSnGradScheme##TYPE##POLYNOMIAL##STENCIL##_, #SS, 0);   \
+                                                                      \
+snGradScheme<TYPE>::addMeshConstructorToTable                         \
+<CentredFitSnGradScheme<TYPE, POLYNOMIAL, STENCIL> >                  \
+    add##SS##STENCIL##TYPE##MeshConstructorToTable_;
+
+#define makeCentredFitSnGradScheme(SS, POLYNOMIAL, STENCIL)           \
+                                                                      \
+makeCentredFitSnGradTypeScheme(SS,POLYNOMIAL,STENCIL,scalar)          \
+makeCentredFitSnGradTypeScheme(SS,POLYNOMIAL,STENCIL,vector)          \
+makeCentredFitSnGradTypeScheme(SS,POLYNOMIAL,STENCIL,sphericalTensor) \
+makeCentredFitSnGradTypeScheme(SS,POLYNOMIAL,STENCIL,symmTensor)      \
+makeCentredFitSnGradTypeScheme(SS,POLYNOMIAL,STENCIL,tensor)
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/finiteVolume/snGradSchemes/linearFitSnGrad/linearFitSnGrads.C

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "CentredFitSnGradScheme.H"
+#include "linearFitPolynomial.H"
+#include "centredFECCellToFaceStencilObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTemplateTypeNameAndDebug
+    (
+        CentredFitSnGradData<linearFitPolynomial>,
+        0
+    );
+
+    namespace fv
+    {
+        makeCentredFitSnGradScheme
+        (
+            linearFit,
+            linearFitPolynomial,
+            centredFECCellToFaceStencilObject
+        );
+    }
+}
+
+// ************************************************************************* //

src/finiteVolume/finiteVolume/snGradSchemes/quadraticFitSnGrad/quadraticFitSnGrads.C

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "CentredFitSnGradScheme.H"
+#include "quadraticFitPolynomial.H"
+#include "centredCFCCellToFaceStencilObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTemplateTypeNameAndDebug
+    (
+        CentredFitSnGradData<quadraticFitPolynomial>,
+        0
+    );
+
+    namespace fv
+    {
+        makeCentredFitSnGradScheme
+        (
+            quadraticFit,
+            quadraticFitPolynomial,
+            centredCFCCellToFaceStencilObject
+        );
+    }
+}
+
+// ************************************************************************* //

src/finiteVolume/interpolation/surfaceInterpolation/schemes/FitData/FitData.H

@@ -80,7 +80,7 @@ class FitData
         const label minSize_;
 
 
-    // Private Member Functions
+protected:
 
         //- Find the normal direction (i) and j and k directions for face faci
         void findFaceDirs
@@ -93,9 +93,6 @@ class FitData
 
 public:
 
-    //TypeName("FitData");
-
-
     // Constructors
 
         //- Construct from components
@@ -122,6 +119,30 @@ public:
             return stencil_;
         }
 
+        //- Factor the fit is allowed to deviate from the base scheme
+        scalar linearLimitFactor() const
+        {
+            return linearLimitFactor_;
+        }
+
+        //- Return weight for central stencil
+        scalar centralWeight() const
+        {
+            return centralWeight_;
+        }
+
+        //- Dimensionality of the geometry
+        label dim() const
+        {
+            return dim_;
+        }
+
+        //- Minimum stencil size
+        label minSize() const
+        {
+            return minSize_;
+        }
+
         bool linearCorrection() const
         {
             return linearCorrection_;
@@ -140,7 +161,6 @@ public:
         //- Calculate the fit for all the faces
         virtual void calcFit() = 0;
 
-
         //- Recalculate weights (but not stencil) when the mesh moves
         bool movePoints();
 };

src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriverFeature.C

@@ -767,7 +767,7 @@ void Foam::autoSnapDriver::binFeatureFace
 ) const
 {
     // What to do with very far attraction? For now just ignore the face
-    if (magSqr(faceDisp) < sqr(snapDist))
+    if (magSqr(faceDisp) < sqr(snapDist) && mag(faceSurfaceNormal) > VSMALL)
     {
         const point pt = fc + faceDisp;
 

src/thermophysicalModels/radiationModels/radiationModel/P1/P1.C

@@ -241,10 +241,14 @@ void Foam::radiation::P1::calculate()
     );
 
     // Calculate radiative heat flux on boundaries.
-    forAll(mesh_.boundaryMesh(), patchI)
+    forAll(mesh_.boundaryMesh(), patchi)
     {
-        Qr_.boundaryField()[patchI] =
+        if (!G_.boundaryField()[patchi].coupled())
-            -gamma.boundaryField()[patchI]*G_.boundaryField()[patchI].snGrad();
+        {
+            Qr_.boundaryField()[patchi] =
+                -gamma.boundaryField()[patchi]
+                *G_.boundaryField()[patchi].snGrad();
+        }
     }
 }
 

src/thermophysicalModels/solidChemistryModel/basicSolidChemistryModel/basicSolidChemistryModelNew.C

@@ -53,11 +53,12 @@ New
 
     Info<< "Selecting chemistry type " << chemistryTypeDict << endl;
 
-    const int nCmpt = 12;
+    const int nCmpt = 13;
     const char* cmptNames[nCmpt] =
     {
         "chemistrySolver",
         "chemistryThermo",
+        "baseChemistry",
         "transport",
         "thermo",
         "equationOfState",
@@ -107,8 +108,9 @@ New
     word chemistryTypeName
     (
         word(chemistryTypeDict.lookup("chemistrySolver")) + '<'
-      + word(chemistryTypeDict.lookup("chemistryThermo")) + ','
+      + word(chemistryTypeDict.lookup("chemistryThermo")) + '<'
-      + solidThermoTypeName + ',' + gasThermoTypeName + ">"
+      + typeName + ','
+      + solidThermoTypeName + ',' + gasThermoTypeName + ">>"
     );
 
     Info<< "chemistryTypeName " << chemistryTypeName << endl;

src/transportModels/incompressible/incompressibleTwoPhaseMixture/incompressibleTwoPhaseMixture.C

@@ -175,8 +175,14 @@ bool Foam::incompressibleTwoPhaseMixture::read()
     {
         if
         (
-            nuModel1_().read(subDict(phase1Name_))
+            nuModel1_().read
-         && nuModel2_().read(subDict(phase2Name_))
+            (
+                subDict(phase1Name_ == "1" ? "phase1": phase1Name_)
+            )
+         && nuModel2_().read
+            (
+                subDict(phase2Name_ == "2" ? "phase2": phase2Name_)
+            )
         )
         {
             nuModel1_->viscosityProperties().lookup("rho") >> rho1_;

src/turbulenceModels/compressible/RAS/derivedFvPatchFields/wallFunctions/alphatWallFunctions/alphatJayatillekeWallFunction/alphatJayatillekeWallFunctionFvPatchScalarField.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
@@ -122,7 +122,7 @@ class alphatJayatillekeWallFunctionFvPatchScalarField
 public:
 
     //- Runtime type information
-    TypeName("alphatJayatillekeWallFunction");
+    TypeName("compressible::alphatJayatillekeWallFunction");
 
 
     // Constructors

src/turbulenceModels/compressible/RAS/derivedFvPatchFields/wallFunctions/alphatWallFunctions/alphatWallFunction/alphatWallFunctionFvPatchScalarField.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
@@ -105,7 +105,7 @@ class alphatWallFunctionFvPatchScalarField
 public:
 
     //- Runtime type information
-    TypeName("alphatWallFunction");
+    TypeName("compressible::alphatWallFunction");
 
 
     // Constructors

tutorials/combustion/PDRFoam/flamePropagationWithObstacles/0.org/alphat

@@ -28,19 +28,19 @@ boundaryField
     }
     ground
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     blockedFaces
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           nonuniform 0();
     }
     baffleWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           nonuniform 0();
     }

tutorials/combustion/engineFoam/kivaTest/-180/alphat

@@ -23,19 +23,19 @@ boundaryField
 {
     piston
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     liner
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     cylinderHead
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/combustion/fireFoam/les/oppositeBurningPanels/0/alphaSgs

@@ -23,7 +23,7 @@ boundaryField
 {
     ground
     {
-        type        alphatWallFunction;
+        type        compressible::alphatWallFunction;
         mut         muSgs;
         value       uniform 0;
     }
@@ -45,7 +45,7 @@ boundaryField
 
     "(region0_to.*)"
     {
-        type        alphatWallFunction;
+        type        compressible::alphatWallFunction;
         mut         muSgs;
         value       uniform 0;
     }

tutorials/combustion/fireFoam/les/oppositeBurningPanels/Allrun

@@ -9,18 +9,18 @@ application=`getApplication`
 
 runApplication blockMesh
 
-runApplication topoSet -dict cRefine.topoSetDict
+runApplication topoSet -dict system/cRefine.topoSetDict
 runApplication refineMesh -overwrite -dict system/refineMeshDict
 
 rm log.topoSet
-runApplication topoSet -dict f.topoSetDict
+runApplication topoSet -dict system/f.topoSetDict
 
 # create the pyrolysis region.
 runApplication extrudeToRegionMesh -overwrite
 
 
 rm log.topoSet
-runApplication topoSet -dict fBurner.topoSetDict
+runApplication topoSet -dict system/fBurner.topoSetDict
 
 runApplication createPatch -overwrite
 

tutorials/combustion/fireFoam/les/oppositeBurningPanels/constant/panelRegion/chemistryProperties

@@ -18,7 +18,7 @@ FoamFile
 chemistryType
 {
     chemistrySolver   ode;
-    chemistryThermo   pyrolysis;
+    chemistryThermo   pyrolysisChemistryModel;
 }
 
 chemistry           on;

tutorials/compressible/rhoLTSPimpleFoam/angledDuct/0/alphat

@@ -23,22 +23,22 @@ boundaryField
 {
     front
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     back
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     wall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     porosityWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/compressible/rhoPimpleFoam/ras/angledDuct/0/alphat

@@ -23,22 +23,22 @@ boundaryField
 {
     front
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     back
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     wall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     porosityWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/compressible/rhoPimpleFoam/ras/cavity/0/alphat

@@ -23,13 +23,13 @@ boundaryField
 {
     movingWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     fixedWalls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/compressible/rhoPimpleFoam/ras/mixerVessel2D/0/alphat

@@ -23,13 +23,13 @@ boundaryField
 {
     rotor
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     stator
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/compressible/rhoPimplecFoam/angledDuct/0/alphat

@@ -23,22 +23,22 @@ boundaryField
 {
     front
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     back
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     wall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     porosityWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/compressible/rhoPorousSimpleFoam/angledDuctImplicit/0/alphat

@@ -23,22 +23,22 @@ boundaryField
 {
     front
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     back
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     wall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     porosityWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/compressible/rhoSimpleFoam/angledDuctExplicitFixedCoeff/0/alphat

@@ -23,22 +23,22 @@ boundaryField
 {
     front
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     back
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     wall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     porosityWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/compressible/rhoSimplecFoam/squareBend/0/alphat

@@ -23,7 +23,7 @@ boundaryField
 {
     Default_Boundary_Region
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/compressible/sonicFoam/ras/nacaAirfoil/0/alphat

@@ -37,7 +37,7 @@ boundaryField
     }
     WALL10
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/compressible/sonicFoam/ras/prism/0/alphat

@@ -43,7 +43,7 @@ boundaryField
     }
     prismWall
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     defaultFaces

tutorials/heatTransfer/buoyantPimpleFoam/hotRoom/0/alphat

@@ -23,17 +23,17 @@ boundaryField
 {
     floor
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     ceiling
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     fixedWalls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
 }

tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/0/alphat

@@ -23,25 +23,25 @@ boundaryField
 {
     frontAndBack
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     topAndBottom
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     hot
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     cold
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/0.org/alphat

@@ -23,12 +23,12 @@ boundaryField
 {
     floor
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     ceiling
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/changeDictionaryDict

@@ -22,7 +22,7 @@ dictionaryReplacement
         {
             "baffle.*"
             {
-                type            alphatWallFunction;
+                type            compressible::alphatWallFunction;
                 value           uniform 0;
             }
         }

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

@@ -22,7 +22,7 @@ dictionaryReplacement
         {
             "baffle1.*"
             {
-                type            alphatWallFunction;
+                type            compressible::alphatWallFunction;
                 value           uniform 0;
             }
         }

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

@@ -22,7 +22,7 @@ dictionaryReplacement
         {
             "region0_to_.*"
             {
-                type            alphatWallFunction;
+                type            compressible::alphatWallFunction;
                 value           uniform 0;
             }
         }

tutorials/heatTransfer/buoyantSimpleFoam/circuitBoardCooling/system/createBafflesDict

@@ -80,7 +80,7 @@ baffles
 
                     alphat
                     {
-                        type            alphatWallFunction;
+                        type            compressible::alphatWallFunction;
                         value           uniform 0;
                     }
                     epsilon

tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoom/0/alphat

@@ -23,22 +23,22 @@ boundaryField
 {
     box
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     floor
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     ceiling
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     fixedWalls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
 }

tutorials/heatTransfer/buoyantSimpleFoam/hotRadiationRoomFvDOM/0/alphat

@@ -23,25 +23,25 @@ boundaryField
 {
     box
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     floor
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     ceiling
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     fixedWalls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/heatTransfer/buoyantSimpleFoam/hotRoom/0/alphat

@@ -23,19 +23,19 @@ boundaryField
 {
     floor
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     ceiling
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }
     fixedWalls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/incompressible/pisoFoam/les/motorBike/motorBike/constant/polyMesh/boundary

@@ -20,6 +20,7 @@ FoamFile
     frontAndBack
     {
         type            symmetryPlane;
+        inGroups        1(symmetryPlane);
         nFaces          320;
         startFace       3456;
     }
@@ -44,6 +45,7 @@ FoamFile
     upperWall
     {
         type            symmetryPlane;
+        inGroups        1(symmetryPlane);
         nFaces          160;
         startFace       4064;
     }

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

@@ -19,13 +19,13 @@ libs            ("libOpenFOAM.so" "libfieldFunctionObjects.so");
 
 application     simpleFoam;
 
-startFrom       latestTime;
+startFrom       startTime;
 
 startTime       0;
 
 stopAt          endTime;
 
-endTime         500;
+endTime         5;
 
 deltaT          1;
 

tutorials/incompressible/pisoFoam/les/motorBike/motorBike/system/fvSchemes

@@ -23,7 +23,7 @@ ddtSchemes
 gradSchemes
 {
     default         Gauss linear;
-    grad(U)         cellLimited Gauss linear 1;
+    grad(U)         fourth; //cellLimited Gauss linear 1;
     grad(nuTilda)   cellLimited Gauss linear 1;
 }
 

tutorials/lagrangian/LTSReactingParcelFoam/verticalChannel/0.org/alphat

@@ -46,7 +46,7 @@ boundaryField
     }
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/lagrangian/LTSReactingParcelFoam/verticalChannel/0/alphat

@@ -46,7 +46,7 @@ boundaryField
     }
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/lagrangian/coalChemistryFoam/simplifiedSiwek/0/alphat

@@ -23,17 +23,17 @@ boundaryField
 {
     top
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     bottom
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     symmetry

tutorials/lagrangian/reactingParcelFilmFoam/hotBoxes/0.org/alphat

@@ -23,7 +23,7 @@ boundaryField
 {
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/lagrangian/reactingParcelFoam/filter/0.org/alphat

@@ -23,7 +23,7 @@ boundaryField
 {
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/lagrangian/reactingParcelFoam/filter/0/alphat

@@ -23,7 +23,7 @@ boundaryField
 {
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
     inlet

tutorials/lagrangian/reactingParcelFoam/verticalChannel/0.org/alphat

@@ -46,7 +46,7 @@ boundaryField
     }
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/lagrangian/simpleReactingParcelFoam/verticalChannel/0.org/alphat

@@ -46,7 +46,7 @@ boundaryField
     }
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/lagrangian/simpleReactingParcelFoam/verticalChannel/0/alphat

@@ -46,7 +46,7 @@ boundaryField
     }
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         Prt             0.85;
         value           uniform 0;
     }

tutorials/lagrangian/sprayFoam/aachenBomb/0/alphat

@@ -23,7 +23,7 @@ boundaryField
 {
     walls
     {
-        type            alphatWallFunction;
+        type            compressible::alphatWallFunction;
         value           uniform 0;
     }
 }