twoPhaseEulerFoam: Move the residualAlpha used for drag into the phaseModel

This is necessary to guarantee consistency between the residualAlpha
used for drag and buoyancy in a multi-phase system

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/TomiyamaAspectRatio/TomiyamaAspectRatio.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "TomiyamaAspectRatio.H"
-#include "orderedPhasePair.H"
+#include "phasePair.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -49,7 +49,7 @@ namespace aspectRatioModels
 Foam::aspectRatioModels::TomiyamaAspectRatio::TomiyamaAspectRatio
 (
     const dictionary& dict,
-    const orderedPhasePair& pair
+    const phasePair& pair
 )
 :
     VakhrushevEfremov(dict, pair),

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/TomiyamaAspectRatio/TomiyamaAspectRatio.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -74,7 +74,7 @@ public:
         TomiyamaAspectRatio
         (
             const dictionary& dict,
-            const orderedPhasePair& pair
+            const phasePair& pair
         );
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/VakhrushevEfremov/VakhrushevEfremov.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "VakhrushevEfremov.H"
-#include "orderedPhasePair.H"
+#include "phasePair.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -33,7 +33,7 @@ namespace Foam
 {
 namespace aspectRatioModels
 {
-    defineTypeNameAndDebug(VakhrushevEfremov, 0); 
+    defineTypeNameAndDebug(VakhrushevEfremov, 0);
     addToRunTimeSelectionTable
     (
         aspectRatioModel,
@@ -49,7 +49,7 @@ namespace aspectRatioModels
 Foam::aspectRatioModels::VakhrushevEfremov::VakhrushevEfremov
 (
     const dictionary& dict,
-    const orderedPhasePair& pair
+    const phasePair& pair
 )
 :
     aspectRatioModel(dict, pair)

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/VakhrushevEfremov/VakhrushevEfremov.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -73,7 +73,7 @@ public:
         VakhrushevEfremov
         (
             const dictionary& dict,
-            const orderedPhasePair& pair
+            const phasePair& pair
         );
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/Wellek/Wellek.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "Wellek.H"
-#include "orderedPhasePair.H"
+#include "phasePair.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -49,7 +49,7 @@ namespace aspectRatioModels
 Foam::aspectRatioModels::Wellek::Wellek
 (
     const dictionary& dict,
-    const orderedPhasePair& pair
+    const phasePair& pair
 )
 :
     aspectRatioModel(dict, pair)

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/Wellek/Wellek.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -79,7 +79,7 @@ public:
         Wellek
         (
             const dictionary& dict,
-            const orderedPhasePair& pair
+            const phasePair& pair
         );
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/aspectRatioModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "aspectRatioModel.H"
-#include "orderedPhasePair.H"
+#include "phasePair.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -40,7 +40,7 @@ namespace Foam
 Foam::aspectRatioModel::aspectRatioModel
 (
     const dictionary& dict,
-    const orderedPhasePair& pair
+    const phasePair& pair
 )
 :
     pair_(pair)

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/aspectRatioModel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -44,7 +44,7 @@ SourceFiles
 namespace Foam
 {
 
-class orderedPhasePair;
+class phasePair;
 
 /*---------------------------------------------------------------------------*\
                            Class aspectRatioModel Declaration
@@ -57,7 +57,7 @@ protected:
     // Protected data
 
         //- Phase pair
-        const orderedPhasePair& pair_;
+        const phasePair& pair_;
 
 
 public:
@@ -74,7 +74,7 @@ public:
         dictionary,
         (
             const dictionary& dict,
-            const orderedPhasePair& pair
+            const phasePair& pair
         ),
         (dict, pair)
     );
@@ -86,7 +86,7 @@ public:
         aspectRatioModel
         (
             const dictionary& dict,
-            const orderedPhasePair& pair
+            const phasePair& pair
         );
 
 
@@ -99,7 +99,7 @@ public:
         static autoPtr<aspectRatioModel> New
         (
             const dictionary& dict,
-            const orderedPhasePair& pair
+            const phasePair& pair
         );
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/aspectRatioModel/newAspectRatioModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,15 +24,15 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "aspectRatioModel.H"
-#include "orderedPhasePair.H"
+#include "phasePair.H"
 
 // * * * * * * * * * * * * * * * * Selector  * * * * * * * * * * * * * * * * //
 
-Foam::autoPtr<Foam::aspectRatioModel >
+Foam::autoPtr<Foam::aspectRatioModel>
 Foam::aspectRatioModel::New
 (
     const dictionary& dict,
-    const orderedPhasePair& pair
+    const phasePair& pair
 )
 {
     word aspectRatioModelType(dict.lookup("type"));

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "constantAspectRatio.H"
-#include "orderedPhasePair.H"
+#include "phasePair.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -33,7 +33,7 @@ namespace Foam
 {
 namespace aspectRatioModels
 {
-    defineTypeNameAndDebug(constantAspectRatio, 0); 
+    defineTypeNameAndDebug(constantAspectRatio, 0);
     addToRunTimeSelectionTable
     (
         aspectRatioModel,
@@ -49,7 +49,7 @@ namespace aspectRatioModels
 Foam::aspectRatioModels::constantAspectRatio::constantAspectRatio
 (
     const dictionary& dict,
-    const orderedPhasePair& pair
+    const phasePair& pair
 )
 :
     aspectRatioModel(dict, pair),

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -70,7 +70,7 @@ public:
         constantAspectRatio
         (
             const dictionary& dict,
-            const orderedPhasePair& pair
+            const phasePair& pair
         );
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/Ergun/Ergun.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,7 +34,7 @@ namespace Foam
 namespace dragModels
 {
     defineTypeNameAndDebug(Ergun, 0);
-    addToRunTimeSelectionTable(dragModel, Ergun, dictionary); 
+    addToRunTimeSelectionTable(dragModel, Ergun, dictionary);
 }
 }
 
@@ -66,8 +66,11 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::Ergun::CdRe() const
         (4/3)
        *(
             150
-           *max(scalar(1) - pair_.continuous(), residualAlpha_)
+           *max
-           /max(pair_.continuous(), residualAlpha_)
+            (
+                scalar(1) - pair_.continuous(),
+                pair_.continuous().residualAlpha()
+            )/max(pair_.continuous(), pair_.continuous().residualAlpha())
           + 1.75
            *pair_.Re()
         );

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/Gibilaro/Gibilaro.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,7 +34,7 @@ namespace Foam
 namespace dragModels
 {
     defineTypeNameAndDebug(Gibilaro, 0);
-    addToRunTimeSelectionTable(dragModel, Gibilaro, dictionary); 
+    addToRunTimeSelectionTable(dragModel, Gibilaro, dictionary);
 }
 }
 
@@ -62,12 +62,15 @@ Foam::dragModels::Gibilaro::~Gibilaro()
 
 Foam::tmp<Foam::volScalarField> Foam::dragModels::Gibilaro::CdRe() const
 {
-    volScalarField alpha2(max(scalar(1) - pair_.dispersed(), residualAlpha_));
+    volScalarField alpha2
+    (
+        max(scalar(1) - pair_.dispersed(), pair_.continuous().residualAlpha())
+    );
 
     return
         (4/3)
        *(17.3/alpha2 + 0.336*pair_.Re())
-       *max(pair_.continuous(), residualAlpha_)
+       *max(pair_.continuous(), pair_.continuous().residualAlpha())
        *pow(alpha2, -2.8);
 }
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/GidaspowSchillerNaumann/GidaspowSchillerNaumann.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -64,8 +64,13 @@ Foam::dragModels::GidaspowSchillerNaumann::~GidaspowSchillerNaumann()
 Foam::tmp<Foam::volScalarField>
 Foam::dragModels::GidaspowSchillerNaumann::CdRe() const
 {
-    volScalarField alpha2(max(scalar(1) - pair_.dispersed(), residualAlpha_));
+    volScalarField alpha2
+    (
+        max(scalar(1) - pair_.dispersed(), pair_.continuous().residualAlpha())
+    );
+
     volScalarField Re(alpha2*pair_.Re());
+
     volScalarField CdsRe
     (
         neg(Re - 1000)*24.0*(1.0 + 0.15*pow(Re, 0.687))/alpha2
@@ -75,7 +80,7 @@ Foam::dragModels::GidaspowSchillerNaumann::CdRe() const
     return
         CdsRe
        *pow(alpha2, -2.65)
-       *max(pair_.continuous(), residualAlpha_);
+       *max(pair_.continuous(), pair_.continuous().residualAlpha());
 }
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/SyamlalOBrien/SyamlalOBrien.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,7 +34,7 @@ namespace Foam
 namespace dragModels
 {
     defineTypeNameAndDebug(SyamlalOBrien, 0);
-    addToRunTimeSelectionTable(dragModel, SyamlalOBrien, dictionary); 
+    addToRunTimeSelectionTable(dragModel, SyamlalOBrien, dictionary);
 }
 }
 
@@ -62,7 +62,11 @@ Foam::dragModels::SyamlalOBrien::~SyamlalOBrien()
 
 Foam::tmp<Foam::volScalarField> Foam::dragModels::SyamlalOBrien::CdRe() const
 {
-    volScalarField alpha2(max(scalar(1) - pair_.dispersed(), residualAlpha_));
+    volScalarField alpha2
+    (
+        max(scalar(1) - pair_.dispersed(), pair_.continuous().residualAlpha())
+    );
+
     volScalarField A(pow(alpha2, 4.14));
     volScalarField B
     (
@@ -81,7 +85,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::SyamlalOBrien::CdRe() const
 
     return
         CdsRe
-       *max(pair_.continuous(), residualAlpha_)
+       *max(pair_.continuous(), pair_.continuous().residualAlpha())
        /sqr(Vr);
 }
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/WenYu/WenYu.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,7 +34,7 @@ namespace Foam
 namespace dragModels
 {
     defineTypeNameAndDebug(WenYu, 0);
-    addToRunTimeSelectionTable(dragModel, WenYu, dictionary); 
+    addToRunTimeSelectionTable(dragModel, WenYu, dictionary);
 }
 }
 
@@ -63,7 +63,11 @@ Foam::dragModels::WenYu::~WenYu()
 
 Foam::tmp<Foam::volScalarField> Foam::dragModels::WenYu::CdRe() const
 {
-    volScalarField alpha2(max(scalar(1) - pair_.dispersed(), residualAlpha_));
+    volScalarField alpha2
+    (
+        max(scalar(1) - pair_.dispersed(), pair_.continuous().residualAlpha())
+    );
+
     volScalarField Re(pair_.Re());
     volScalarField CdsRe
     (
@@ -74,7 +78,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::WenYu::CdRe() const
     return
         CdsRe
        *pow(alpha2, -2.65)
-       *max(pair_.continuous(), residualAlpha_);
+       *max(pair_.continuous(), pair_.continuous().residualAlpha());
 }
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/dragModel/dragModel.C

@@ -90,8 +90,7 @@ Foam::dragModel::dragModel
             dict.subDict("swarmCorrection"),
             pair
         )
-    ),
+    )
-    residualAlpha_("residualAlpha", dimless, dict.lookup("residualAlpha"))
 {}
 
 
@@ -117,15 +116,18 @@ Foam::tmp<Foam::volScalarField> Foam::dragModel::Ki() const
 
 Foam::tmp<Foam::volScalarField> Foam::dragModel::K() const
 {
-    return max(pair_.dispersed(), residualAlpha_)*Ki();
+    return max(pair_.dispersed(), pair_.dispersed().residualAlpha())*Ki();
 }
 
 
 Foam::tmp<Foam::surfaceScalarField> Foam::dragModel::Kf() const
 {
     return
-        max(fvc::interpolate(pair_.dispersed()), residualAlpha_)
+        max
-       *fvc::interpolate(Ki());
+        (
+            fvc::interpolate(pair_.dispersed()),
+            pair_.dispersed().residualAlpha()
+        )*fvc::interpolate(Ki());
 }
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/dragModel/dragModel.H

@@ -65,9 +65,6 @@ protected:
         //- Swarm correction
         autoPtr<swarmCorrection> swarmCorrection_;
 
-        //- Residual phase fraction
-        const dimensionedScalar residualAlpha_;
-
 
 public:
 
@@ -130,13 +127,6 @@ public:
 
     // Member Functions
 
-        //- Return the residual phase-fraction
-        //  used to stabilize the phase momentum as the phase-fraction -> 0
-        const dimensionedScalar& residualAlpha() const
-        {
-            return residualAlpha_;
-        }
-
         //- Drag coefficient
         virtual tmp<volScalarField> CdRe() const = 0;
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/dragModels/segregated/segregated.C

@@ -112,7 +112,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::K() const
        /max
         (
             alpha1 + alpha2,
-            residualAlpha_
+            pair_.phase1().residualAlpha() + pair_.phase2().residualAlpha()
         )
     );
     volScalarField magGradI
@@ -120,7 +120,7 @@ Foam::tmp<Foam::volScalarField> Foam::dragModels::segregated::K() const
         max
         (
             mag(fvc::grad(I)),
-            residualAlpha_/L
+            (pair_.phase1().residualAlpha() + pair_.phase2().residualAlpha())/L
         )
     );
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/heatTransferModels/RanzMarshall/RanzMarshall.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,8 @@ Class
     Foam::heatTransferModels::RanzMarshall
 
 Description
+    Ranz-Marshall correlation for turbulent heat transfer from the surface of a
+    sphere to the surrounding fluid.
 
 SourceFiles
     RanzMarshall.C

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/heatTransferModels/heatTransferModel/heatTransferModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -46,7 +46,16 @@ Foam::heatTransferModel::heatTransferModel
 )
 :
     pair_(pair),
-    residualAlpha_("residualAlpha", dimless, dict.lookup("residualAlpha"))
+    residualAlpha_
+    (
+        "residualAlpha",
+        dimless,
+        dict.lookupOrDefault<scalar>
+        (
+            "residualAlpha",
+            pair_.dispersed().residualAlpha().value()
+        )
+    )
 {}
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/swarmCorrections/TomiyamaSwarm/TomiyamaSwarm.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2014-2015 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,7 +33,7 @@ namespace Foam
 {
 namespace swarmCorrections
 {
-    defineTypeNameAndDebug(TomiyamaSwarm, 0); 
+    defineTypeNameAndDebug(TomiyamaSwarm, 0);
     addToRunTimeSelectionTable
     (
         swarmCorrection,
@@ -53,7 +53,16 @@ Foam::swarmCorrections::TomiyamaSwarm::TomiyamaSwarm
 )
 :
     swarmCorrection(dict, pair),
-    residualAlpha_("residualAlpha", dimless, dict.lookup("residualAlpha")),
+    residualAlpha_
+    (
+        "residualAlpha",
+        dimless,
+        dict.lookupOrDefault<scalar>
+        (
+            "residualAlpha",
+            pair_.dispersed().residualAlpha().value()
+        )
+    ),
     l_("l", dimless, dict.lookup("l"))
 {}
 
@@ -69,7 +78,7 @@ Foam::swarmCorrections::TomiyamaSwarm::~TomiyamaSwarm()
 Foam::tmp<Foam::volScalarField>
 Foam::swarmCorrections::TomiyamaSwarm::Cs() const
 {
-    return 
+    return
         pow(max(this->pair_.continuous(), residualAlpha_), scalar(3) - 2*l_);
 }
 

applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/turbulentDispersionModels/Burns/Burns.C

@@ -57,7 +57,16 @@ Foam::turbulentDispersionModels::Burns::Burns
 :
     turbulentDispersionModel(dict, pair),
     sigma_("sigma", dimless, dict.lookup("sigma")),
-    residualAlpha_("residualAlpha", dimless, dict.lookup("residualAlpha"))
+    residualAlpha_
+    (
+        "residualAlpha",
+        dimless,
+        dict.lookupOrDefault<scalar>
+        (
+            "residualAlpha",
+            pair_.dispersed().residualAlpha().value()
+        )
+    )
 {}
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/pU/pEqn.H

@@ -7,7 +7,7 @@ volScalarField rAU1
     1.0
    /(
         U1Eqn.A()
-      + max(fluid.residualAlpha(phase1) - alpha1, scalar(0))
+      + max(phase1.residualAlpha() - alpha1, scalar(0))
        *rho1/runTime.deltaT()
     )
 );
@@ -17,18 +17,18 @@ volScalarField rAU2
     1.0
    /(
         U2Eqn.A()
-      + max(fluid.residualAlpha(phase2) - alpha2, scalar(0))
+      + max(phase2.residualAlpha() - alpha2, scalar(0))
        *rho2/runTime.deltaT()
     )
 );
 
 surfaceScalarField alpharAUf1
 (
-    fvc::interpolate(max(alpha1, fluid.residualAlpha(phase1))*rAU1)
+    fvc::interpolate(max(alpha1, phase1.residualAlpha())*rAU1)
 );
 surfaceScalarField alpharAUf2
 (
-    fvc::interpolate(max(alpha2, fluid.residualAlpha(phase2))*rAU2)
+    fvc::interpolate(max(alpha2, phase2.residualAlpha())*rAU2)
 );
 
 // Turbulent diffusion, particle-pressure, lift and wall-lubrication fluxes
@@ -104,7 +104,7 @@ while (pimple.correct())
         rAU1
        *(
             U1Eqn.H()
-          + max(fluid.residualAlpha(phase1) - alpha1, scalar(0))
+          + max(phase1.residualAlpha() - alpha1, scalar(0))
            *rho1*U1.oldTime()/runTime.deltaT()
         );
 
@@ -117,7 +117,7 @@ while (pimple.correct())
         rAU2
        *(
             U2Eqn.H()
-         +  max(fluid.residualAlpha(phase2) - alpha2, scalar(0))
+         +  max(phase2.residualAlpha() - alpha2, scalar(0))
            *rho2*U2.oldTime()/runTime.deltaT()
         );
 
@@ -145,7 +145,7 @@ while (pimple.correct())
        *(
            ghSnGradRho
          - alphaf1*fvc::interpolate(rho2 - rho1)*(g & mesh.Sf())
-       )
+        )
     );
 
 

applications/solvers/multiphase/twoPhaseEulerFoam/pUf/pEqn.H

@@ -6,7 +6,7 @@ surfaceScalarField alphaRhof10
     "alphaRhof10",
     fvc::interpolate
     (
-        max(alpha1.oldTime(), fluid.residualAlpha(phase1))
+        max(alpha1.oldTime(), phase1.residualAlpha())
        *rho1.oldTime()
     )
 );
@@ -16,7 +16,7 @@ surfaceScalarField alphaRhof20
     "alphaRhof20",
     fvc::interpolate
     (
-        max(alpha2.oldTime(), fluid.residualAlpha(phase2))
+        max(alpha2.oldTime(), phase2.residualAlpha())
        *rho2.oldTime()
     )
 );
@@ -105,13 +105,13 @@ while (pimple.correct())
     surfaceScalarField alpharAUf1
     (
         IOobject::groupName("alpharAUf", phase1.name()),
-        max(alphaf1, fluid.residualAlpha(phase1))*rAUf1
+        max(alphaf1, phase1.residualAlpha())*rAUf1
     );
 
     surfaceScalarField alpharAUf2
     (
         IOobject::groupName("alpharAUf", phase2.name()),
-        max(alphaf2, fluid.residualAlpha(phase2))*rAUf2
+        max(alphaf2, phase2.residualAlpha())*rAUf2
     );
 
     volScalarField rho("rho", fluid.rho());

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/phaseModel/phaseModel.C

@@ -36,6 +36,7 @@ License
 #include "partialSlipFvPatchFields.H"
 #include "surfaceInterpolate.H"
 
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::phaseModel::phaseModel
@@ -64,6 +65,12 @@ Foam::phaseModel::phaseModel
     (
         phaseProperties.subDict(name_)
     ),
+    residualAlpha_
+    (
+        "residualAlpha",
+        dimless,
+        fluid.subDict(phaseName).lookup("residualAlpha")
+    ),
     alphaMax_(phaseDict_.lookupOrDefault("alphaMax", 1.0)),
     thermo_(rhoThermo::New(fluid.mesh(), name_)),
     U_
@@ -212,23 +219,27 @@ Foam::tmp<Foam::volScalarField> Foam::phaseModel::d() const
     return dPtr_().d();
 }
 
+
 Foam::PhaseCompressibleTurbulenceModel<Foam::phaseModel>&
 Foam::phaseModel::turbulence()
 {
     return turbulence_();
 }
 
+
 const Foam::PhaseCompressibleTurbulenceModel<Foam::phaseModel>&
 Foam::phaseModel::turbulence() const
 {
     return turbulence_();
 }
 
+
 void Foam::phaseModel::correct()
 {
     return dPtr_->correct();
 }
 
+
 bool Foam::phaseModel::read(const dictionary& phaseProperties)
 {
     phaseDict_ = phaseProperties.subDict(name_);

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/phaseModel/phaseModel.H

@@ -71,6 +71,10 @@ class phaseModel
 
         dictionary phaseDict_;
 
+        //- Return the residual phase-fraction for given phase
+        //  Used to stabilize the phase momentum as the phase-fraction -> 0
+        dimensionedScalar residualAlpha_;
+
         //- Optional maximum phase-fraction (e.g. packing limit)
         scalar alphaMax_;
 
@@ -129,6 +133,13 @@ public:
         //- Return the other phase in this two-phase system
         const phaseModel& otherPhase() const;
 
+        //- Return the residual phase-fraction for given phase
+        //  Used to stabilize the phase momentum as the phase-fraction -> 0
+        const dimensionedScalar& residualAlpha() const
+        {
+            return residualAlpha_;
+        }
+
         //- Optional maximum phase-fraction (e.g. packing limit)
         //  Defaults to 1
         scalar alphaMax() const

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/twoPhaseSystem.C

@@ -48,14 +48,6 @@ License
 #include "HashPtrTable.H"
 
 
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-Foam::dimensionedScalar Foam::twoPhaseSystem::zeroResidualAlpha_
-(
-    "zeroResidualAlpha", dimless, 0
-);
-
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::twoPhaseSystem::twoPhaseSystem
@@ -588,20 +580,6 @@ bool Foam::twoPhaseSystem::read()
 }
 
 
-const Foam::dimensionedScalar&
-Foam::twoPhaseSystem::residualAlpha(const phaseModel& phase) const
-{
-    if (drag_->hasModel(phase))
-    {
-        return drag_->phaseModel(phase).residualAlpha();
-    }
-    else
-    {
-        return zeroResidualAlpha_;
-    }
-}
-
-
 const Foam::dragModel& Foam::twoPhaseSystem::drag(const phaseModel& phase) const
 {
     return drag_->phaseModel(phase);

applications/solvers/multiphase/twoPhaseEulerFoam/twoPhaseSystem/twoPhaseSystem.H

@@ -116,9 +116,6 @@ class twoPhaseSystem
         autoPtr<BlendedInterfacialModel<turbulentDispersionModel> >
             turbulentDispersion_;
 
-        //- Default residual alpha (0)
-        static dimensionedScalar zeroResidualAlpha_;
-
 
     // Private member functions
 
@@ -185,13 +182,6 @@ public:
 
         // Access
 
-            //- Return the residual phase-fraction for given phase
-            //  Used to stabilize the phase momentum as the phase-fraction -> 0
-            const dimensionedScalar& residualAlpha
-            (
-                const phaseModel& phase
-            ) const;
-
             //- Return the drag model for the given phase
             const dragModel& drag(const phaseModel& phase) const;
 

tutorials/multiphase/twoPhaseEulerFoam/LES/bubbleColumn/constant/phaseProperties

@@ -25,6 +25,8 @@ air
         d0              3e-3;
         p0              1e5;
     }
+
+    residualAlpha   1e-6;
 }
 
 water
@@ -34,6 +36,8 @@ water
     {
         d               1e-4;
     }
+
+    residualAlpha   1e-6;
 }
 
 blending
@@ -73,7 +77,6 @@ drag
     (air in water)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -84,7 +87,6 @@ drag
     (water in air)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -95,7 +97,6 @@ drag
     (air and water)
     {
         type            segregated;
-        residualAlpha   1e-6;
         m               0.5;
         n               8;
         swarmCorrection

tutorials/multiphase/twoPhaseEulerFoam/RAS/bubbleColumn/constant/phaseProperties

@@ -25,6 +25,8 @@ air
         d0              3e-3;
         p0              1e5;
     }
+
+    residualAlpha   1e-6;
 }
 
 water
@@ -34,6 +36,8 @@ water
     {
         d               1e-4;
     }
+
+    residualAlpha   1e-6;
 }
 
 blending
@@ -73,7 +77,6 @@ drag
     (air in water)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -84,7 +87,6 @@ drag
     (water in air)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -95,7 +97,6 @@ drag
     (air and water)
     {
         type            segregated;
-        residualAlpha   1e-6;
         m               0.5;
         n               8;
         swarmCorrection

tutorials/multiphase/twoPhaseEulerFoam/RAS/fluidisedBed/constant/phaseProperties

@@ -19,22 +19,29 @@ phases (particles air);
 
 particles
 {
+    residualAlpha   1e-6;
+
     diameterModel constant;
     constantCoeffs
     {
         d               3e-4;
     }
 
-    alphaMax 0.62;
+    alphaMax        0.62;
+    residualAlpha   1e-6;
 }
 
 air
 {
+    residualAlpha   0;
+
     diameterModel constant;
     constantCoeffs
     {
         d               1;
     }
+
+    residualAlpha   0;
 }
 
 blending
@@ -60,7 +67,6 @@ drag
     (particles in air)
     {
         type            GidaspowErgunWenYu;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {

tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumn/constant/phaseProperties

@@ -25,6 +25,8 @@ air
         d0              3e-3;
         p0              1e5;
     }
+
+    residualAlpha   1e-6;
 }
 
 water
@@ -34,6 +36,8 @@ water
     {
         d               1e-4;
     }
+
+    residualAlpha   1e-6;
 }
 
 blending
@@ -73,7 +77,6 @@ drag
     (air in water)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -84,7 +87,6 @@ drag
     (water in air)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {

tutorials/multiphase/twoPhaseEulerFoam/laminar/bubbleColumnIATE/constant/phaseProperties

@@ -46,6 +46,8 @@ air
             }
         );
     }
+
+    residualAlpha   1e-6;
 }
 
 water
@@ -55,6 +57,8 @@ water
     {
         d               1e-4;
     }
+
+    residualAlpha   1e-6;
 }
 
 blending
@@ -94,7 +98,6 @@ drag
     (air in water)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -105,7 +108,6 @@ drag
     (water in air)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -116,7 +118,6 @@ drag
     (air and water)
     {
         type            segregated;
-        residualAlpha   1e-6;
         m               0.5;
         n               8;
         swarmCorrection

tutorials/multiphase/twoPhaseEulerFoam/laminar/fluidisedBed/constant/phaseProperties

@@ -25,7 +25,8 @@ particles
         d               3e-4;
     }
 
-    alphaMax 0.62;
+    alphaMax        0.62;
+    residualAlpha   1e-6;
 }
 
 air
@@ -35,6 +36,8 @@ air
     {
         d               1;
     }
+
+    residualAlpha   0;
 }
 
 blending
@@ -60,7 +63,6 @@ drag
     (particles in air)
     {
         type            GidaspowErgunWenYu;
-        residualAlpha   1e-6;
         residualRe      1e-3;
         swarmCorrection
         {

tutorials/multiphase/twoPhaseEulerFoam/laminar/injection/constant/phaseProperties

@@ -25,6 +25,8 @@ air
         d0              3e-3;
         p0              1e5;
     }
+
+    residualAlpha   1e-4;
 }
 
 water
@@ -34,6 +36,8 @@ water
     {
         d               1e-4;
     }
+
+    residualAlpha   1e-4;
 }
 
 blending
@@ -73,7 +77,6 @@ drag
     (air in water)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-4;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -84,7 +87,6 @@ drag
     (water in air)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-4;
         residualRe      1e-3;
         swarmCorrection
         {

tutorials/multiphase/twoPhaseEulerFoam/laminar/mixerVessel2D/constant/phaseProperties

@@ -25,6 +25,8 @@ air
         d0              3e-3;
         p0              1e5;
     }
+
+    residualAlpha   1e-4;
 }
 
 water
@@ -34,6 +36,8 @@ water
     {
         d               1e-4;
     }
+
+    residualAlpha   1e-4;
 }
 
 blending
@@ -73,7 +77,6 @@ drag
     (air in water)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-4;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -84,7 +87,6 @@ drag
     (water in air)
     {
         type            SchillerNaumann;
-        residualAlpha   1e-4;
         residualRe      1e-3;
         swarmCorrection
         {
@@ -95,7 +97,6 @@ drag
     (air and water)
     {
         type            segregated;
-        residualAlpha   1e-4;
         m               0.5;
         n               8;
         swarmCorrection