From 7a945f5e9dedd4f40fb1dc36322fb12aff135b32 Mon Sep 17 00:00:00 2001
From: andy <a.heather@opencfd.co.uk>
Date: Fri, 20 Jun 2008 15:13:10 +0100
Subject: [PATCH] updated to reflect changes in turbulence models

---
 .../execFlowFunctionObjects/Make/options      |   8 +-
 .../execFlowFunctionObjects.C                 | 164 +++++-----
 .../velocityField/Pe/Make/options             |   8 +-
 .../postProcessing/velocityField/Pe/Pe.C      | 302 +++++++++---------
 src/postProcessing/forces/Make/options        |   9 +-
 src/postProcessing/forces/forces/forces.C     |  38 +--
 6 files changed, 250 insertions(+), 279 deletions(-)

diff --git a/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/Make/options b/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/Make/options
index 42c58cc6ab8..4f059b58dee 100644
--- a/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/Make/options
+++ b/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/Make/options
@@ -11,9 +11,9 @@ EXE_LIBS = \
     $(FOAM_LIBBIN)/postCalc.o \
     -lfiniteVolume \
     -lincompressibleTransportModels \
-    -lincompressibleRASmodels \
-    -lincompressibleLESmodels \
+    -lincompressibleRASModels \
+    -lincompressibleLESModels \
     -lbasicThermophysicalModels \
     -lspecie \
-    -lcompressibleRASmodels \
-    -lcompressibleLESmodels
+    -lcompressibleRASModels \
+    -lcompressibleLESModels
diff --git a/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/execFlowFunctionObjects.C b/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/execFlowFunctionObjects.C
index 43348f7ec49..5b86c71c0a4 100644
--- a/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/execFlowFunctionObjects.C
+++ b/applications/utilities/postProcessing/miscellaneous/execFlowFunctionObjects/execFlowFunctionObjects.C
@@ -39,12 +39,12 @@ Description
 
 #include "incompressible/singlePhaseTransportModel/singlePhaseTransportModel.H"
 
-#include "incompressible/RASmodel/RASmodel.H"
-#include "incompressible/LESmodel/LESmodel.H"
+#include "incompressible/RASModel/RASModel.H"
+#include "incompressible/LESModel/LESModel.H"
 
 #include "basicThermo.H"
-#include "compressible/RASmodel/RASmodel.H"
-#include "compressible/LESmodel/LESmodel.H"
+#include "compressible/RASModel/RASModel.H"
+#include "compressible/LESModel/LESModel.H"
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -127,9 +127,9 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
 
     if (phi.dimensions() == dimensionSet(0, 3, -1, 0, 0))
     {
-        IOobject turbulencePropertiesHeader
+        IOobject RASPropertiesHeader
         (
-            "turbulenceProperties",
+            "RASProperties",
             runTime.constant(),
             mesh,
             IOobject::MUST_READ,
@@ -137,45 +137,43 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
             false
         );
 
-        if (turbulencePropertiesHeader.headerOk())
+        IOobject LESPropertiesHeader
+        (
+            "RASProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        );
+
+        singlePhaseTransportModel laminarTransport(U, phi);
+
+        if (RASPropertiesHeader.headerOk())
         {
-            IOdictionary turbulenceProperties
+            IOdictionary RASProperties(RASPropertiesHeader);
+
+            autoPtr<incompressible::RASModel> RASModel
             (
-                turbulencePropertiesHeader
+                incompressible::RASModel::New
+                (
+                    U,
+                    phi,
+                    laminarTransport
+                )
             );
+            execFlowFunctionObjects(args, runTime);
+        }
+        else if (LESPropertiesHeader.headerOk())
+        {
+            IOdictionary LESProperties(LESPropertiesHeader);
 
-            singlePhaseTransportModel laminarTransport(U, phi);
+            autoPtr<incompressible::LESModel> sgsModel
+            (
+                incompressible::LESModel::New(U, phi, laminarTransport)
+            );
 
-            if (turbulenceProperties.found("RASmodel"))
-            {
-                autoPtr<incompressible::RASmodel> RASmodel
-                (
-                    incompressible::RASmodel::New
-                    (
-                        U,
-                        phi,
-                        laminarTransport
-                    )
-                );
-
-                execFlowFunctionObjects(args, runTime);
-            }
-            else if (turbulenceProperties.found("LESmodel"))
-            {
-                autoPtr<incompressible::LESmodel> sgsModel
-                (
-                    incompressible::LESmodel::New(U, phi, laminarTransport)
-                );
-
-                execFlowFunctionObjects(args, runTime);
-            }
-            else
-            {
-                FatalErrorIn(args.executable())
-                    << "Cannot find turbulence model type in "
-                    << "RASmodel dictionary"
-                    << nl << exit(FatalError);
-            }
+            execFlowFunctionObjects(args, runTime);
         }
         else
         {
@@ -191,20 +189,14 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
                 )
             );
 
-            dimensionedScalar nu
-            (
-                transportProperties.lookup("nu")
-            );
+            dimensionedScalar nu(transportProperties.lookup("nu"));
 
             execFlowFunctionObjects(args, runTime);
         }
     }
     else if (phi.dimensions() == dimensionSet(1, 0, -1, 0, 0))
     {
-        autoPtr<basicThermo> thermo
-        (
-            basicThermo::New(mesh)
-        );
+        autoPtr<basicThermo> thermo(basicThermo::New(mesh));
 
         volScalarField rho
         (
@@ -217,9 +209,9 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
             thermo->rho()
         );
 
-        IOobject turbulencePropertiesHeader
+        IOobject RASPropertiesHeader
         (
-            "turbulenceProperties",
+            "RASProperties",
             runTime.constant(),
             mesh,
             IOobject::MUST_READ,
@@ -227,44 +219,43 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
             false
         );
 
-        if (turbulencePropertiesHeader.headerOk())
+        IOobject LESPropertiesHeader
+        (
+            "LESProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        );
+
+        if (RASPropertiesHeader.headerOk())
         {
-            IOdictionary turbulenceProperties
+            IOdictionary RASProperties(RASPropertiesHeader);
+
+            autoPtr<compressible::RASModel> RASModel
             (
-                turbulencePropertiesHeader
+                compressible::RASModel::New
+                (
+                    rho,
+                    U,
+                    phi,
+                    thermo()
+                )
             );
 
-            if (turbulenceProperties.found("RASmodel"))
-            {
-                autoPtr<compressible::RASmodel> RASmodel
-                (
-                    compressible::RASmodel::New
-                    (
-                        rho,
-                        U,
-                        phi,
-                        thermo()
-                    )
-                );
-
-                execFlowFunctionObjects(args, runTime);
-            }
-            else if (turbulenceProperties.found("LESmodel"))
-            {
-                autoPtr<compressible::LESmodel> sgsModel
-                (
-                    compressible::LESmodel::New(rho, U, phi, thermo())
-                );
-
-                execFlowFunctionObjects(args, runTime);
-            }
-            else
-            {
-                FatalErrorIn(args.executable())
-                    << "Cannot find turbulence model type in "
-                    << "RASmodel dictionary"
-                    << nl << exit(FatalError);
-            }
+            execFlowFunctionObjects(args, runTime);
+        }
+        else if (LESPropertiesHeader.headerOk())
+        {
+            IOdictionary LESProperties(LESPropertiesHeader);
+
+            autoPtr<compressible::LESModel> sgsModel
+            (
+                compressible::LESModel::New(rho, U, phi, thermo())
+            );
+
+            execFlowFunctionObjects(args, runTime);
         }
         else
         {
@@ -280,10 +271,7 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
                 )
             );
 
-            dimensionedScalar mu
-            (
-                transportProperties.lookup("mu")
-            );
+            dimensionedScalar mu(transportProperties.lookup("mu"));
 
             execFlowFunctionObjects(args, runTime);
         }
diff --git a/applications/utilities/postProcessing/velocityField/Pe/Make/options b/applications/utilities/postProcessing/velocityField/Pe/Make/options
index ae1ccb29ac8..eaebf099149 100644
--- a/applications/utilities/postProcessing/velocityField/Pe/Make/options
+++ b/applications/utilities/postProcessing/velocityField/Pe/Make/options
@@ -14,9 +14,9 @@ EXE_LIBS = \
     -lfiniteVolume \
     -lmeshTools \
     -lincompressibleTransportModels \
-    -lincompressibleRASmodels \
-    -lincompressibleLESmodels \
+    -lincompressibleRASModels \
+    -lincompressibleLESModels \
     -lbasicThermophysicalModels \
     -lspecie \
-    -lcompressibleRASmodels \
-    -lcompressibleLESmodels
+    -lcompressibleRASModels \
+    -lcompressibleLESModels
diff --git a/applications/utilities/postProcessing/velocityField/Pe/Pe.C b/applications/utilities/postProcessing/velocityField/Pe/Pe.C
index b20e04e6ab2..aaf878526fe 100644
--- a/applications/utilities/postProcessing/velocityField/Pe/Pe.C
+++ b/applications/utilities/postProcessing/velocityField/Pe/Pe.C
@@ -37,11 +37,11 @@ Description
 #include "fvc.H"
 
 #include "incompressible/singlePhaseTransportModel/singlePhaseTransportModel.H"
-#include "incompressible/RASmodel/RASmodel.H"
-#include "incompressible/LESmodel/LESmodel.H"
+#include "incompressible/RASModel/RASModel.H"
+#include "incompressible/LESModel/LESModel.H"
 #include "basicThermo.H"
-#include "compressible/RASmodel/RASmodel.H"
-#include "compressible/LESmodel/LESmodel.H"
+#include "compressible/RASModel/RASModel.H"
+#include "compressible/LESModel/LESModel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -76,94 +76,94 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
             mesh
         );
 
+        IOobject RASPropertiesHeader
+        (
+            "RASProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        );
+
+        IOobject LESPropertiesHeader
+        (
+            "LESProperties",
+            runTime.constant(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        );
+
         Info<< "    Calculating Pe" << endl;
 
         if (phi.dimensions() == dimensionSet(0, 3, -1, 0, 0))
         {
-            IOobject turbulencePropertiesHeader
-            (
-                "turbulenceProperties",
-                runTime.constant(),
-                mesh,
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
-            );
-
-            if (turbulencePropertiesHeader.headerOk())
+            if (RASPropertiesHeader.headerOk())
             {
-                IOdictionary turbulenceProperties
-                (
-                    turbulencePropertiesHeader
-                );
+                IOdictionary RASProperties(RASPropertiesHeader);
 
                 singlePhaseTransportModel laminarTransport(U, phi);
 
-                if (turbulenceProperties.found("RASmodel"))
-                {
-                    autoPtr<incompressible::RASmodel> RASmodel
+                autoPtr<incompressible::RASModel> RASModel
+                (
+                    incompressible::RASModel::New
                     (
-                        incompressible::RASmodel::New
-                        (
-                            U,
-                            phi,
-                            laminarTransport
-                        )
-                    );
+                        U,
+                        phi,
+                        laminarTransport
+                    )
+                );
 
-                    PePtr.set
+                PePtr.set
+                (
+                    new surfaceScalarField
                     (
-                        new surfaceScalarField
+                        IOobject
                         (
-                            IOobject
-                            (
-                                "Pe",
-                                runTime.timeName(),
-                                mesh,
-                                IOobject::NO_READ
-                            ),
-                            mag(phi) /
-                            (
-                                mesh.magSf()
-                              * mesh.surfaceInterpolation::deltaCoeffs()
-                              * fvc::interpolate(RASmodel->nuEff())
-                            )
-                        )
-                    );
-                }
-                else if (turbulenceProperties.found("LESmodel"))
-                {
-                    autoPtr<incompressible::LESmodel> sgsModel
-                    (
-                        incompressible::LESmodel::New(U, phi, laminarTransport)
-                    );
+                            "Pe",
+                            runTime.timeName(),
+                            mesh,
+                            IOobject::NO_READ
+                        ),
+                        mag(phi)
+                       /(
+                            mesh.magSf()
+                          * mesh.surfaceInterpolation::deltaCoeffs()
+                          * fvc::interpolate(RASModel->nuEff())
+                         )
+                    )
+                );
+            }
+            else if (LESPropertiesHeader.headerOk())
+            {
+                IOdictionary LESProperties(LESPropertiesHeader);
+
+                singlePhaseTransportModel laminarTransport(U, phi);
 
-                    PePtr.set
+                autoPtr<incompressible::LESModel> sgsModel
+                (
+                    incompressible::LESModel::New(U, phi, laminarTransport)
+                );
+
+                PePtr.set
+                (
+                    new surfaceScalarField
                     (
-                        new surfaceScalarField
+                        IOobject
                         (
-                            IOobject
-                            (
-                                "Pe",
-                                runTime.timeName(),
-                                mesh,
-                                IOobject::NO_READ
-                            ),
-                            mag(phi) /
-                            (
-                                mesh.magSf()
-                              * mesh.surfaceInterpolation::deltaCoeffs()
-                              * fvc::interpolate(sgsModel->nuEff())
-                            )
+                            "Pe",
+                            runTime.timeName(),
+                            mesh,
+                            IOobject::NO_READ
+                        ),
+                        mag(phi)
+                       /(
+                            mesh.magSf()
+                          * mesh.surfaceInterpolation::deltaCoeffs()
+                          * fvc::interpolate(sgsModel->nuEff())
                         )
-                    );
-                }
-                else
-                {
-                    FatalErrorIn(args.executable())
-                        << "Cannot find turbulence model type in "
-                        "RASmodel dictionary"
-                        << exit(FatalError);
-                }
+                    )
+                );
             }
             else
             {
@@ -179,10 +179,7 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
                     )
                 );
 
-                dimensionedScalar nu
-                (
-                    transportProperties.lookup("nu")
-                );
+                dimensionedScalar nu(transportProperties.lookup("nu"));
 
                 PePtr.set
                 (
@@ -203,26 +200,11 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
         }
         else if (phi.dimensions() == dimensionSet(1, 0, -1, 0, 0))
         {
-            IOobject turbulencePropertiesHeader
-            (
-                "turbulenceProperties",
-                runTime.constant(),
-                mesh,
-                IOobject::MUST_READ,
-                IOobject::NO_WRITE
-            );
-
-            if (turbulencePropertiesHeader.headerOk())
+            if (RASPropertiesHeader.headerOk())
             {
-                IOdictionary turbulenceProperties
-                (
-                    turbulencePropertiesHeader
-                );
+                IOdictionary RASProperties(RASPropertiesHeader);
 
-                autoPtr<basicThermo> thermo
-                (
-                    basicThermo::New(mesh)
-                );
+                autoPtr<basicThermo> thermo(basicThermo::New(mesh));
 
                 volScalarField rho
                 (
@@ -235,73 +217,78 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
                     thermo->rho()
                 );
 
-                if (turbulenceProperties.found("RASmodel"))
-                {
-                    autoPtr<compressible::RASmodel> RASmodel
+                autoPtr<compressible::RASModel> RASModel
+                (
+                    compressible::RASModel::New
                     (
-                        compressible::RASmodel::New
-                        (
-                            rho,
-                            U,
-                            phi,
-                            thermo()
-                        )
-                    );
+                        rho,
+                        U,
+                        phi,
+                        thermo()
+                    )
+                );
 
-                    PePtr.set
+                PePtr.set
+                (
+                    new surfaceScalarField
                     (
-                        new surfaceScalarField
+                        IOobject
                         (
-                            IOobject
-                            (
-                                "Pe",
-                                runTime.timeName(),
-                                mesh,
-                                IOobject::NO_READ
-                            ),
-                            mag(phi) /
-                            (
-                                mesh.magSf()
-                              * mesh.surfaceInterpolation::deltaCoeffs()
-                              * fvc::interpolate(RASmodel->muEff())
-                            )
+                            "Pe",
+                            runTime.timeName(),
+                            mesh,
+                            IOobject::NO_READ
+                        ),
+                        mag(phi)
+                       /(
+                            mesh.magSf()
+                          * mesh.surfaceInterpolation::deltaCoeffs()
+                          * fvc::interpolate(RASModel->muEff())
                         )
-                    );
-                }
-                else if (turbulenceProperties.found("LESmodel"))
-                {
-                    autoPtr<compressible::LESmodel> sgsModel
+                    )
+                );
+            }
+            else if (LESPropertiesHeader.headerOk())
+            {
+                IOdictionary LESProperties(LESPropertiesHeader);
+
+                autoPtr<basicThermo> thermo(basicThermo::New(mesh));
+
+                volScalarField rho
+                (
+                    IOobject
                     (
-                        compressible::LESmodel::New(rho, U, phi, thermo())
-                    );
+                        "rho",
+                        runTime.timeName(),
+                        mesh
+                    ),
+                    thermo->rho()
+                );
 
-                    PePtr.set
+                autoPtr<compressible::LESModel> sgsModel
+                (
+                    compressible::LESModel::New(rho, U, phi, thermo())
+                );
+
+                PePtr.set
+                (
+                    new surfaceScalarField
                     (
-                        new surfaceScalarField
+                        IOobject
                         (
-                            IOobject
-                            (
-                                "Pe",
-                                runTime.timeName(),
-                                mesh,
-                                IOobject::NO_READ
-                            ),
-                            mag(phi) /
-                            (
-                                mesh.magSf()
-                              * mesh.surfaceInterpolation::deltaCoeffs()
-                              * fvc::interpolate(sgsModel->muEff())
-                            )
+                            "Pe",
+                            runTime.timeName(),
+                            mesh,
+                            IOobject::NO_READ
+                        ),
+                        mag(phi)
+                       /(
+                            mesh.magSf()
+                          * mesh.surfaceInterpolation::deltaCoeffs()
+                          * fvc::interpolate(sgsModel->muEff())
                         )
-                    );
-                }
-                else
-                {
-                    FatalErrorIn(args.executable())
-                        << "Cannot find turbulence model type in"
-                        "RASmodel dictionary"
-                        << exit(FatalError);
-                }
+                    )
+                );
             }
             else
             {
@@ -317,10 +304,7 @@ void Foam::calc(const argList& args, const Time& runTime, const fvMesh& mesh)
                     )
                 );
 
-                dimensionedScalar mu
-                (
-                    transportProperties.lookup("mu")
-                );
+                dimensionedScalar mu(transportProperties.lookup("mu"));
 
                 PePtr.set
                 (
diff --git a/src/postProcessing/forces/Make/options b/src/postProcessing/forces/Make/options
index 844ccb0d6a4..60030515780 100644
--- a/src/postProcessing/forces/Make/options
+++ b/src/postProcessing/forces/Make/options
@@ -12,13 +12,18 @@ LIB_LIBS = \
     -lfiniteVolume \
     -lmeshTools \
     -lincompressibleTransportModels \
+<<<<<<< HEAD:src/postProcessing/forces/Make/options
 <<<<<<< HEAD:src/postProcessing/forces/Make/options
     -lincompressibleRASModels \
 =======
     -lincompressibleRASmodels \
 >>>>>>> update to reflect RASmodel changes:src/postProcessing/forces/Make/options
     -lincompressibleLESmodels \
+=======
+    -lincompressibleRASModels \
+    -lincompressibleLESModels \
+>>>>>>> updated to reflect changes in turbulence models:src/postProcessing/forces/Make/options
     -lbasicThermophysicalModels \
     -lspecie \
-    -lcompressibleRASmodels \
-    -lcompressibleLESmodels
+    -lcompressibleRASModels \
+    -lcompressibleLESModels
diff --git a/src/postProcessing/forces/forces/forces.C b/src/postProcessing/forces/forces/forces.C
index 8554c33a9c5..23abe6861af 100644
--- a/src/postProcessing/forces/forces/forces.C
+++ b/src/postProcessing/forces/forces/forces.C
@@ -30,11 +30,11 @@ License
 #include "Time.H"
 
 #include "incompressible/singlePhaseTransportModel/singlePhaseTransportModel.H"
-#include "incompressible/RASmodel/RASmodel.H"
-#include "incompressible/LESmodel/LESmodel.H"
+#include "incompressible/RASModel/RASModel.H"
+#include "incompressible/LESModel/LESModel.H"
 #include "basicThermo.H"
-#include "compressible/RASmodel/RASmodel.H"
-#include "compressible/LESmodel/LESmodel.H"
+#include "compressible/RASModel/RASModel.H"
+#include "compressible/LESModel/LESModel.H"
 
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -48,37 +48,31 @@ namespace Foam
 
 Foam::tmp<Foam::volSymmTensorField> Foam::forces::devRhoReff() const
 {
-    if
-    (
-        obr_.foundObject<compressible::RASmodel>("turbulenceProperties")
-    )
+    if (obr_.foundObject<compressible::RASModel>("RASProperties"))
     {
-        const compressible::RASmodel& ras
-            = obr_.lookupObject<compressible::RASmodel>
-            ("turbulenceProperties");
+        const compressible::RASModel& ras
+            = obr_.lookupObject<compressible::RASModel>("RASProperties");
 
         return ras.devRhoReff();
     }
-    else if (obr_.foundObject<incompressible::RASmodel>("turbulenceProperties"))
+    else if (obr_.foundObject<incompressible::RASModel>("RASProperties"))
     {
-        const incompressible::RASmodel& ras
-            = obr_.lookupObject<incompressible::RASmodel>
-            ("turbulenceProperties");
+        const incompressible::RASModel& ras
+            = obr_.lookupObject<incompressible::RASModel>("RASProperties");
 
         return rhoRef_*ras.devReff();
     }
-    else if (obr_.foundObject<compressible::LESmodel>("turbulenceProperties"))
+    else if (obr_.foundObject<compressible::LESModel>("LESProperties"))
     {
-        const compressible::LESmodel& les =
-        obr_.lookupObject<compressible::LESmodel>
-        ("turbulenceProperties");
+        const compressible::LESModel& les =
+        obr_.lookupObject<compressible::LESModel>("LESProperties");
 
         return les.devRhoBeff();
     }
-    else if (obr_.foundObject<incompressible::LESmodel>("turbulenceProperties"))
+    else if (obr_.foundObject<incompressible::LESModel>("LESProperties"))
     {
-        const incompressible::LESmodel& les
-            = obr_.lookupObject<incompressible::LESmodel>("turbulenceProperties");
+        const incompressible::LESModel& les
+            = obr_.lookupObject<incompressible::LESModel>("LESProperties");
 
         return rhoRef_*les.devBeff();
     }
-- 
GitLab