multiphaseSystem.H 8.12 KB
Newer Older
Henry's avatar
Henry committed
1 2 3 4
/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
OpenFOAM bot's avatar
OpenFOAM bot committed
5
    \\  /    A nd           | www.openfoam.com
Henry's avatar
Henry committed
6
     \\/     M anipulation  |
OpenFOAM bot's avatar
OpenFOAM bot committed
7
-------------------------------------------------------------------------------
OpenFOAM bot's avatar
OpenFOAM bot committed
8
    Copyright (C) 2011-2016 OpenFOAM Foundation
9
    Copyright (C) 2019 OpenCFD Ltd.
Henry's avatar
Henry committed
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
-------------------------------------------------------------------------------
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::multiphaseSystem

Description
    Incompressible multi-phase mixture with built in solution for the
    phase fractions with interface compression for interface-capturing.

34
    Derived from transportModel so that it can be unused in conjunction with
Henry's avatar
Henry committed
35 36 37 38 39 40 41 42 43 44 45 46 47 48
    the incompressible turbulence models.

    Surface tension and contact-angle is handled for the interface
    between each phase-pair.

SourceFiles
    multiphaseSystem.C

\*---------------------------------------------------------------------------*/

#ifndef multiphaseSystem_H
#define multiphaseSystem_H

#include "incompressible/transportModel/transportModel.H"
49
#include "IOdictionary.H"
Henry's avatar
Henry committed
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
#include "phaseModel.H"
#include "PtrDictionary.H"
#include "volFields.H"
#include "surfaceFields.H"
#include "dragModel.H"
#include "HashPtrTable.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

/*---------------------------------------------------------------------------*\
                      Class multiphaseSystem Declaration
\*---------------------------------------------------------------------------*/

class multiphaseSystem
:
68
    public IOdictionary,
Henry's avatar
Henry committed
69
    public transportModel
Henry's avatar
Henry committed
70 71 72 73 74 75 76 77 78 79
{

public:

    class interfacePair
    :
        public Pair<word>
    {
    public:

80 81 82
        class symmHash
        :
            public Hash<interfacePair>
83
        {
84 85 86 87 88
        public:

            symmHash()
            {}

89 90 91 92 93 94
            label operator()(const interfacePair& key) const
            {
                return word::hash()(key.first()) + word::hash()(key.second());
            }
        };

95 96 97
        class hash
        :
             public Hash<interfacePair>
Henry's avatar
Henry committed
98
        {
99 100 101 102 103
        public:

            hash()
            {}

Henry's avatar
Henry committed
104 105
            label operator()(const interfacePair& key) const
            {
106
                return word::hash()(key.first(), word::hash()(key.second()));
Henry's avatar
Henry committed
107 108 109 110 111 112
            }
        };


        // Constructors

113 114
            interfacePair()
            {}
Henry's avatar
Henry committed
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152

            interfacePair(const word& alpha1Name, const word& alpha2Name)
            :
                Pair<word>(alpha1Name, alpha2Name)
            {}

            interfacePair(const phaseModel& alpha1, const phaseModel& alpha2)
            :
                Pair<word>(alpha1.name(), alpha2.name())
            {}


        // Friend Operators

            friend bool operator==
            (
                const interfacePair& a,
                const interfacePair& b
            )
            {
                return
                (
                    ((a.first() == b.first()) && (a.second() == b.second()))
                 || ((a.first() == b.second()) && (a.second() == b.first()))
                );
            }

            friend bool operator!=
            (
                const interfacePair& a,
                const interfacePair& b
            )
            {
                return (!(a == b));
            }
    };


153
    typedef HashPtrTable<dragModel, interfacePair, interfacePair::symmHash>
Henry's avatar
Henry committed
154 155
        dragModelTable;

156
    typedef HashPtrTable<volScalarField, interfacePair, interfacePair::symmHash>
Henry's avatar
Henry committed
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171
        dragCoeffFields;


private:

    // Private data

        //- Dictionary of phases
        PtrDictionary<phaseModel> phases_;

        const fvMesh& mesh_;
        const surfaceScalarField& phi_;

        volScalarField alphas_;

172 173 174
        typedef HashTable<scalar, interfacePair, interfacePair::symmHash>
            scalarCoeffSymmTable;

Henry's avatar
Henry committed
175 176 177
        typedef HashTable<scalar, interfacePair, interfacePair::hash>
            scalarCoeffTable;

178
        scalarCoeffSymmTable sigmas_;
Henry's avatar
Henry committed
179 180
        dimensionSet dimSigma_;

181
        scalarCoeffSymmTable cAlphas_;
Henry's avatar
Henry committed
182 183 184

        scalarCoeffTable Cvms_;

185
        typedef HashTable<dictionary, interfacePair, interfacePair::symmHash>
Henry's avatar
Henry committed
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
            interfaceDictTable;

        dragModelTable dragModels_;

        //- Stabilisation for normalisation of the interface normal
        const dimensionedScalar deltaN_;


    // Private member functions

        void calcAlphas();

        void solveAlphas();

        tmp<surfaceVectorField> nHatfv
        (
            const volScalarField& alpha1,
            const volScalarField& alpha2
        ) const;

        tmp<surfaceScalarField> nHatf
        (
            const volScalarField& alpha1,
            const volScalarField& alpha2
        ) const;

        void correctContactAngle
        (
            const phaseModel& alpha1,
            const phaseModel& alpha2,
216
            surfaceVectorField::Boundary& nHatb
Henry's avatar
Henry committed
217 218
        ) const;

Henry's avatar
Henry committed
219 220 221 222 223
        tmp<volScalarField> K
        (
            const phaseModel& alpha1,
            const phaseModel& alpha2
        ) const;
Henry's avatar
Henry committed
224 225 226 227 228 229 230 231 232


public:

    // Constructors

        //- Construct from components
        multiphaseSystem
        (
Henry's avatar
Henry committed
233
            const volVectorField& U,
Henry's avatar
Henry committed
234 235 236 237 238
            const surfaceScalarField& phi
        );


    //- Destructor
239
    virtual ~multiphaseSystem() = default;
Henry's avatar
Henry committed
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258


    // Member Functions

        //- Return the phases
        const PtrDictionary<phaseModel>& phases() const
        {
            return phases_;
        }

        //- Return the phases
        PtrDictionary<phaseModel>& phases()
        {
            return phases_;
        }

        //- Return the mixture density
        tmp<volScalarField> rho() const;

259 260 261
        //- Return the mixture density for patch
        tmp<scalarField> rho(const label patchi) const;

Henry's avatar
Henry committed
262 263 264
        //- Return the mixture laminar viscosity
        tmp<volScalarField> nu() const;

265 266 267
        //- Return the laminar viscosity for patch
        tmp<scalarField> nu(const label patchi) const;

Henry's avatar
Henry committed
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
        //- Return the virtual-mass coefficient for the given phase
        tmp<volScalarField> Cvm(const phaseModel& phase) const;

        //- Return the virtual-mass source for the given phase
        tmp<volVectorField> Svm(const phaseModel& phase) const;

        //- Return the table of drag models
        const dragModelTable& dragModels() const
        {
            return dragModels_;
        }

        //- Return the drag coefficients for all of the interfaces
        autoPtr<dragCoeffFields> dragCoeffs() const;

        //- Return the sum of the drag coefficients for the given phase
        tmp<volScalarField> dragCoeff
        (
            const phaseModel& phase,
            const dragCoeffFields& dragCoeffs
        ) const;

290
        tmp<surfaceScalarField> surfaceTension(const phaseModel& phase) const;
Henry's avatar
Henry committed
291 292 293 294 295 296 297 298

        //- Indicator of the proximity of the interface
        //  Field values are 1 near and 0 away for the interface.
        tmp<volScalarField> nearInterface() const;

        //- Solve for the mixture phase-fractions
        void solve();

Henry's avatar
Henry committed
299 300 301 302
        //- Dummy correct
        void correct()
        {}

Henry's avatar
Henry committed
303 304 305 306 307 308 309 310 311 312 313 314 315 316
        //- Read base transportProperties dictionary
        bool read();
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //