├── applications
    └── VOFDBMcavitationFoam
    │   ├── Make
    │       ├── files
    │       └── options
    │   ├── phaseChangeTwoPhaseMixtures
    │       ├── Make
    │       │   ├── files
    │       │   └── options
    │       ├── phaseChangeTwoPhaseMixture
    │       │   ├── phaseChangeTwoPhaseMixtureNew.C
    │       │   ├── phaseChangeTwoPhaseMixture.C
    │       │   └── phaseChangeTwoPhaseMixture.H
    │       ├── Merkle
    │       │   ├── Merkle.H
    │       │   └── Merkle.C
    │       ├── Kunz
    │       │   ├── Kunz.C
    │       │   └── Kunz.H
    │       └── SchnerrSauer
    │       │   ├── SchnerrSauer.H
    │       │   └── SchnerrSauer.C
    │   ├── Allwclean
    │   ├── Allwmake
    │   ├── alphaControls.H
    │   ├── UEqn.H
    │   ├── alphaEqnSubCycle.H
    │   ├── pEqn.H
    │   ├── createFields.H
    │   ├── alphaEqn.H
    │   └── VOFDBMcavitationFoam.C
├── src
    └── libVOFDBM
    │   ├── Make
    │       ├── files
    │       └── options
    │   ├── bubbleCloud
    │       ├── bubbleCloudI.H
    │       ├── collisionModel.H
    │       ├── breakupModel.H
    │       ├── bubbleCloud.H
    │       ├── collisionModel.C
    │       ├── breakupModel.C
    │       └── bubbleCloud.C
    │   ├── bubble
    │       ├── bubbleI.H
    │       ├── RPEqn.H
    │       ├── bubbleIO.C
    │       ├── bubble.H
    │       └── bubble.C
    │   └── phaseCoupling
    │       ├── phaseCoupling.H
    │       └── phaseCoupling.C
├── .gitignore
├── README.md
└── LICENSE


/applications/VOFDBMcavitationFoam/Make/files:
--------------------------------------------------------------------------------
1 | VOFDBMcavitationFoam.C
2 | 
3 | EXE = $(FOAM_USER_APPBIN)/VOFDBMcavitationFoam
4 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/Make/files:
--------------------------------------------------------------------------------
 1 | bubble/bubble.C
 2 | bubble/bubbleIO.C
 3 | 
 4 | bubbleCloud/bubbleCloud.C
 5 | bubbleCloud/breakupModel.C
 6 | bubbleCloud/collisionModel.C
 7 | 
 8 | phaseCoupling/phaseCoupling.C
 9 | 
10 | LIB = $(FOAM_USER_LIBBIN)/libVOFDBM
11 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/Make/options:
--------------------------------------------------------------------------------
 1 | EXE_INC = \
 2 |     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
 3 |     -I$(LIB_SRC)/finiteVolume/lnInclude \
 4 |     -I$(LIB_SRC)/meshTools/lnInclude
 5 | 
 6 | EXE_LIBS = \
 7 |     -lfiniteVolume \
 8 |     -lmeshTools \
 9 |     -llagrangian
10 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/Make/files:
--------------------------------------------------------------------------------
1 | phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixture.C
2 | phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixtureNew.C
3 | Kunz/Kunz.C
4 | Merkle/Merkle.C
5 | SchnerrSauer/SchnerrSauer.C
6 | 
7 | LIB = $(FOAM_USER_LIBBIN)/libphaseChangeTwoPhaseMixtures
8 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/Allwclean:
--------------------------------------------------------------------------------
1 | #!/bin/sh
2 | cd "${0%/*}" || exit    # Run from this directory
3 | #------------------------------------------------------------------------------
4 | 
5 | wclean libso phaseChangeTwoPhaseMixtures
6 | wclean
7 | 
8 | #------------------------------------------------------------------------------
9 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/Allwmake:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | cd "${0%/*}" || exit                                # Run from this directory
 3 | . ${WM_PROJECT_DIR:?}/wmake/scripts/AllwmakeParseArguments
 4 | #------------------------------------------------------------------------------
 5 | 
 6 | 
 7 | wmake $targetType
 8 | wmake $targetType VOFDBMcavitationDyMFoam
 9 | 
10 | #------------------------------------------------------------------------------
11 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/Make/options:
--------------------------------------------------------------------------------
 1 | EXE_INC = \
 2 |     -I$(LIB_SRC)/finiteVolume/lnInclude \
 3 |     -I$(LIB_SRC)/meshTools/lnInclude \
 4 |     -I$(LIB_SRC)/transportModels \
 5 |     -I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
 6 |     -I$(LIB_SRC)/transportModels/incompressible/lnInclude
 7 | 
 8 | LIB_LIBS = \
 9 |     -lfiniteVolume \
10 |     -lmeshTools \
11 |     -ltwoPhaseMixture \
12 |     -ltwoPhaseProperties \
13 |     -lincompressibleTransportModels
14 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/alphaControls.H:
--------------------------------------------------------------------------------
 1 | const dictionary& alphaControls = mesh.solverDict(alpha1.name());
 2 | 
 3 | label nAlphaCorr(alphaControls.get<label>("nAlphaCorr"));
 4 | 
 5 | label nAlphaSubCycles(alphaControls.get<label>("nAlphaSubCycles"));
 6 | 
 7 | bool MULESCorr(alphaControls.getOrDefault("MULESCorr", false));
 8 | 
 9 | // Apply the compression correction from the previous iteration
10 | // Improves efficiency for steady-simulations but can only be applied
11 | // once the alpha field is reasonably steady, i.e. fully developed
12 | //bool alphaApplyPrevCorr
13 | //(
14 | //    alphaControls.getOrDefault("alphaApplyPrevCorr", false)
15 | //);
16 | 
17 | // Isotropic compression coefficient
18 | scalar icAlpha
19 | (
20 |     alphaControls.getOrDefault<scalar>("icAlpha", 0)
21 | );
22 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/UEqn.H:
--------------------------------------------------------------------------------
 1 |     fvVectorMatrix UEqn
 2 |     (
 3 |         fvm::ddt(rho, U)
 4 |       + fvm::div(rhoPhi, U)
 5 |       - fvm::Sp(fvc::ddt(rho) + fvc::div(rhoPhi), U)
 6 |       + turbulence->divDevRhoReff(rho, U)
 7 |       + fvm::Sp(rho*coupling.damping(), U)
 8 |       - fvm::Su(cloud.momentumSource(), U)
 9 |       ==
10 |         fvOptions(rho, U) 
11 |         + rho*cloud.USource().oldTime() //for transition coupling
12 |     );
13 | 
14 |     UEqn.relax();
15 | 
16 |     if (pimple.momentumPredictor())
17 |     {
18 |         solve
19 |         (
20 |             UEqn
21 |          ==
22 |             fvc::reconstruct
23 |             (
24 |                 (
25 |                     interface.surfaceTensionForce()
26 |                   - ghf*fvc::snGrad(rho)
27 |                   - fvc::snGrad(p_rgh)
28 |                 ) * mesh.magSf()
29 |             )
30 |         );
31 |     }
32 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # VOFDBMcavitationFoam
 2 | 
 3 | ## Features
 4 | 
 5 | - Volume-of-Fluid (VOF) solver with phasechange for cavitating flows coupled with Lagrangian library
 6 | - Conversion of small VOF elements to Lagrangian parcels to reduce computational cost
 7 | - Support for
 8 |   - Particle-particle interaction (collision, coalescence) and secondary breakup
 9 |   - Solving RP equation or simplified RP equation for discrete bubbles
10 |   - Adaptive mesh refinement
11 |   - Fully parallelized
12 | - Based on interPhaseChangeFoam
13 | 
14 | ## Compilation
15 | 
16 | - First, compile the library libVOFDBM in the src folder.
17 | - Afterwards, compile the solver VOFDBMcavitationFoam in the application folder.
18 | 
19 | ## Reference
20 | Linmin Li, Weisen Xu, Bowen Jiang, Xiaojun Li, Zuchao Zhu, A multiscale Eulerian-Lagrangian cavitating flow solver in OpenFOAM, SoftwareX, 2023, 21, 101304, https://doi.org/10.1016/j.softx.2022.101304
21 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/Make/options:
--------------------------------------------------------------------------------
 1 | EXE_INC = \
 2 |     -I../../src/libVOFDBM/lnInclude \
 3 |     -I$(LIB_SRC)/finiteVolume/lnInclude \
 4 |     -I$(LIB_SRC)/meshTools/lnInclude \
 5 |     -I$(LIB_SRC)/sampling/lnInclude \
 6 |     -I$(LIB_SRC)/lagrangian/basic/lnInclude \
 7 |     -I$(LIB_SRC)/transportModels/twoPhaseMixture/lnInclude \
 8 |     -I$(LIB_SRC)/transportModels \
 9 |     -I$(LIB_SRC)/transportModels/incompressible/lnInclude \
10 |     -I$(LIB_SRC)/transportModels/interfaceProperties/lnInclude \
11 |     -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
12 |     -I$(LIB_SRC)/TurbulenceModels/incompressible/lnInclude \
13 |     -IphaseChangeTwoPhaseMixtures/lnInclude
14 | 
15 | EXE_LIBS = \
16 |     -L$(FOAM_USER_LIBBIN) \
17 |     -lfiniteVolume \
18 |     -lfvOptions \
19 |     -lmeshTools \
20 |     -lsampling \
21 |     -lphaseChangeTwoPhaseMixtures \
22 |     -ltwoPhaseMixture \
23 |     -ltwoPhaseProperties \
24 |     -linterfaceProperties \
25 |     -lincompressibleTransportModels \
26 |     -lturbulenceModels \
27 |     -lincompressibleTurbulenceModels \
28 |     -lwaveModels \
29 |     -llagrangian \
30 |     -lgeometricVoF \
31 |     -lVOFDBM
32 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/alphaEqnSubCycle.H:
--------------------------------------------------------------------------------
 1 | {
 2 |     // Standard face-flux compression coefficient
 3 |     surfaceScalarField phic(interface.cAlpha()*mag(phi/mesh.magSf()));
 4 | 
 5 |     // Add the optional isotropic compression contribution
 6 |     if (icAlpha > 0)
 7 |     {
 8 |         phic *= (1.0 - icAlpha);
 9 |         phic += (interface.cAlpha()*icAlpha)*fvc::interpolate(mag(U));
10 |     }
11 | 
12 |     volScalarField divU
13 |     (
14 |         mesh.moving()
15 |       ? fvc::div(phi + mesh.phi())
16 |       : fvc::div(phi)
17 |     );
18 | 
19 |     if (nAlphaSubCycles > 1)
20 |     {
21 |         dimensionedScalar totalDeltaT = runTime.deltaT();
22 |         surfaceScalarField rhoPhiSum
23 |         (
24 |             IOobject
25 |             (
26 |                 "rhoPhiSum",
27 |                 runTime.timeName(),
28 |                 mesh
29 |             ),
30 |             mesh,
31 |             dimensionedScalar(rhoPhi.dimensions(), Zero)
32 |         );
33 | 
34 |         for
35 |         (
36 |             subCycle<volScalarField> alphaSubCycle(alpha1, nAlphaSubCycles);
37 |             !(++alphaSubCycle).end();
38 |         )
39 |         {
40 |             #include "alphaEqn.H"
41 |             rhoPhiSum += (runTime.deltaT()/totalDeltaT)*rhoPhi;
42 |         }
43 | 
44 |         rhoPhi = rhoPhiSum;
45 |     }
46 |     else
47 |     {
48 |         #include "alphaEqn.H"
49 |     }
50 | 
51 |     rho == alpha1*rho1 + alpha2*rho2;
52 | }
53 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/pEqn.H:
--------------------------------------------------------------------------------
 1 | {
 2 |     volScalarField rAU("rAU", 1.0/UEqn.A());
 3 |     surfaceScalarField rAUf("rAUf", fvc::interpolate(rAU));
 4 |     volVectorField HbyA(constrainHbyA(rAU*UEqn.H(), U, p_rgh));
 5 |     surfaceScalarField phiHbyA
 6 |     (
 7 |         "phiHbyA",
 8 |         fvc::flux(HbyA)
 9 |       + fvc::interpolate(rho*rAU)*fvc::ddtCorr(U, phi)
10 |     );
11 |     adjustPhi(phiHbyA, U, p_rgh);
12 | 
13 |     surfaceScalarField phig
14 |     (
15 |         (
16 |             interface.surfaceTensionForce()
17 |           - ghf*fvc::snGrad(rho)
18 |         )*rAUf*mesh.magSf()
19 |     );
20 | 
21 |     phiHbyA += phig;
22 | 
23 |     // Update the pressure BCs to ensure flux consistency
24 |     constrainPressure(p_rgh, U, phiHbyA, rAUf);
25 | 
26 |     Pair<tmp<volScalarField>> vDotP = mixture->vDotP();
27 |     const volScalarField& vDotcP = vDotP[0]();
28 |     const volScalarField& vDotvP = vDotP[1]();
29 | 
30 |     while (pimple.correctNonOrthogonal())
31 |     {
32 |         fvScalarMatrix p_rghEqn
33 |         (
34 |             fvc::div(phiHbyA) - fvm::laplacian(rAUf, p_rgh)
35 |           - (vDotvP - vDotcP)*(mixture->pSat() - rho*gh)
36 |           + fvm::Sp(vDotvP - vDotcP, p_rgh)
37 |         );
38 | 
39 |         p_rghEqn.setReference(pRefCell, pRefValue);
40 | 
41 |         p_rghEqn.solve(mesh.solver(p_rgh.select(pimple.finalInnerIter())));
42 | 
43 |         if (pimple.finalNonOrthogonalIter())
44 |         {
45 |             phi = phiHbyA + p_rghEqn.flux();
46 | 
47 |             U = HbyA + rAU*fvc::reconstruct((phig + p_rghEqn.flux())/rAUf);
48 |             U.correctBoundaryConditions();
49 |             fvOptions.correct(U);
50 |         }
51 |     }
52 | 
53 |     p == p_rgh + rho*gh;
54 | 
55 |     if (p_rgh.needReference())
56 |     {
57 |         p += dimensionedScalar
58 |         (
59 |             "p",
60 |             p.dimensions(),
61 |             pRefValue - getRefCellValue(p, pRefCell)
62 |         );
63 |         p_rgh = p - rho*gh;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixtureNew.C:
--------------------------------------------------------------------------------
 1 | /*---------------------------------------------------------------------------*\
 2 |   =========                 |
 3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 4 |    \\    /   O peration     |
 5 |     \\  /    A nd           | www.openfoam.com
 6 |      \\/     M anipulation  |
 7 | -------------------------------------------------------------------------------
 8 |     Copyright (C) 2011-2015 OpenFOAM Foundation
 9 |     Copyright (C) 2019-2021 OpenCFD Ltd.
10 | -------------------------------------------------------------------------------
11 | License
12 |     This file is part of OpenFOAM.
13 | 
14 |     OpenFOAM is free software: you can redistribute it and/or modify it
15 |     under the terms of the GNU General Public License as published by
16 |     the Free Software Foundation, either version 3 of the License, or
17 |     (at your option) any later version.
18 | 
19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
22 |     for more details.
23 | 
24 |     You should have received a copy of the GNU General Public License
25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
26 | 
27 | \*---------------------------------------------------------------------------*/
28 | 
29 | #include "phaseChangeTwoPhaseMixture.H"
30 | #include "incompressibleTwoPhaseMixture.H"
31 | #include "surfaceMesh.H"
32 | 
33 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
34 | 
35 | Foam::autoPtr<Foam::phaseChangeTwoPhaseMixture>
36 | Foam::phaseChangeTwoPhaseMixture::New
37 | (
38 |     const volVectorField& U,
39 |     const surfaceScalarField& phi
40 | )
41 | {
42 |     const IOdictionary dict
43 |     (
44 |         IOobject
45 |         (
46 |             "transportProperties",
47 |             U.time().constant(),
48 |             U.db(),
49 |             IOobject::MUST_READ,
50 |             IOobject::NO_WRITE,
51 |             false // Do not register
52 |         )
53 |     );
54 | 
55 |     const word modelType(dict.get<word>("phaseChangeTwoPhaseMixture"));
56 | 
57 |     Info<< "Selecting phaseChange model " << modelType << endl;
58 | 
59 |     auto* ctorPtr = componentsConstructorTable(modelType);
60 | 
61 |     if (!ctorPtr)
62 |     {
63 |         FatalIOErrorInLookup
64 |         (
65 |             dict,
66 |             "phaseChangeTwoPhaseMixture",
67 |             modelType,
68 |             *componentsConstructorTablePtr_
69 |         ) << exit(FatalIOError);
70 |     }
71 | 
72 |     return autoPtr<phaseChangeTwoPhaseMixture>(ctorPtr(U, phi));
73 | }
74 | 
75 | 
76 | // ************************************************************************* //
77 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/createFields.H:
--------------------------------------------------------------------------------
  1 | Info<< "Reading field p_rgh\n" << endl;
  2 | volScalarField p_rgh
  3 | (
  4 |     IOobject
  5 |     (
  6 |         "p_rgh",
  7 |         runTime.timeName(),
  8 |         mesh,
  9 |         IOobject::MUST_READ,
 10 |         IOobject::AUTO_WRITE
 11 |     ),
 12 |     mesh
 13 | );
 14 | 
 15 | Info<< "Reading field U\n" << endl;
 16 | volVectorField U
 17 | (
 18 |     IOobject
 19 |     (
 20 |         "U",
 21 |         runTime.timeName(),
 22 |         mesh,
 23 |         IOobject::MUST_READ,
 24 |         IOobject::AUTO_WRITE
 25 |     ),
 26 |     mesh
 27 | );
 28 | 
 29 | #include "createPhi.H"
 30 | 
 31 | 
 32 | Info<< "Creating phaseChangeTwoPhaseMixture\n" << endl;
 33 | autoPtr<phaseChangeTwoPhaseMixture> mixture =
 34 |     phaseChangeTwoPhaseMixture::New(U, phi);
 35 | 
 36 | volScalarField& alpha1(mixture->alpha1());
 37 | volScalarField& alpha2(mixture->alpha2());
 38 | 
 39 | const dimensionedScalar& rho1 = mixture->rho1();
 40 | const dimensionedScalar& rho2 = mixture->rho2();
 41 | 
 42 | 
 43 | // Need to store rho for ddt(rho, U)
 44 | volScalarField rho
 45 | (
 46 |     IOobject
 47 |     (
 48 |         "rho",
 49 |         runTime.timeName(),
 50 |         mesh,
 51 |         IOobject::READ_IF_PRESENT
 52 |     ),
 53 |     alpha1*rho1 + alpha2*rho2
 54 | );
 55 | rho.oldTime();
 56 | 
 57 | 
 58 | // Construct interface from alpha1 distribution
 59 | interfaceProperties interface(alpha1, U, mixture());
 60 | 
 61 | // Construct incompressible turbulence model
 62 | autoPtr<incompressible::turbulenceModel> turbulence
 63 | (
 64 |     incompressible::turbulenceModel::New(U, phi, mixture())
 65 | );
 66 | 
 67 | 
 68 | #include "readGravitationalAcceleration.H"
 69 | #include "readhRef.H"
 70 | #include "gh.H"
 71 | 
 72 | 
 73 | volScalarField p
 74 | (
 75 |     IOobject
 76 |     (
 77 |         "p",
 78 |         runTime.timeName(),
 79 |         mesh,
 80 |         IOobject::NO_READ,
 81 |         IOobject::AUTO_WRITE
 82 |     ),
 83 |     p_rgh + rho*gh
 84 | );
 85 | 
 86 | label pRefCell = 0;
 87 | scalar pRefValue = 0.0;
 88 | setRefCell
 89 | (
 90 |     p,
 91 |     p_rgh,
 92 |     pimple.dict(),
 93 |     pRefCell,
 94 |     pRefValue
 95 | );
 96 | 
 97 | if (p_rgh.needReference())
 98 | {
 99 |     p += dimensionedScalar
100 |     (
101 |         "p",
102 |         p.dimensions(),
103 |         pRefValue - getRefCellValue(p, pRefCell)
104 |     );
105 |     p_rgh = p - rho*gh;
106 | }
107 | 
108 | mesh.setFluxRequired(p_rgh.name());
109 | mesh.setFluxRequired(alpha1.name());
110 | 
111 | #include "createFvOptions.H"
112 | 
113 | IOobject alphaPhi10Header
114 | (
115 |     IOobject::groupName("alphaPhi0", alpha1.group()),
116 |     runTime.timeName(),
117 |     mesh,
118 |     IOobject::NO_READ,
119 |     IOobject::NO_WRITE
120 | );
121 | 
122 | // MULES flux from previous time-step
123 | surfaceScalarField alphaPhi10
124 | (
125 |     alphaPhi10Header,
126 |     phi*fvc::interpolate(alpha1)
127 | );
128 | 
129 | bubbleCloud cloud(mesh, g);
130 | 
131 | phaseCoupling coupling
132 | (
133 |     U,
134 |     alpha1,
135 |     alpha2,
136 |     cloud
137 | );
138 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixture.C:
--------------------------------------------------------------------------------
 1 | /*---------------------------------------------------------------------------*\
 2 |   =========                 |
 3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
 4 |    \\    /   O peration     |
 5 |     \\  /    A nd           | www.openfoam.com
 6 |      \\/     M anipulation  |
 7 | -------------------------------------------------------------------------------
 8 |     Copyright (C) 2011-2017 OpenFOAM Foundation
 9 | -------------------------------------------------------------------------------
10 | License
11 |     This file is part of OpenFOAM.
12 | 
13 |     OpenFOAM is free software: you can redistribute it and/or modify it
14 |     under the terms of the GNU General Public License as published by
15 |     the Free Software Foundation, either version 3 of the License, or
16 |     (at your option) any later version.
17 | 
18 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
21 |     for more details.
22 | 
23 |     You should have received a copy of the GNU General Public License
24 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
25 | 
26 | \*---------------------------------------------------------------------------*/
27 | 
28 | #include "phaseChangeTwoPhaseMixture.H"
29 | #include "surfaceMesh.H"
30 | 
31 | // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
32 | 
33 | namespace Foam
34 | {
35 |     defineTypeNameAndDebug(phaseChangeTwoPhaseMixture, 0);
36 |     defineRunTimeSelectionTable(phaseChangeTwoPhaseMixture, components);
37 | }
38 | 
39 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
40 | 
41 | Foam::phaseChangeTwoPhaseMixture::phaseChangeTwoPhaseMixture
42 | (
43 |     const word& type,
44 |     const volVectorField& U,
45 |     const surfaceScalarField& phi
46 | )
47 | :
48 |     incompressibleTwoPhaseMixture(U, phi),
49 |     phaseChangeTwoPhaseMixtureCoeffs_(optionalSubDict(type + "Coeffs")),
50 |     pSat_("pSat", dimPressure, *this)
51 | {}
52 | 
53 | 
54 | // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
55 | 
56 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
57 | Foam::phaseChangeTwoPhaseMixture::vDotAlphal() const
58 | {
59 |     volScalarField alphalCoeff(1.0/rho1() - alpha1_*(1.0/rho1() - 1.0/rho2()));
60 |     Pair<tmp<volScalarField>> mDotAlphal = this->mDotAlphal();
61 | 
62 |     return Pair<tmp<volScalarField>>
63 |     (
64 |         alphalCoeff*mDotAlphal[0],
65 |         alphalCoeff*mDotAlphal[1]
66 |     );
67 | }
68 | 
69 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
70 | Foam::phaseChangeTwoPhaseMixture::vDotP() const
71 | {
72 |     dimensionedScalar pCoeff(1.0/rho1() - 1.0/rho2());
73 |     Pair<tmp<volScalarField>> mDotP = this->mDotP();
74 | 
75 |     return Pair<tmp<volScalarField>>(pCoeff*mDotP[0], pCoeff*mDotP[1]);
76 | }
77 | 
78 | 
79 | bool Foam::phaseChangeTwoPhaseMixture::read()
80 | {
81 |     if (incompressibleTwoPhaseMixture::read())
82 |     {
83 |         phaseChangeTwoPhaseMixtureCoeffs_ = optionalSubDict(type() + "Coeffs");
84 |         readEntry("pSat", pSat_);
85 | 
86 |         return true;
87 |     }
88 | 
89 |     return false;
90 | }
91 | 
92 | 
93 | // ************************************************************************* //
94 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubbleCloud/bubbleCloudI.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | \*---------------------------------------------------------------------------*/
 25 | 
 26 | // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 27 | 
 28 | inline const Foam::fvMesh& Foam::bubbleCloud::mesh() const
 29 | {
 30 |     return mesh_;
 31 | }
 32 | 
 33 | inline Foam::scalar Foam::bubbleCloud::rhop() const
 34 | {
 35 |     return rhop_;
 36 | }
 37 | 
 38 | inline Foam::scalar Foam::bubbleCloud::mup() const
 39 | {
 40 |     return mup_;
 41 | }
 42 | 
 43 | inline Foam::scalar Foam::bubbleCloud::sigma() const
 44 | {
 45 |     return sigma_;
 46 | }
 47 | 
 48 | //added
 49 | inline Foam::scalar Foam::bubbleCloud::p0() const
 50 | {
 51 |   return p0_;
 52 | }
 53 | 
 54 | inline Foam::scalar Foam::bubbleCloud::pSat() const
 55 | {
 56 |     return pSat_;
 57 | }
 58 | inline Foam::scalar Foam::bubbleCloud::RPEqn() const
 59 | {
 60 |     return RPEqn_;
 61 | }
 62 | 
 63 | inline Foam::scalar Foam::bubbleCloud::gamma() const
 64 | {
 65 |     return gamma_;
 66 | }
 67 | 
 68 | //7-6
 69 | inline Foam::vectorField& Foam::bubbleCloud::source()
 70 | {
 71 |     return source_;
 72 | }
 73 | inline Foam::vectorField& Foam::bubbleCloud::Usource()
 74 | {
 75 |     return Usource_;
 76 | }
 77 | inline Foam::scalarField& Foam::bubbleCloud::correctalpha1()
 78 | {
 79 |      return correctalpha1_;
 80 | }
 81 | inline const Foam::volVectorField& Foam::bubbleCloud::momentumSource()
 82 | {
 83 |     return momentumSource_;
 84 | }
 85 | inline const Foam::volVectorField& Foam::bubbleCloud::USource()
 86 | {
 87 |     return USource_;
 88 | }
 89 | inline const Foam::volScalarField& Foam::bubbleCloud::Addalpha1()
 90 | { 
 91 |     return Addalpha1_;
 92 | }
 93 | 
 94 | inline const Foam::labelList& Foam::bubbleCloud::faceZoneIDs()
 95 | {
 96 |     return faceZoneIDs_;
 97 | }
 98 | 
 99 | inline Foam::List<Foam::List<Foam::DynamicList<Foam::scalar> > >& Foam::bubbleCloud::dataDiameter()
100 | {
101 |     return dataDiameter_;
102 | }
103 | 
104 | inline Foam::List<Foam::List<Foam::DynamicList<Foam::scalar> > >& Foam::bubbleCloud::dataNParticle()
105 | {
106 |     return dataNParticle_;
107 | }
108 | 
109 | inline Foam::List<Foam::List<Foam::DynamicList<Foam::vector> > >& Foam::bubbleCloud::dataPosition()
110 | {
111 |     return dataPosition_;
112 | }
113 | //added
114 | 
115 | //end
116 | // ************************************************************************* //
117 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubble/bubbleI.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | \*---------------------------------------------------------------------------*/
 25 | 
 26 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 27 | 
 28 | inline Foam::bubble::trackingData::trackingData
 29 | (
 30 |     const bubbleCloud& spc,
 31 |     const interpolationCellPoint<scalar>& rhoInterp,
 32 |     const interpolationCellPoint<vector>& UInterp,
 33 |     const interpolationCellPoint<scalar>& nuInterp,
 34 |     const interpolationCell<scalar>& alpha1Interp, //
 35 |     const interpolationCellPoint<scalar>& pInterp, //
 36 |     const vector& g
 37 | )
 38 | :
 39 |     particle::trackingData(spc),
 40 |     rhoInterp_(rhoInterp),
 41 |     UInterp_(UInterp),
 42 |     nuInterp_(nuInterp),
 43 |     alpha1Interp_(alpha1Interp), //
 44 |     pInterp_(pInterp),//
 45 |     g_(g)
 46 | {}
 47 | 
 48 | 
 49 | inline Foam::bubble::bubble
 50 | (
 51 |     const polyMesh& mesh,
 52 |     const vector& position,
 53 |     const label celli,
 54 |     const scalar d,
 55 |     const vector& U
 56 | )
 57 | :
 58 |     particle(mesh, position, celli),
 59 |     d_(d),
 60 |     U_(U),
 61 |     nParticle_(1),
 62 |     y_(0.0),
 63 |     yDot_(0.0)
 64 | {}
 65 | 
 66 | 
 67 | // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 68 | 
 69 | inline const Foam::interpolationCellPoint<Foam::scalar>&
 70 | Foam::bubble::trackingData::rhoInterp() const
 71 | {
 72 |     return rhoInterp_;
 73 | }
 74 | 
 75 | 
 76 | inline const Foam::interpolationCellPoint<Foam::vector>&
 77 | Foam::bubble::trackingData::UInterp() const
 78 | {
 79 |     return UInterp_;
 80 | }
 81 | 
 82 | 
 83 | inline const Foam::interpolationCellPoint<Foam::scalar>&
 84 | Foam::bubble::trackingData::nuInterp() const
 85 | {
 86 |     return nuInterp_;
 87 | }
 88 | 
 89 | //added
 90 | inline const Foam::interpolationCell<Foam::scalar>&
 91 | Foam::bubble::trackingData::alpha1Interp() const
 92 | {
 93 |     return alpha1Interp_;
 94 | }
 95 | //end
 96 | //added
 97 | inline const Foam::interpolationCellPoint<Foam::scalar>&
 98 | Foam::bubble::trackingData::pInterp() const
 99 | {
100 |     return pInterp_;
101 | }
102 | //end
103 | inline const Foam::vector& Foam::bubble::trackingData::g() const
104 | {
105 |     return g_;
106 | }
107 | 
108 | 
109 | inline Foam::scalar& Foam::bubble::d()
110 | {
111 |     return d_;
112 | }
113 | 
114 | 
115 | inline Foam::vector& Foam::bubble::U()
116 | {
117 |     return U_;
118 | }
119 | 
120 | 
121 | inline Foam::scalar& Foam::bubble::nParticle()
122 | {
123 |     return nParticle_;
124 | }
125 | 
126 | 
127 | inline Foam::scalar& Foam::bubble::y()
128 | {
129 |     return y_;
130 | }
131 | 
132 | 
133 | inline Foam::scalar& Foam::bubble::yDot()
134 | {
135 |     return yDot_;
136 | }
137 | 
138 | 
139 | // ************************************************************************* //
140 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/alphaEqn.H:
--------------------------------------------------------------------------------
  1 | {
  2 |     word alphaScheme("div(phi,alpha)");
  3 |     word alpharScheme("div(phirb,alpha)");
  4 | 
  5 |     surfaceScalarField phir("phir", phic*interface.nHatf());
  6 | 
  7 |     Pair<tmp<volScalarField>> vDotAlphal =
  8 |         mixture->vDotAlphal();
  9 |     const volScalarField& vDotcAlphal = vDotAlphal[0]();
 10 |     const volScalarField& vDotvAlphal = vDotAlphal[1]();
 11 |     const volScalarField vDotvmcAlphal(vDotvAlphal - vDotcAlphal);
 12 | 
 13 |     tmp<surfaceScalarField> talphaPhi;
 14 | 
 15 |     if (MULESCorr)
 16 |     {
 17 |         fvScalarMatrix alpha1Eqn
 18 |         (
 19 |             fv::EulerDdtScheme<scalar>(mesh).fvmDdt(alpha1)
 20 |           + fv::gaussConvectionScheme<scalar>
 21 |             (
 22 |                 mesh,
 23 |                 phi,
 24 |                 upwind<scalar>(mesh, phi)
 25 |             ).fvmDiv(phi, alpha1)
 26 |           - fvm::Sp(divU, alpha1)
 27 |          ==
 28 |             fvm::Sp(vDotvmcAlphal, alpha1)
 29 |           + vDotcAlphal
 30 |         );
 31 | 
 32 |         alpha1Eqn.solve();
 33 | 
 34 |         Info<< "Phase-1 volume fraction = "
 35 |             << alpha1.weightedAverage(mesh.Vsc()).value()
 36 |             << "  Min(" << alpha1.name() << ") = " << min(alpha1).value()
 37 |             << "  Max(" << alpha1.name() << ") = " << max(alpha1).value()
 38 |             << endl;
 39 | 
 40 |         talphaPhi = alpha1Eqn.flux();
 41 |     }
 42 | 
 43 |     volScalarField alpha10("alpha10", alpha1);
 44 | 
 45 |     for (int aCorr=0; aCorr<nAlphaCorr; aCorr++)
 46 |     {
 47 |         tmp<surfaceScalarField> talphaPhiCorr
 48 |         (
 49 |             fvc::flux
 50 |             (
 51 |                 phi,
 52 |                 alpha1,
 53 |                 alphaScheme
 54 |             )
 55 |           + fvc::flux
 56 |             (
 57 |                 -fvc::flux(-phir, alpha2, alpharScheme),
 58 |                 alpha1,
 59 |                 alpharScheme
 60 |             )
 61 |         );
 62 | 
 63 |         if (MULESCorr)
 64 |         {
 65 |             talphaPhiCorr.ref() -= talphaPhi();
 66 | 
 67 |             volScalarField alpha100("alpha100", alpha10);
 68 |             alpha10 = alpha1;
 69 | 
 70 |             MULES::correct
 71 |             (
 72 |                 geometricOneField(),
 73 |                 alpha1,
 74 |                 talphaPhi(),
 75 |                 talphaPhiCorr.ref(),
 76 |                 vDotvmcAlphal,
 77 |                 (
 78 |                     divU*(alpha10 - alpha100)
 79 |                   - vDotvmcAlphal*alpha10
 80 |                 )(),
 81 |                 oneField(),
 82 |                 zeroField()
 83 |             );
 84 | 
 85 |             // Under-relax the correction for all but the 1st corrector
 86 |             if (aCorr == 0)
 87 |             {
 88 |                 talphaPhi.ref() += talphaPhiCorr();
 89 |             }
 90 |             else
 91 |             {
 92 |                 alpha1 = 0.5*alpha1 + 0.5*alpha10;
 93 |                 talphaPhi.ref() += 0.5*talphaPhiCorr();
 94 |             }
 95 |         }
 96 |         else
 97 |         {
 98 |             MULES::explicitSolve
 99 |             (
100 |                 geometricOneField(),
101 |                 alpha1,
102 |                 phi,
103 |                 talphaPhiCorr.ref(),
104 |                 vDotvmcAlphal,
105 |                 (divU*alpha1 + vDotcAlphal)(),
106 |                 oneField(),
107 |                 zeroField()
108 |             );
109 | 
110 |             talphaPhi = talphaPhiCorr;
111 |         }
112 | 
113 |         alpha2 = 1.0 - alpha1;
114 |     }
115 | 
116 |     rhoPhi = talphaPhi()*(rho1 - rho2) + phi*rho2;
117 | 
118 |     // Cache alphaPhi
119 |     alphaPhi10 = talphaPhi();
120 | 
121 |     Info<< "Liquid phase volume fraction = "
122 |         << alpha1.weightedAverage(mesh.V()).value()
123 |         << "  Min(" << alpha1.name() << ") = " << min(alpha1).value()
124 |         << "  Max(" << alpha1.name() << ") = " << max(alpha1).value()
125 |         << endl;
126 | }
127 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubbleCloud/collisionModel.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | Class
 25 |     Foam::collisionModel
 26 | 
 27 | Description
 28 |     Class for the collision model for the use with bubble class.
 29 | 
 30 | Author
 31 |     Dr. Martin Heinrich is copyright owner of the code, based on 
 32 |     the collision models included in the lagrangianSpray library in OpenFOAM.
 33 | 
 34 | 
 35 | \*---------------------------------------------------------------------------*/
 36 | 
 37 | #ifndef collisionModel_H
 38 | #define collisionModel_H
 39 | 
 40 | #include "Cloud.H"
 41 | #include "bubbleCloud.H"
 42 | #include "bubble.H"
 43 | #include "Random.H"
 44 | #include "clock.H"
 45 | 
 46 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 47 | 
 48 | namespace Foam
 49 | {
 50 | 
 51 | // Forward declaration of classes
 52 | class fvMesh;
 53 | 
 54 | /*---------------------------------------------------------------------------*\
 55 |                            Class bubbleCloud Declaration
 56 | \*---------------------------------------------------------------------------*/
 57 | 
 58 | class collisionModel
 59 | {
 60 |     // Private data
 61 | 
 62 |         const fvMesh& mesh_;
 63 | 
 64 | 	IOdictionary dict_;
 65 | 
 66 | 	// Secondary breakup active
 67 | 	bool active_;
 68 | 
 69 | 	//- Random number generator
 70 |         Random ranGen_;
 71 | 
 72 |         //- Model constants
 73 |         scalar cTime_;
 74 |         scalar cSpace_;
 75 | 
 76 |         //- bubble density
 77 |         scalar rhop_;
 78 | 
 79 |         //- bubble surface tension
 80 |         scalar sigma_;
 81 | 
 82 |     // Private Member Functions
 83 | 
 84 |         //- Collide parcels and return true if mass has changed
 85 |         bool collidebubbles
 86 |         (
 87 |             const scalar dt,
 88 |             bubble& p1,
 89 |             bubble& p2,
 90 |             scalar& m1,
 91 |             scalar& m2
 92 |         );
 93 | 
 94 |         // 1 is the larger drop and 2 is the smaller
 95 |         bool collideSorted
 96 |         (
 97 |             const scalar dt,
 98 |             bubble& p1,
 99 |             bubble& p2,
100 |             scalar& m1,
101 |             scalar& m2
102 |         );
103 |            
104 | 
105 | public:
106 | 
107 |     // Constructors
108 | 
109 |         collisionModel
110 |         (
111 |             const fvMesh&
112 |         );
113 | 
114 | 
115 |     // Member Functions
116 | 
117 |         //- Calulate bubble-bubble collision and coalescence
118 |         void update
119 |         (
120 |             bubbleCloud& cloud,
121 |             const scalar dt
122 |         );
123 | };
124 | 
125 | 
126 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
127 | 
128 | } // End namespace Foam
129 | 
130 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
131 | 
132 | #endif
133 | 
134 | // ************************************************************************* //
135 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubbleCloud/breakupModel.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | Class
 25 |     Foam::breakupModel
 26 | 
 27 | Description
 28 |     Class for different breakup models for the use with bubble class.
 29 | 
 30 | Author
 31 |     Dr. Martin Heinrich is copyright owner of the code, based on 
 32 |     the breakup models included in the lagrangianSpray library in OpenFOAM.
 33 | 
 34 | \*---------------------------------------------------------------------------*/
 35 | 
 36 | #ifndef breakupModel_H
 37 | #define breakupModel_H
 38 | 
 39 | #include "Cloud.H"
 40 | #include "bubbleCloud.H"
 41 | #include "bubble.H"
 42 | 
 43 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 44 | 
 45 | namespace Foam
 46 | {
 47 | 
 48 | // Forward declaration of classes
 49 | class fvMesh;
 50 | 
 51 | /*---------------------------------------------------------------------------*\
 52 |                            Class bubbleCloud Declaration
 53 | \*---------------------------------------------------------------------------*/
 54 | 
 55 | class breakupModel
 56 | {
 57 |     // Private data
 58 | 
 59 |         const fvMesh& mesh_;
 60 | 
 61 |         IOdictionary dict_;
 62 | 
 63 |         // Secondary breakup model
 64 |         word model_;
 65 | 
 66 |         // ETAB model constants
 67 |         scalar k1_;
 68 |         scalar k2_;
 69 |         scalar WeTransition_;
 70 |         scalar AWe_;
 71 |         scalar TABComega_;
 72 |         scalar TABCmu_;
 73 |         scalar TABtwoWeCrit_;
 74 | 
 75 |         // Reitz Diwakar model constants
 76 |         scalar Cbag_;
 77 |         scalar Cb_;
 78 |         scalar Cstrip_;
 79 |         scalar Cs_;
 80 | 
 81 |         // Pilch Erman model constants
 82 |         scalar B1_;
 83 |         scalar B2_;
 84 | 
 85 |         // Check for breakup
 86 |         void breakup
 87 |         (
 88 |             const scalar dt,
 89 |             const vector g,
 90 |             scalar& d,
 91 |             scalar& nParticle,
 92 |             scalar& y,
 93 |             scalar& yDot,
 94 |             const scalar rhop,
 95 |             const scalar mup,
 96 |             const scalar sigma,
 97 |             const vector& Up,
 98 |             const scalar rhoc,
 99 |             const scalar muc,
100 |             const scalar Urmag
101 |         );
102 | 
103 | public:
104 | 
105 |     // Constructors
106 | 
107 |         breakupModel
108 |         (
109 |             const fvMesh&
110 |         );
111 | 
112 | 
113 |     // Member Functions
114 | 
115 |         //- Calulate bubble breakup
116 |         void update
117 |         (
118 |             bubbleCloud& cloud,
119 |             bubble::trackingData& td,
120 |             const scalar dt
121 |         );
122 | };
123 | 
124 | 
125 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
126 | 
127 | } // End namespace Foam
128 | 
129 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
130 | 
131 | #endif
132 | 
133 | // ************************************************************************* //
134 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/Merkle/Merkle.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2016 OpenFOAM Foundation
  9 |     Copyright (C) 2019 OpenCFD Ltd.
 10 | -------------------------------------------------------------------------------
 11 | License
 12 |     This file is part of OpenFOAM.
 13 | 
 14 |     OpenFOAM is free software: you can redistribute it and/or modify it
 15 |     under the terms of the GNU General Public License as published by
 16 |     the Free Software Foundation, either version 3 of the License, or
 17 |     (at your option) any later version.
 18 | 
 19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 22 |     for more details.
 23 | 
 24 |     You should have received a copy of the GNU General Public License
 25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 26 | 
 27 | Class
 28 |     Foam::phaseChangeTwoPhaseMixtures::Merkle
 29 | 
 30 | Description
 31 |     Merkle cavitation model.
 32 | 
 33 |     Reference:
 34 |     \verbatim
 35 |         C. L. Merkle, J. Feng, and P. E. O. Buelow,
 36 |         "Computational modeling of the dynamics of sheet cavitation",
 37 |         in Proceedings Third International Symposium on Cavitation
 38 |         Grenoble, France 1998.
 39 |    \endverbatim
 40 | 
 41 | SourceFiles
 42 |     Merkle.C
 43 | 
 44 | \*--------------------------------------------------------------------*/
 45 | 
 46 | #ifndef Merkle_H
 47 | #define Merkle_H
 48 | 
 49 | #include "phaseChangeTwoPhaseMixture.H"
 50 | 
 51 | // * * * * * * * * * * * * * * * * *  * * * * * * * * * * * * * * * * //
 52 | 
 53 | namespace Foam
 54 | {
 55 | namespace phaseChangeTwoPhaseMixtures
 56 | {
 57 | 
 58 | /*--------------------------------------------------------------------*\
 59 |                               Class Merkle
 60 | \*--------------------------------------------------------------------*/
 61 | 
 62 | class Merkle
 63 | :
 64 |     public phaseChangeTwoPhaseMixture
 65 | {
 66 |     // Private data
 67 | 
 68 |         dimensionedScalar UInf_;
 69 |         dimensionedScalar tInf_;
 70 |         dimensionedScalar Cc_;
 71 |         dimensionedScalar Cv_;
 72 | 
 73 |         dimensionedScalar p0_;
 74 | 
 75 |         dimensionedScalar mcCoeff_;
 76 |         dimensionedScalar mvCoeff_;
 77 | 
 78 | 
 79 | public:
 80 | 
 81 |     //- Runtime type information
 82 |     TypeName("Merkle");
 83 | 
 84 | 
 85 |     // Constructors
 86 | 
 87 |         //- Construct from components
 88 |         Merkle
 89 |         (
 90 |             const volVectorField& U,
 91 |             const surfaceScalarField& phi
 92 |         );
 93 | 
 94 | 
 95 |     //- Destructor
 96 |     virtual ~Merkle() = default;
 97 | 
 98 | 
 99 |     // Member Functions
100 | 
101 |         //- Return the mass condensation and vaporisation rates as a
102 |         //  coefficient to multiply (1 - alphal) for the condensation rate
103 |         //  and a coefficient to multiply  alphal for the vaporisation rate
104 |         virtual Pair<tmp<volScalarField>> mDotAlphal() const;
105 | 
106 |         //- Return the mass condensation and vaporisation rates as coefficients
107 |         //  to multiply (p - pSat)
108 |         virtual Pair<tmp<volScalarField>> mDotP() const;
109 | 
110 |         //- Correct the Merkle phaseChange model
111 |         virtual void correct();
112 | 
113 |         //- Read the transportProperties dictionary and update
114 |         virtual bool read();
115 | };
116 | 
117 | 
118 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
119 | 
120 | } // End namespace phaseChangeTwoPhaseMixtures
121 | } // End namespace Foam
122 | 
123 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
124 | 
125 | #endif
126 | 
127 | // ************************************************************************* //
128 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/Merkle/Merkle.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2017 OpenFOAM Foundation
  9 |     Copyright (C) 2019 OpenCFD Ltd.
 10 | -------------------------------------------------------------------------------
 11 | License
 12 |     This file is part of OpenFOAM.
 13 | 
 14 |     OpenFOAM is free software: you can redistribute it and/or modify it
 15 |     under the terms of the GNU General Public License as published by
 16 |     the Free Software Foundation, either version 3 of the License, or
 17 |     (at your option) any later version.
 18 | 
 19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 22 |     for more details.
 23 | 
 24 |     You should have received a copy of the GNU General Public License
 25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 26 | 
 27 | \*---------------------------------------------------------------------------*/
 28 | 
 29 | #include "Merkle.H"
 30 | #include "addToRunTimeSelectionTable.H"
 31 | 
 32 | // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 33 | 
 34 | namespace Foam
 35 | {
 36 | namespace phaseChangeTwoPhaseMixtures
 37 | {
 38 |     defineTypeNameAndDebug(Merkle, 0);
 39 |     addToRunTimeSelectionTable(phaseChangeTwoPhaseMixture, Merkle, components);
 40 | }
 41 | }
 42 | 
 43 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 44 | 
 45 | Foam::phaseChangeTwoPhaseMixtures::Merkle::Merkle
 46 | (
 47 |     const volVectorField& U,
 48 |     const surfaceScalarField& phi
 49 | )
 50 | :
 51 |     phaseChangeTwoPhaseMixture(typeName, U, phi),
 52 | 
 53 |     UInf_("UInf", dimVelocity, phaseChangeTwoPhaseMixtureCoeffs_),
 54 |     tInf_("tInf", dimTime, phaseChangeTwoPhaseMixtureCoeffs_),
 55 |     Cc_("Cc", dimless, phaseChangeTwoPhaseMixtureCoeffs_),
 56 |     Cv_("Cv", dimless, phaseChangeTwoPhaseMixtureCoeffs_),
 57 | 
 58 |     p0_(pSat().dimensions(), Zero),
 59 | 
 60 |     mcCoeff_(Cc_/(0.5*sqr(UInf_)*tInf_)),
 61 |     mvCoeff_(Cv_*rho1()/(0.5*sqr(UInf_)*tInf_*rho2()))
 62 | {
 63 |     correct();
 64 | }
 65 | 
 66 | 
 67 | // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 68 | 
 69 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
 70 | Foam::phaseChangeTwoPhaseMixtures::Merkle::mDotAlphal() const
 71 | {
 72 |     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
 73 | 
 74 |     return Pair<tmp<volScalarField>>
 75 |     (
 76 |         mcCoeff_*max(p - pSat(), p0_),
 77 |         mvCoeff_*min(p - pSat(), p0_)
 78 |     );
 79 | }
 80 | 
 81 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
 82 | Foam::phaseChangeTwoPhaseMixtures::Merkle::mDotP() const
 83 | {
 84 |     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
 85 |     volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
 86 | 
 87 |     return Pair<tmp<volScalarField>>
 88 |     (
 89 |         mcCoeff_*(1.0 - limitedAlpha1)*pos0(p - pSat()),
 90 |         (-mvCoeff_)*limitedAlpha1*neg(p - pSat())
 91 |     );
 92 | }
 93 | 
 94 | 
 95 | void Foam::phaseChangeTwoPhaseMixtures::Merkle::correct()
 96 | {}
 97 | 
 98 | 
 99 | bool Foam::phaseChangeTwoPhaseMixtures::Merkle::read()
100 | {
101 |     if (phaseChangeTwoPhaseMixture::read())
102 |     {
103 |         phaseChangeTwoPhaseMixtureCoeffs_ = optionalSubDict(type() + "Coeffs");
104 | 
105 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("UInf", UInf_);
106 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("tInf", tInf_);
107 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("Cc", Cc_);
108 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("Cv", Cv_);
109 | 
110 |         mcCoeff_ = Cc_/(0.5*sqr(UInf_)*tInf_);
111 |         mvCoeff_ = Cv_*rho1()/(0.5*sqr(UInf_)*tInf_*rho2());
112 | 
113 |         return true;
114 |     }
115 | 
116 |     return false;
117 | }
118 | 
119 | 
120 | // ************************************************************************* //
121 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubble/RPEqn.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  | 
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | Class
 25 |     Foam::bubble
 26 | 
 27 | Description
 28 |     For solving the RP equation.
 29 |   
 30 | SourceFiles
 31 |     bubbleI.H
 32 |     bubble.C
 33 |     bubbleIO.C
 34 | 
 35 | 
 36 | \*---------------------------------------------------------------------------*/
 37 | 
 38 | //Solve R-P equation for bubbles
 39 | scalar hrk = 1.0E-10;
 40 | scalar h = 0.5*hrk;
 41 | scalar dD = 1.0/(2.0+sqrt(2.0));
 42 | scalar time_rk = 0;
 43 | scalar sigma = cloud.sigma();
 44 | //scalar pV = cloud.pSat();
 45 | scalar substeps = 0;
 46 |  
 47 | while (time_rk < trackTime)
 48 | { 
 49 |  if (time_rk+h > trackTime)
 50 |  {
 51 |     h = trackTime-time_rk;
 52 |  }
 53 | // f
 54 | scalar F0 = Rdt_;
 55 | scalar F1 = -1.5*(Rdt_*Rdt_/R_)+((pB_-pc)/(rhoc*R_))-4.0*(nuc*rhoc)*(Rdt_/(R_*R_))-((2.0*sigma)/(rhoc*R_*R_));
 56 | // f0
 57 | scalar F00 = F0;
 58 | scalar F01 = F1;
 59 | // the jacobian dF/dX
 60 | scalar J00 = 0.0;
 61 | scalar J01 = 1.0;
 62 | scalar J10 = 1.5*((Rdt_*Rdt_)/(R_*R_))-((pB_-pc)/(rhoc*R_*R_))+
 63 | ((8.0*(nuc*rhoc)*Rdt_)/(R_*R_*R_))+((4.0*sigma)/(rhoc*R_*R_*R_));
 64 | scalar J11 = -3.0*Rdt_/R_-4.0*((nuc*rhoc)/(R_*R_));
 65 | // W = I - h dD J
 66 | scalar W00 = 1.0 - h*dD*J00;
 67 | scalar W01 = 0.0 - h*dD*J01;
 68 | scalar W10 = 0.0 - h*dD*J10;
 69 | scalar W11 = 1.0 - h*dD*J11;
 70 | // inv W
 71 | scalar ff = 1.0/(W00*W11-W01*W10);
 72 | scalar invW00 = ff*W11;
 73 | scalar invW01 = -ff*W01;
 74 | scalar invW10 = -ff*W10;
 75 | scalar invW11 = ff*W00;
 76 | // the time derivative of function, dF/dt
 77 | // estimated numerically
 78 | scalar T0 = (F0-F0Old_)/h;
 79 | scalar T1 = (F1-F1Old_)/h;
 80 | // k1
 81 | scalar tmp0 = F00+h*dD*T0;
 82 | scalar tmp1 = F01+h*dD*T1;
 83 | scalar k10 = invW00*tmp0+invW01*tmp1;
 84 | scalar k11 = invW10*tmp0+invW11*tmp1;
 85 | // y_n + 0.5 h k1
 86 | scalar R1 = R_+0.5*h*k10;
 87 | scalar Rdt1 = Rdt_+0.5*h*k11;
 88 | // f1
 89 | scalar F10 = Rdt1;
 90 | scalar F11 = -1.5*(Rdt1*Rdt1/R1)+((pB_ -
 91 | pc)/(rhoc*R1))-4.0*(nuc*rhoc)*(Rdt1/(R1*R1))-((2.0*sigma)/(rhoc*R1*R1));
 92 | // k2
 93 | tmp0 = F10-k10;
 94 | tmp1 = F11-k11;
 95 | scalar k20 = invW00*tmp0+invW01*tmp1+k10;
 96 | scalar k21 = invW10*tmp0+invW11*tmp1+k11;
 97 | // y_n+1
 98 | scalar R2 = R_+h*k20;
 99 | scalar Rdt2 = Rdt_+h*k21;
100 | // f2
101 | scalar F20 = Rdt2;
102 | scalar F21 = -1.5*(Rdt2*Rdt2/R2)+((pB_ -
103 | pc)/(rhoc*R2))-4.0*(nuc*rhoc)*(Rdt2/(R2*R2))-((2.0*sigma)/(rhoc*R2*R2));
104 | 
105 | // k3
106 | scalar b = 6.0 + sqrt(2.0);
107 | tmp0 = F20-b*(k20-F10)-2.0*(k10-F00)+h*dD*T0;
108 | tmp1 = F21-b*(k21-F11)-2.0*(k11-F01)+h*dD*T1;
109 | scalar k30 = invW00*tmp0+invW01*tmp1;
110 | scalar k31 = invW10*tmp0+invW11*tmp1;
111 | // error
112 | scalar err0 = fabs((h/6.0)*(k10-2.0*k20+k30));
113 | scalar err1 = fabs((h/6.0)*(k11-2.0*k21+k31));
114 | scalar err = max(err0,err1);
115 | 
116 | time_rk += h;
117 | substeps += 1;
118 | //scalar absTol = 1.0E-5;
119 | 
120 | if (err > 1.0E-08)
121 | {
122 | h = min(0.5*hrk, 0.5*h);
123 | }
124 | else
125 | {
126 | h = max(1.5*hrk, 1.5*h);
127 | }
128 | // update bubble state
129 | F0Old_ = F0;
130 | F1Old_ = F1;
131 | R_ = R2;
132 | d_ = 2.0*R_;
133 | Rdt_ = Rdt2;
134 | 
135 | if (R_ < R0_)
136 | {
137 |   pG_ = pG0_*pow(R0_/R_,3.0);
138 | }
139 | else
140 | {
141 |   pG_ = pG0_*pow(R0_/R_,3.0*1.4);
142 | }
143 |   pB_ = pG_ + pV;
144 | 
145 | }
146 | // End of R-P equation 
147 | 
148 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/Kunz/Kunz.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2017 OpenFOAM Foundation
  9 |     Copyright (C) 2019 OpenCFD Ltd.
 10 | -------------------------------------------------------------------------------
 11 | License
 12 |     This file is part of OpenFOAM.
 13 | 
 14 |     OpenFOAM is free software: you can redistribute it and/or modify it
 15 |     under the terms of the GNU General Public License as published by
 16 |     the Free Software Foundation, either version 3 of the License, or
 17 |     (at your option) any later version.
 18 | 
 19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 22 |     for more details.
 23 | 
 24 |     You should have received a copy of the GNU General Public License
 25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 26 | 
 27 | \*---------------------------------------------------------------------------*/
 28 | 
 29 | #include "Kunz.H"
 30 | #include "addToRunTimeSelectionTable.H"
 31 | 
 32 | // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 33 | 
 34 | namespace Foam
 35 | {
 36 | namespace phaseChangeTwoPhaseMixtures
 37 | {
 38 |     defineTypeNameAndDebug(Kunz, 0);
 39 |     addToRunTimeSelectionTable(phaseChangeTwoPhaseMixture, Kunz, components);
 40 | }
 41 | }
 42 | 
 43 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 44 | 
 45 | Foam::phaseChangeTwoPhaseMixtures::Kunz::Kunz
 46 | (
 47 |     const volVectorField& U,
 48 |     const surfaceScalarField& phi
 49 | )
 50 | :
 51 |     phaseChangeTwoPhaseMixture(typeName, U, phi),
 52 | 
 53 |     UInf_("UInf", dimVelocity, phaseChangeTwoPhaseMixtureCoeffs_),
 54 |     tInf_("tInf", dimTime, phaseChangeTwoPhaseMixtureCoeffs_),
 55 |     Cc_("Cc", dimless, phaseChangeTwoPhaseMixtureCoeffs_),
 56 |     Cv_("Cv", dimless, phaseChangeTwoPhaseMixtureCoeffs_),
 57 | 
 58 |     p0_(pSat().dimensions(), Zero),
 59 | 
 60 |     mcCoeff_(Cc_*rho2()/tInf_),
 61 |     mvCoeff_(Cv_*rho2()/(0.5*rho1()*sqr(UInf_)*tInf_))
 62 | {
 63 |     correct();
 64 | }
 65 | 
 66 | 
 67 | // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 68 | 
 69 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
 70 | Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotAlphal() const
 71 | {
 72 |     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
 73 |     volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
 74 | 
 75 |     return Pair<tmp<volScalarField>>
 76 |     (
 77 |         mcCoeff_*sqr(limitedAlpha1)
 78 |        *max(p - pSat(), p0_)/max(p - pSat(), 0.01*pSat()),
 79 | 
 80 |         mvCoeff_*min(p - pSat(), p0_)
 81 |     );
 82 | }
 83 | 
 84 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
 85 | Foam::phaseChangeTwoPhaseMixtures::Kunz::mDotP() const
 86 | {
 87 |     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
 88 |     volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
 89 | 
 90 |     return Pair<tmp<volScalarField>>
 91 |     (
 92 |         mcCoeff_*sqr(limitedAlpha1)*(1.0 - limitedAlpha1)
 93 |        *pos0(p - pSat())/max(p - pSat(), 0.01*pSat()),
 94 | 
 95 |         (-mvCoeff_)*limitedAlpha1*neg(p - pSat())
 96 |     );
 97 | }
 98 | 
 99 | 
100 | void Foam::phaseChangeTwoPhaseMixtures::Kunz::correct()
101 | {}
102 | 
103 | 
104 | bool Foam::phaseChangeTwoPhaseMixtures::Kunz::read()
105 | {
106 |     if (phaseChangeTwoPhaseMixture::read())
107 |     {
108 |         phaseChangeTwoPhaseMixtureCoeffs_ = optionalSubDict(type() + "Coeffs");
109 | 
110 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("UInf", UInf_);
111 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("tInf", tInf_);
112 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("Cc", Cc_);
113 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("Cv", Cv_);
114 | 
115 |         mcCoeff_ = Cc_*rho2()/tInf_;
116 |         mvCoeff_ = Cv_*rho2()/(0.5*rho1()*sqr(UInf_)*tInf_);
117 | 
118 |         return true;
119 |     }
120 | 
121 |     return false;
122 | }
123 | 
124 | 
125 | // ************************************************************************* //
126 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/Kunz/Kunz.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2016 OpenFOAM Foundation
  9 |     Copyright (C) 2019 OpenCFD Ltd.
 10 | -------------------------------------------------------------------------------
 11 | License
 12 |     This file is part of OpenFOAM.
 13 | 
 14 |     OpenFOAM is free software: you can redistribute it and/or modify it
 15 |     under the terms of the GNU General Public License as published by
 16 |     the Free Software Foundation, either version 3 of the License, or
 17 |     (at your option) any later version.
 18 | 
 19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 22 |     for more details.
 23 | 
 24 |     You should have received a copy of the GNU General Public License
 25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 26 | 
 27 | Class
 28 |     Foam::phaseChangeTwoPhaseMixtures::Kunz
 29 | 
 30 | Description
 31 |     Kunz cavitation model slightly modified so that the condensation term
 32 |     is switched off when the pressure is less than the saturation vapour
 33 |     pressure.  This change allows the condensation term to be formulated as
 34 |     a coefficient multiplying (p - p_sat) so that it can be included as an
 35 |     implicit term in the pressure equation.
 36 | 
 37 |     Reference:
 38 |     \verbatim
 39 |         Kunz, R.F., Boger, D.A., Stinebring, D.R., Chyczewski, Lindau. J.W.,
 40 |         Gibeling, H.J., Venkateswaran, S., Govindan, T.R.,
 41 |         "A Preconditioned Implicit Method for Two-Phase Flows with Application
 42 |          to Cavitation Prediction,"
 43 |         Computers and Fluids,
 44 |         29(8):849-875, 2000.
 45 |     \endverbatim
 46 | 
 47 | SourceFiles
 48 |     Kunz.C
 49 | 
 50 | \*--------------------------------------------------------------------*/
 51 | 
 52 | #ifndef Kunz_H
 53 | #define Kunz_H
 54 | 
 55 | #include "phaseChangeTwoPhaseMixture.H"
 56 | 
 57 | // * * * * * * * * * * * * * * * * *  * * * * * * * * * * * * * * * * //
 58 | 
 59 | namespace Foam
 60 | {
 61 | namespace phaseChangeTwoPhaseMixtures
 62 | {
 63 | 
 64 | /*--------------------------------------------------------------------*\
 65 |                               Class Kunz
 66 | \*--------------------------------------------------------------------*/
 67 | 
 68 | class Kunz
 69 | :
 70 |     public phaseChangeTwoPhaseMixture
 71 | {
 72 |     // Private data
 73 | 
 74 |         dimensionedScalar UInf_;
 75 |         dimensionedScalar tInf_;
 76 |         dimensionedScalar Cc_;
 77 |         dimensionedScalar Cv_;
 78 | 
 79 |         dimensionedScalar p0_;
 80 | 
 81 |         dimensionedScalar mcCoeff_;
 82 |         dimensionedScalar mvCoeff_;
 83 | 
 84 | 
 85 | public:
 86 | 
 87 |     //- Runtime type information
 88 |     TypeName("Kunz");
 89 | 
 90 | 
 91 |     // Constructors
 92 | 
 93 |         //- Construct from components
 94 |         Kunz
 95 |         (
 96 |             const volVectorField& U,
 97 |             const surfaceScalarField& phi
 98 |         );
 99 | 
100 | 
101 |     //- Destructor
102 |     virtual ~Kunz() = default;
103 | 
104 | 
105 |     // Member Functions
106 | 
107 |         //- Return the mass condensation and vaporisation rates as a
108 |         //  coefficient to multiply (1 - alphal) for the condensation rate
109 |         //  and a coefficient to multiply  alphal for the vaporisation rate
110 |         virtual Pair<tmp<volScalarField>> mDotAlphal() const;
111 | 
112 |         //- Return the mass condensation and vaporisation rates as coefficients
113 |         //  to multiply (p - pSat)
114 |         virtual Pair<tmp<volScalarField>> mDotP() const;
115 | 
116 |         //- Correct the Kunz phaseChange model
117 |         virtual void correct();
118 | 
119 |         //- Read the transportProperties dictionary and update
120 |         virtual bool read();
121 | };
122 | 
123 | 
124 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
125 | 
126 | } // End namespace phaseChangeTwoPhaseMixtures
127 | } // End namespace Foam
128 | 
129 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
130 | 
131 | #endif
132 | 
133 | // ************************************************************************* //
134 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2016 OpenFOAM Foundation
  9 |     Copyright (C) 2019 OpenCFD Ltd.
 10 | -------------------------------------------------------------------------------
 11 | License
 12 |     This file is part of OpenFOAM.
 13 | 
 14 |     OpenFOAM is free software: you can redistribute it and/or modify it
 15 |     under the terms of the GNU General Public License as published by
 16 |     the Free Software Foundation, either version 3 of the License, or
 17 |     (at your option) any later version.
 18 | 
 19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 22 |     for more details.
 23 | 
 24 |     You should have received a copy of the GNU General Public License
 25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 26 | 
 27 | Class
 28 |     Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer
 29 | 
 30 | Description
 31 |     SchnerrSauer cavitation model.
 32 | 
 33 |     Reference:
 34 |     \verbatim
 35 |         Schnerr, G. H., And Sauer, J.,
 36 |         "Physical and Numerical Modeling of Unsteady Cavitation Dynamics",
 37 |         Proc. 4th International Conference on Multiphase Flow,
 38 |         New Orleans, U.S.A., 2001.
 39 |     \endverbatim
 40 | 
 41 | SourceFiles
 42 |     SchnerrSauer.C
 43 | 
 44 | \*--------------------------------------------------------------------*/
 45 | 
 46 | #ifndef SchnerrSauer_H
 47 | #define SchnerrSauer_H
 48 | 
 49 | #include "phaseChangeTwoPhaseMixture.H"
 50 | 
 51 | // * * * * * * * * * * * * * * * * *  * * * * * * * * * * * * * * * * //
 52 | 
 53 | namespace Foam
 54 | {
 55 | namespace phaseChangeTwoPhaseMixtures
 56 | {
 57 | 
 58 | /*--------------------------------------------------------------------*\
 59 |                               Class SchnerrSauer
 60 | \*--------------------------------------------------------------------*/
 61 | 
 62 | class SchnerrSauer
 63 | :
 64 |     public phaseChangeTwoPhaseMixture
 65 | {
 66 |     // Private data
 67 | 
 68 |         //- Bubble number density
 69 |         dimensionedScalar n_;
 70 | 
 71 |         //- Nucleation site diameter
 72 |         dimensionedScalar dNuc_;
 73 | 
 74 |         //- Condensation rate coefficient
 75 |         dimensionedScalar Cc_;
 76 | 
 77 |         //- Vapourisation rate coefficient
 78 |         dimensionedScalar Cv_;
 79 | 
 80 |         dimensionedScalar p0_;
 81 | 
 82 |         //- Nucleation site volume-fraction
 83 |         dimensionedScalar alphaNuc() const;
 84 | 
 85 |         //- Reciprocal bubble radius
 86 |         tmp<volScalarField>rRb(const volScalarField& limitedAlpha1) const;
 87 | 
 88 |         //- Part of the condensation and vapourisation rates
 89 |         tmp<volScalarField> pCoeff(const volScalarField& p) const;
 90 | 
 91 | 
 92 | public:
 93 | 
 94 |     //- Runtime type information
 95 |     TypeName("SchnerrSauer");
 96 | 
 97 | 
 98 |     // Constructors
 99 | 
100 |         //- Construct from components
101 |         SchnerrSauer
102 |         (
103 |             const volVectorField& U,
104 |             const surfaceScalarField& phi
105 |         );
106 | 
107 | 
108 |     //- Destructor
109 |     virtual ~SchnerrSauer() = default;
110 | 
111 | 
112 |     // Member Functions
113 | 
114 |         //- Return the mass condensation and vaporisation rates as a
115 |         //  coefficient to multiply (1 - alphal) for the condensation rate
116 |         //  and a coefficient to multiply  alphal for the vaporisation rate
117 |         virtual Pair<tmp<volScalarField>> mDotAlphal() const;
118 | 
119 |         //- Return the mass condensation and vaporisation rates as coefficients
120 |         //  to multiply (p - pSat)
121 |         virtual Pair<tmp<volScalarField>> mDotP() const;
122 | 
123 |         //- Correct the SchnerrSauer phaseChange model
124 |         virtual void correct();
125 | 
126 |         //- Read the transportProperties dictionary and update
127 |         virtual bool read();
128 | };
129 | 
130 | 
131 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
132 | 
133 | } // End namespace phaseChangeTwoPhaseMixtures
134 | } // End namespace Foam
135 | 
136 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
137 | 
138 | #endif
139 | 
140 | // ************************************************************************* //
141 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/phaseCoupling/phaseCoupling.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software; you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by the
 13 |     Free Software Foundation; either version 2 of the License, or (at your
 14 |     option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM; if not, write to the Free Software Foundation,
 23 |     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 24 | 
 25 | Class
 26 |     Foam::phaseCoupling
 27 | 
 28 | Description
 29 |     Class for the coupling between VoF elements and lagrangian bubbles
 30 |     in the corresponding bubbleCloud.
 31 | 
 32 | Author
 33 |     Dr. Martin Heinrich, all rights reserved
 34 | 
 35 | \*---------------------------------------------------------------------------*/
 36 | 
 37 | #ifndef phaseCoupling_H
 38 | #define phaseCoupling_H
 39 | 
 40 | #include "fvCFD.H"
 41 | #include "vectorList.H"
 42 | #include "bubbleCloud.H"
 43 | #include "bubble.H"
 44 | 
 45 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 46 | 
 47 | namespace Foam
 48 | {
 49 | 
 50 | /*---------------------------------------------------------------------------*\
 51 |                            Class phaseCoupling Declaration
 52 | \*---------------------------------------------------------------------------*/
 53 | 
 54 | class phaseCoupling
 55 | {
 56 |     // Private data
 57 | 
 58 |         //- Reference to mesh and dictionary
 59 |         const fvMesh& mesh_;
 60 |         const IOdictionary dict_;
 61 | 
 62 |         // Reference to velocity field
 63 |         const volVectorField& U_;
 64 | 
 65 |         // Reference to phase fraction field
 66 |         volScalarField& alpha1_;
 67 |         volScalarField& alpha2_;
 68 | 
 69 |         // Reference to lagrangian bubble cloud from solver
 70 |         bubbleCloud& cloud_;
 71 | 
 72 | 	// On/off switch
 73 |         bool active_;
 74 | 
 75 |         // Limit for alpha which counts towards bubbles
 76 |         scalar alphaLimit_;
 77 | 
 78 |         // Lower and upper limit for diameter to inject bubbles
 79 |         scalar dMax_;
 80 | 
 81 |         // Upper limit for sphericity to inject bubbles
 82 |         scalar sphMax_;
 83 | 
 84 |         // Start time
 85 |         scalar startTime_;
 86 | 
 87 |         // Interval for phase coupling
 88 |         label nInterval_;
 89 | 
 90 |         // Marker field to indicate bubble volume ID
 91 |         volScalarField vofID_;
 92 | 
 93 |         // Field for level set function
 94 |         volScalarField psi_;
 95 | 
 96 |         // Damping and source functions for bubble removal/creation
 97 |         volVectorField source_;
 98 |         volScalarField damping_;
 99 |         volScalarField maskalpha1_;
100 |         
101 | 
102 |         //- Check, if neighbours of cellI belong to connected volI
103 |         void checkConnection
104 |         (
105 |             const label cellI,
106 |             const label iter
107 |         );
108 | 
109 |         //- Function to calculate distance to nearest interface
110 |         void levelSetFunction();
111 | 
112 | public:
113 | 
114 |     // Constructors
115 | 
116 |         //- Construct from components
117 |         phaseCoupling
118 |         (
119 |             const volVectorField& U,
120 |             volScalarField& alpha1,
121 |             volScalarField& alpha2,
122 |             bubbleCloud& cloud_ 
123 |         );
124 | 
125 | 
126 |     // Destructor - default
127 | 
128 |     // Member Functions
129 | 
130 |         //- Detect bubbles and convert to bubbles
131 |         void update();
132 | 
133 |         //- Return source for velocity field
134 |         volVectorField source()
135 |         {
136 |             return source_;
137 |         }
138 | 
139 |         //- Return damping for velocity field
140 |         volScalarField damping()
141 |         {
142 |             return damping_;
143 |         }
144 |         volScalarField maskalpha1()
145 |         {
146 |             return maskalpha1_;
147 |         }
148 | 
149 | };
150 | 
151 | 
152 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
153 | 
154 | } // End namespace Foam
155 | 
156 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
157 | 
158 | #endif
159 | 
160 | // ************************************************************************* //
161 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/VOFDBMcavitationFoam.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2017 OpenFOAM Foundation
  9 | -------------------------------------------------------------------------------
 10 | License
 11 |     This file is part of OpenFOAM.
 12 | 
 13 |     OpenFOAM is free software: you can redistribute it and/or modify it
 14 |     under the terms of the GNU General Public License as published by
 15 |     the Free Software Foundation, either version 3 of the License, or
 16 |     (at your option) any later version.
 17 | 
 18 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 19 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 20 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 21 |     for more details.
 22 | 
 23 |     You should have received a copy of the GNU General Public License
 24 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 25 | 
 26 | Application
 27 |     VOFDBMcavitationFoam
 28 | 
 29 | Group
 30 |     grpMultiphaseSolvers
 31 | 
 32 | Description
 33 |     Solver for two incompressible, isothermal immiscible fluids with
 34 |     phase-change (e.g. cavitation).
 35 |     Uses VOF (volume of fluid) phase-fraction based interface capturing.
 36 | 
 37 |     The momentum and other fluid properties are of the "mixture" and a
 38 |     single momentum equation is solved.
 39 | 
 40 |     The set of phase-change models provided are designed to simulate cavitation
 41 |     but other mechanisms of phase-change are supported within this solver
 42 |     framework.
 43 | 
 44 |     Turbulence modelling is generic, i.e. laminar, RAS or LES may be selected.
 45 | 
 46 | \*---------------------------------------------------------------------------*/
 47 | 
 48 | #include "fvCFD.H"
 49 | #include "CMULES.H"
 50 | #include "subCycle.H"
 51 | #include "interfaceProperties.H"
 52 | #include "phaseChangeTwoPhaseMixture.H"
 53 | #include "turbulentTransportModel.H"
 54 | #include "pimpleControl.H"
 55 | #include "fvOptions.H"
 56 | 
 57 | #include "bubbleCloud.H"  //for bubble 
 58 | #include "phaseCoupling.H"
 59 | 
 60 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 61 | 
 62 | int main(int argc, char *argv[])
 63 | {
 64 |     argList::addNote
 65 |     (
 66 |         "Solver for two incompressible, isothermal immiscible fluids with"
 67 |         " phase-change.\n"
 68 |         "Uses VOF (volume of fluid) phase-fraction based interface capturing."
 69 |     );
 70 | 
 71 |     #include "postProcess.H"
 72 | 
 73 |     #include "addCheckCaseOptions.H"
 74 |     #include "setRootCaseLists.H"
 75 |     #include "createTime.H"
 76 |     #include "createMesh.H"
 77 |     #include "createControl.H"
 78 |     #include "createFields.H"
 79 |     #include "createTimeControls.H"
 80 |     #include "CourantNo.H"
 81 |     #include "setInitialDeltaT.H"
 82 | 
 83 |     turbulence->validate();
 84 | 
 85 |     // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 86 | 
 87 |     Info<< "\nStarting time loop\n" << endl;
 88 | 
 89 |     while (runTime.run())
 90 |     {
 91 |         #include "readTimeControls.H"
 92 |         #include "CourantNo.H"
 93 |         #include "setDeltaT.H"
 94 | 
 95 |         ++runTime;
 96 | 
 97 |         Info<< "Time = " << runTime.timeName() << nl << endl;
 98 | 
 99 |         // Store the particle positions
100 |         cloud.storeGlobalPositions();
101 | 
102 |         // Inject bubbles
103 |         coupling.update();
104 | 
105 |         // Move bubbles
106 |         cloud.move();
107 | 
108 |         // --- Pressure-velocity PIMPLE corrector loop
109 |         while (pimple.loop())
110 |         {
111 |             #include "alphaControls.H"
112 | 
113 |             surfaceScalarField rhoPhi
114 |             (
115 |                 IOobject
116 |                 (
117 |                     "rhoPhi",
118 |                     runTime.timeName(),
119 |                     mesh
120 |                 ),
121 |                 mesh,
122 |                 dimensionedScalar(dimMass/dimTime, Zero)
123 |             );
124 | 
125 |             mixture->correct();
126 | 
127 |             #include "alphaEqnSubCycle.H"
128 |             interface.correct();
129 |  
130 |             #include "UEqn.H"
131 | 
132 |             // --- Pressure corrector loop
133 |             while (pimple.correct())
134 |             {
135 |                 #include "pEqn.H"
136 |             }
137 | 
138 |             if (pimple.turbCorr())
139 |             {
140 |                 turbulence->correct();
141 |             }
142 |         }
143 | 
144 |         alpha2 = max(0.0, alpha2 - 1000.0*coupling.maskalpha1());
145 |         alpha1 = min(1.0, alpha1 + 1000.0*coupling.maskalpha1());
146 |         alpha2 = min(1.0, alpha2 + cloud.Addalpha1());
147 |         alpha1 = max(0.0, alpha1 - cloud.Addalpha1());
148 |         
149 |         runTime.write();
150 | 
151 |         runTime.printExecutionTime(Info);
152 |     }
153 | 
154 |     Info<< "End\n" << endl;
155 | 
156 |     return 0;
157 | }
158 | 
159 | 
160 | // ************************************************************************* //
161 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/SchnerrSauer/SchnerrSauer.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2017 OpenFOAM Foundation
  9 |     Copyright (C) 2019 OpenCFD Ltd.
 10 | -------------------------------------------------------------------------------
 11 | License
 12 |     This file is part of OpenFOAM.
 13 | 
 14 |     OpenFOAM is free software: you can redistribute it and/or modify it
 15 |     under the terms of the GNU General Public License as published by
 16 |     the Free Software Foundation, either version 3 of the License, or
 17 |     (at your option) any later version.
 18 | 
 19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 22 |     for more details.
 23 | 
 24 |     You should have received a copy of the GNU General Public License
 25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 26 | 
 27 | \*---------------------------------------------------------------------------*/
 28 | 
 29 | #include "SchnerrSauer.H"
 30 | #include "mathematicalConstants.H"
 31 | #include "addToRunTimeSelectionTable.H"
 32 | 
 33 | // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 34 | 
 35 | namespace Foam
 36 | {
 37 | namespace phaseChangeTwoPhaseMixtures
 38 | {
 39 |     defineTypeNameAndDebug(SchnerrSauer, 0);
 40 |     addToRunTimeSelectionTable
 41 |     (
 42 |         phaseChangeTwoPhaseMixture,
 43 |         SchnerrSauer,
 44 |         components
 45 |     );
 46 | }
 47 | }
 48 | 
 49 | 
 50 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 51 | 
 52 | Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::SchnerrSauer
 53 | (
 54 |     const volVectorField& U,
 55 |     const surfaceScalarField& phi
 56 | )
 57 | :
 58 |     phaseChangeTwoPhaseMixture(typeName, U, phi),
 59 | 
 60 |     n_("n", dimless/dimVolume, phaseChangeTwoPhaseMixtureCoeffs_),
 61 |     dNuc_("dNuc", dimLength, phaseChangeTwoPhaseMixtureCoeffs_),
 62 |     Cc_("Cc", dimless, phaseChangeTwoPhaseMixtureCoeffs_),
 63 |     Cv_("Cv", dimless, phaseChangeTwoPhaseMixtureCoeffs_),
 64 | 
 65 |     p0_(pSat().dimensions(), Zero)
 66 | {
 67 |     correct();
 68 | }
 69 | 
 70 | 
 71 | // * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
 72 | 
 73 | Foam::tmp<Foam::volScalarField>
 74 | Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::rRb
 75 | (
 76 |     const volScalarField& limitedAlpha1
 77 | ) const
 78 | {
 79 |     return pow
 80 |     (
 81 |         ((4*constant::mathematical::pi*n_)/3)
 82 |        *limitedAlpha1/(1.0 + alphaNuc() - limitedAlpha1),
 83 |         1.0/3.0
 84 |     );
 85 | }
 86 | 
 87 | 
 88 | Foam::dimensionedScalar
 89 | Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::alphaNuc() const
 90 | {
 91 |     dimensionedScalar Vnuc = n_*constant::mathematical::pi*pow3(dNuc_)/6;
 92 |     return Vnuc/(1 + Vnuc);
 93 | }
 94 | 
 95 | 
 96 | Foam::tmp<Foam::volScalarField>
 97 | Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::pCoeff
 98 | (
 99 |     const volScalarField& p
100 | ) const
101 | {
102 |     volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
103 |     volScalarField rho
104 |     (
105 |         limitedAlpha1*rho1() + (scalar(1) - limitedAlpha1)*rho2()
106 |     );
107 | 
108 |     return
109 |         (3*rho1()*rho2())*sqrt(2/(3*rho1()))
110 |        *rRb(limitedAlpha1)/(rho*sqrt(mag(p - pSat()) + 0.01*pSat()));
111 | }
112 | 
113 | 
114 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
115 | Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::mDotAlphal() const
116 | {
117 |     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
118 |     volScalarField pCoeff(this->pCoeff(p));
119 | 
120 |     volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
121 | 
122 |     return Pair<tmp<volScalarField>>
123 |     (
124 |         Cc_*limitedAlpha1*pCoeff*max(p - pSat(), p0_),
125 | 
126 |         Cv_*(1.0 + alphaNuc() - limitedAlpha1)*pCoeff*min(p - pSat(), p0_)
127 |     );
128 | }
129 | 
130 | 
131 | Foam::Pair<Foam::tmp<Foam::volScalarField>>
132 | Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::mDotP() const
133 | {
134 |     const volScalarField& p = alpha1_.db().lookupObject<volScalarField>("p");
135 |     volScalarField pCoeff(this->pCoeff(p));
136 | 
137 |     volScalarField limitedAlpha1(min(max(alpha1_, scalar(0)), scalar(1)));
138 |     volScalarField apCoeff(limitedAlpha1*pCoeff);
139 | 
140 |     return Pair<tmp<volScalarField>>
141 |     (
142 |         Cc_*(1.0 - limitedAlpha1)*pos0(p - pSat())*apCoeff,
143 | 
144 |         (-Cv_)*(1.0 + alphaNuc() - limitedAlpha1)*neg(p - pSat())*apCoeff
145 |     );
146 | }
147 | 
148 | 
149 | void Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::correct()
150 | {}
151 | 
152 | 
153 | bool Foam::phaseChangeTwoPhaseMixtures::SchnerrSauer::read()
154 | {
155 |     if (phaseChangeTwoPhaseMixture::read())
156 |     {
157 |         phaseChangeTwoPhaseMixtureCoeffs_ = optionalSubDict(type() + "Coeffs");
158 | 
159 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("n", n_);
160 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("dNuc", dNuc_);
161 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("Cc", Cc_);
162 |         phaseChangeTwoPhaseMixtureCoeffs_.readEntry("Cv", Cv_);
163 | 
164 |         return true;
165 |     }
166 | 
167 |     return false;
168 | }
169 | 
170 | 
171 | // ************************************************************************* //
172 | 


--------------------------------------------------------------------------------
/applications/VOFDBMcavitationFoam/phaseChangeTwoPhaseMixtures/phaseChangeTwoPhaseMixture/phaseChangeTwoPhaseMixture.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | www.openfoam.com
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 |     Copyright (C) 2011-2016 OpenFOAM Foundation
  9 |     Copyright (C) 2019 OpenCFD Ltd.
 10 | -------------------------------------------------------------------------------
 11 | License
 12 |     This file is part of OpenFOAM.
 13 | 
 14 |     OpenFOAM is free software: you can redistribute it and/or modify it
 15 |     under the terms of the GNU General Public License as published by
 16 |     the Free Software Foundation, either version 3 of the License, or
 17 |     (at your option) any later version.
 18 | 
 19 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 20 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 21 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 22 |     for more details.
 23 | 
 24 |     You should have received a copy of the GNU General Public License
 25 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 26 | 
 27 | Class
 28 |     Foam::phaseChangeTwoPhaseMixture
 29 | 
 30 | Description
 31 | 
 32 | SourceFiles
 33 |     phaseChangeTwoPhaseMixture.C
 34 |     newPhaseChangeModel.C
 35 | 
 36 | \*---------------------------------------------------------------------------*/
 37 | 
 38 | #ifndef phaseChangeTwoPhaseMixture_H
 39 | #define phaseChangeTwoPhaseMixture_H
 40 | 
 41 | #include "incompressibleTwoPhaseMixture.H"
 42 | #include "typeInfo.H"
 43 | #include "runTimeSelectionTables.H"
 44 | #include "volFields.H"
 45 | #include "dimensionedScalar.H"
 46 | #include "autoPtr.H"
 47 | #include "Pair.H"
 48 | 
 49 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 50 | 
 51 | namespace Foam
 52 | {
 53 | 
 54 | /*---------------------------------------------------------------------------*\
 55 |                 Class phaseChangeTwoPhaseMixture Declaration
 56 | \*---------------------------------------------------------------------------*/
 57 | 
 58 | class phaseChangeTwoPhaseMixture
 59 | :
 60 |     public incompressibleTwoPhaseMixture
 61 | {
 62 | 
 63 | protected:
 64 | 
 65 |     // Protected data
 66 | 
 67 |         dictionary phaseChangeTwoPhaseMixtureCoeffs_;
 68 | 
 69 |         //- Saturation vapour pressure
 70 |         dimensionedScalar pSat_;
 71 | 
 72 | 
 73 |     // Private Member Functions
 74 | 
 75 |         //- No copy construct
 76 |         phaseChangeTwoPhaseMixture(const phaseChangeTwoPhaseMixture&) = delete;
 77 | 
 78 |         //- No copy assignment
 79 |         void operator=(const phaseChangeTwoPhaseMixture&) = delete;
 80 | 
 81 | 
 82 | public:
 83 | 
 84 |     //- Runtime type information
 85 |     TypeName("phaseChangeTwoPhaseMixture");
 86 | 
 87 | 
 88 |     // Declare run-time constructor selection table
 89 | 
 90 |         declareRunTimeSelectionTable
 91 |         (
 92 |             autoPtr,
 93 |             phaseChangeTwoPhaseMixture,
 94 |             components,
 95 |             (
 96 |                 const volVectorField& U,
 97 |                 const surfaceScalarField& phi
 98 |             ),
 99 |             (U, phi)
100 |         );
101 | 
102 | 
103 |     // Selectors
104 | 
105 |         //- Return a reference to the selected phaseChange model
106 |         static autoPtr<phaseChangeTwoPhaseMixture> New
107 |         (
108 |             const volVectorField& U,
109 |             const surfaceScalarField& phi
110 |         );
111 | 
112 | 
113 |     // Constructors
114 | 
115 |         //- Construct from components
116 |         phaseChangeTwoPhaseMixture
117 |         (
118 |             const word& type,
119 |             const volVectorField& U,
120 |             const surfaceScalarField& phi
121 |         );
122 | 
123 | 
124 |     //- Destructor
125 |     virtual ~phaseChangeTwoPhaseMixture() = default;
126 | 
127 | 
128 |     // Member Functions
129 | 
130 |         //- Return const-access to the saturation vapour pressure
131 |         const dimensionedScalar& pSat() const
132 |         {
133 |             return pSat_;
134 |         }
135 | 
136 |         //- Return the mass condensation and vaporisation rates as a
137 |         //  coefficient to multiply (1 - alphal) for the condensation rate
138 |         //  and a coefficient to multiply  alphal for the vaporisation rate
139 |         virtual Pair<tmp<volScalarField>> mDotAlphal() const = 0;
140 | 
141 |         //- Return the mass condensation and vaporisation rates as coefficients
142 |         //  to multiply (p - pSat)
143 |         virtual Pair<tmp<volScalarField>> mDotP() const = 0;
144 | 
145 |         //- Return the volumetric condensation and vaporisation rates as a
146 |         //  coefficient to multiply (1 - alphal) for the condensation rate
147 |         //  and a coefficient to multiply  alphal for the vaporisation rate
148 |         Pair<tmp<volScalarField>> vDotAlphal() const;
149 | 
150 |         //- Return the volumetric condensation and vaporisation rates as
151 |         //  coefficients to multiply (p - pSat)
152 |         Pair<tmp<volScalarField>> vDotP() const;
153 | 
154 |         //- Correct the phaseChange model
155 |         virtual void correct() = 0;
156 | 
157 |         //- Read the transportProperties dictionary and update
158 |         virtual bool read() = 0;
159 | };
160 | 
161 | 
162 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
163 | 
164 | } // End namespace Foam
165 | 
166 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
167 | 
168 | #endif
169 | 
170 | // ************************************************************************* //
171 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubbleCloud/bubbleCloud.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | Class
 25 |     Foam::bubbleCloud
 26 | 
 27 | Description
 28 |     A cloud of bubbles for the VoF-Lagrangian coupling.
 29 | 
 30 | 
 31 | SourceFiles
 32 |     bubbleCloudI.H
 33 |     bubbleCloud.C
 34 | 
 35 | \*---------------------------------------------------------------------------*/
 36 | 
 37 | #ifndef bubbleCloud_H
 38 | #define bubbleCloud_H
 39 | 
 40 | #include "Cloud.H"
 41 | #include "bubble.H"
 42 | #include "collisionModel.H"
 43 | #include "breakupModel.H"
 44 | #include "IOdictionary.H"
 45 | #include "CompactListList.H"
 46 | 
 47 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 48 | 
 49 | namespace Foam
 50 | {
 51 | 
 52 | // Forward declaration of classes
 53 | class fvMesh;
 54 | 
 55 | /*---------------------------------------------------------------------------*\
 56 |                            Class bubbleCloud Declaration
 57 | \*---------------------------------------------------------------------------*/
 58 | 
 59 | class bubbleCloud
 60 | :
 61 |     public Cloud<bubble>
 62 | {
 63 |     // Private data
 64 | 
 65 |         const fvMesh& mesh_;
 66 | 
 67 |         const dimensionedVector& g_;
 68 |         
 69 |         IOdictionary dict_;
 70 |         IOdictionary particleProperties_;
 71 | 
 72 |         // bubble properties
 73 |         word phaseName_;
 74 |         
 75 |         scalar rhop_;
 76 |         scalar mup_;
 77 |         scalar sigma_;
 78 |         
 79 |         scalar p0_; //
 80 |         scalar pSat_; //added 7-6
 81 |        
 82 |         scalar gamma_;  //
 83 |         vector posP1_;
 84 |         scalar dP1_;
 85 |         vector UP1_;
 86 |         vector posP2_;
 87 |         scalar dP2_;
 88 |         vector UP2_;
 89 |         scalar tInjStart_;
 90 |         scalar tInjEnd_;
 91 |          
 92 |         //- Face zone IDs for postprocessing
 93 |         labelList faceZoneIDs_;
 94 | 
 95 |         //- Word list for face zone names
 96 |         wordList faceZoneNames_;
 97 | 
 98 |         //- Storage for output stream for postprocessing
 99 |         List<autoPtr<OFstream> > cloudDataFilesPtr_;
100 |         
101 |         //- Storage for bubble information for postprocessing
102 |         List<List<DynamicList<scalar> > > dataDiameter_;
103 |         List<List<DynamicList<scalar> > > dataNParticle_;
104 |         List<List<DynamicList<vector> > > dataPosition_;
105 |         
106 |         // Auxiliary field for momentum source
107 |         vectorField source_;
108 |         vectorField Usource_;
109 |         scalarField correctalpha1_;  // 7-99999
110 |            
111 |         // Momentum source for governing equation
112 |         volVectorField momentumSource_;
113 |         volVectorField USource_;
114 |         volScalarField Addalpha1_;  // 7-99999
115 | 
116 |         //- Class for collision calculation
117 |         collisionModel collision_;
118 | 
119 |         //- Class for breakup calculation
120 |         breakupModel breakup_;
121 | 
122 |     // Private Member Functions
123 | 
124 |         //- Create file for bubble postprocessing
125 |         void createbubbleDataFiles();
126 | 
127 |         //- Give a short summary of bubble cloud
128 |         void info();
129 | 
130 |         //- Calculate mean diameter
131 |         Foam::scalar Dij(const label i, const label j);
132 | 
133 |         //- Calculate maximum diameter
134 |         Foam::scalar Dmax();
135 | 
136 | 
137 | public:
138 | 
139 |     // Constructors
140 | 
141 |         //- Construct given mesh
142 |         bubbleCloud
143 |         (
144 |             const fvMesh&,
145 |             const dimensionedVector&, 
146 |             const word& cloudName = "bubbleCloud",
147 |             bool readFields = true
148 |         );
149 | 
150 | 
151 |     // Member Functions
152 | 
153 |         // Access
154 | 
155 |             inline const fvMesh& mesh() const;
156 | 
157 |             inline scalar rhop() const;
158 |             inline scalar e() const;
159 |             inline scalar mup() const;
160 |             inline scalar sigma() const;
161 |             
162 |             inline scalar pSat() const;//added 7-6
163 |              inline scalar RPEqn() const;// RP equation
164 |             inline scalar p0() const;//added 7-6
165 |             inline scalar gamma() const;//added 7-6
166 |              
167 |             // Field to store momentum source
168 |             inline vectorField& source();
169 |             inline vectorField& Usource();
170 |             
171 |             inline scalarField& correctalpha1();  //7-9
172 |             // Return momentum source to carrier phase
173 |             inline const volVectorField& momentumSource();
174 |                  inline const volVectorField& USource(); 
175 |             inline const volScalarField& Addalpha1();
176 |              
177 |             // Return faceZoneIDs for hitFace in bubble
178 |             inline const labelList& faceZoneIDs();
179 |             
180 |             // Return processor data for bubble postprocessing
181 |             inline List<List<DynamicList<scalar> > >& dataDiameter();
182 |             inline List<List<DynamicList<vector> > >& dataPosition();
183 |             inline List<List<DynamicList<scalar> > >& dataNParticle();
184 |             
185 |             
186 | 
187 |         // Edit
188 | 
189 |             //- Move the bubbles under the influence of the given
190 |             //  gravitational acceleration
191 |             void move();//bubbleCloud& cloud);
192 |   
193 |             //- Inject bubbles at a given position with a given
194 |             //  velocity and diameter
195 |             void inject
196 |             (
197 |                 vector position,
198 |                 const scalar diameter,
199 |                 const vector velocity,
200 |                 bubbleCloud& cloud
201 |             );
202 |          
203 |             void injector(bubbleCloud& cloud, bubble::trackingData &td); // For adding particles 
204 |            
205 | };
206 | 
207 | 
208 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
209 | 
210 | } // End namespace Foam
211 | 
212 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
213 | 
214 | #include "bubbleCloudI.H"
215 | 
216 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
217 | 
218 | #endif
219 | 
220 | // ************************************************************************* //
221 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubble/bubbleIO.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | \*---------------------------------------------------------------------------*/
 25 | 
 26 | #include "bubble.H"
 27 | #include "IOstreams.H"
 28 | 
 29 | // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 30 | 
 31 | const std::size_t Foam::bubble::sizeofFields
 32 | (
 33 |     sizeof(bubble) - sizeof(particle)
 34 | );
 35 | 
 36 | 
 37 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 38 | 
 39 | Foam::bubble::bubble
 40 | (
 41 |     const polyMesh& mesh,
 42 |     Istream& is,
 43 |     bool readFields,
 44 |     bool newFormat
 45 | )
 46 | :
 47 |     particle(mesh, is, readFields, newFormat)
 48 | {
 49 |     if (readFields)
 50 |     {
 51 |         if (is.format() == IOstream::ASCII)
 52 |         {
 53 |             d_ = readScalar(is);
 54 |             is >> U_>> Rdt_ >> R_ >> R0_ >> pB_ >> pG_ >> pG0_ >> F0Old_ >> F1Old_;
 55 |             nParticle_ = readScalar(is);
 56 |             y_ = readScalar(is);
 57 |             yDot_ = readScalar(is);
 58 |         }
 59 |         else
 60 |         {
 61 |             is.read(reinterpret_cast<char*>(&d_), 
 62 |             sizeof(d_)
 63 | + sizeof(U_)
 64 | + sizeof(Rdt_)
 65 | + sizeof(R_)
 66 | + sizeof(R0_)
 67 | + sizeof(pB_)
 68 | + sizeof(pG_)
 69 | + sizeof(pG0_)
 70 | + sizeof(F0Old_)
 71 | + sizeof(F1Old_)
 72 | + sizeof(nParticle_)
 73 | + sizeof(y_)
 74 | + sizeof(yDot_));
 75 |               
 76 |             //sizeofFields); //modified try
 77 |         }
 78 |     }
 79 | 
 80 |     is.check(FUNCTION_NAME);
 81 | }
 82 | 
 83 | 
 84 | void Foam::bubble::readFields(Cloud<bubble>& c)
 85 | {
 86 |     bool valid = c.size();
 87 | 
 88 |     particle::readFields(c);
 89 | 
 90 |     IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ), valid);
 91 |     c.checkFieldIOobject(c, d);
 92 | 
 93 |     IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ), valid);
 94 |     c.checkFieldIOobject(c, U);
 95 | 
 96 | IOField<scalar> Rdt(c.fieldIOobject("Rdt", IOobject::MUST_READ), valid);
 97 | c.checkFieldIOobject(c, Rdt);
 98 | IOField<scalar> R(c.fieldIOobject("R", IOobject::MUST_READ), valid);
 99 | c.checkFieldIOobject(c, R);
100 | IOField<scalar> R0(c.fieldIOobject("R0", IOobject::MUST_READ), valid);
101 | c.checkFieldIOobject(c, R0);
102 | IOField<scalar> pB(c.fieldIOobject("pB", IOobject::MUST_READ), valid);
103 | c.checkFieldIOobject(c, pB);
104 | IOField<scalar> pG(c.fieldIOobject("pG", IOobject::MUST_READ), valid);
105 | c.checkFieldIOobject(c, pG);
106 | IOField<scalar> pG0(c.fieldIOobject("pG0", IOobject::MUST_READ), valid);
107 | c.checkFieldIOobject(c, pG0);
108 | IOField<scalar> F0Old(c.fieldIOobject("F0Old", IOobject::MUST_READ), valid);
109 | c.checkFieldIOobject(c, F0Old);
110 | IOField<scalar> F1Old(c.fieldIOobject("F1Old", IOobject::MUST_READ), valid);
111 | c.checkFieldIOobject(c, F1Old);
112 | 
113 |     IOField<scalar> nParticle(c.fieldIOobject("nParticle", IOobject::MUST_READ), valid);
114 |     c.checkFieldIOobject(c, nParticle);
115 | 
116 |     IOField<scalar> y(c.fieldIOobject("y", IOobject::MUST_READ), valid);
117 |     c.checkFieldIOobject(c, y);
118 | 
119 |     IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::MUST_READ), valid);
120 |     c.checkFieldIOobject(c, yDot);
121 | 
122 |     label i = 0;
123 |     forAllIter(Cloud<bubble>, c, iter)
124 |     {
125 |         bubble& p = iter();
126 | 
127 |         p.d_ = d[i];
128 |         p.U_ = U[i];
129 |         
130 | p.Rdt_ = Rdt[i];
131 | p.R_ = R[i];
132 | p.R0_ = R0[i];
133 | p.pB_ = pB[i];
134 | p.pG_ = pG[i];
135 | p.pG0_ = pG0[i];
136 | p.F0Old_ = F0Old[i];
137 | p.F1Old_ = F1Old[i];  
138 | 
139 |         p.nParticle_ = nParticle[i];
140 |         p.y_ = y[i];
141 |         p.yDot_ = yDot[i];
142 |         i++;
143 |     }
144 | }
145 | 
146 | 
147 | void Foam::bubble::writeFields(const Cloud<bubble>& c)
148 | {
149 |     particle::writeFields(c);
150 | 
151 |     label np = c.size();
152 | 
153 |     IOField<scalar> d(c.fieldIOobject("d", IOobject::NO_READ), np);
154 |     IOField<vector> U(c.fieldIOobject("U", IOobject::NO_READ), np);
155 |     
156 | IOField<scalar> Rdt(c.fieldIOobject("Rdt", IOobject::NO_READ), np);
157 | IOField<scalar> R(c.fieldIOobject("R", IOobject::NO_READ), np);
158 | IOField<scalar> R0(c.fieldIOobject("R0", IOobject::NO_READ), np);
159 | IOField<scalar> pB(c.fieldIOobject("pB", IOobject::NO_READ), np);
160 | IOField<scalar> pG(c.fieldIOobject("pG", IOobject::NO_READ), np);
161 | IOField<scalar> pG0(c.fieldIOobject("pG0", IOobject::NO_READ), np);
162 | IOField<scalar> F0Old(c.fieldIOobject("F0Old", IOobject::NO_READ), np);
163 | IOField<scalar> F1Old(c.fieldIOobject("F1Old", IOobject::NO_READ), np);
164 |      
165 |     IOField<scalar> nParticle(c.fieldIOobject("nParticle", IOobject::NO_READ), np);
166 |     IOField<scalar> y(c.fieldIOobject("y", IOobject::NO_READ), np);
167 |     IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::NO_READ), np);
168 | 
169 |     label i = 0;
170 |     forAllConstIter(Cloud<bubble>, c, iter)
171 |     {
172 |         const bubble& p = iter();
173 | 
174 |         d[i] = p.d_;
175 |         U[i] = p.U_;
176 |         
177 | Rdt[i] = p.Rdt_;
178 | R[i] = p.R_;
179 | R0[i] = p.R0_;
180 | pB[i] = p.pB_;
181 | pG[i] = p.pG_;
182 | pG0[i] = p.pG0_;
183 | F0Old[i] = p.F0Old_;
184 | F1Old[i] =p.F1Old_;
185 |         
186 |         nParticle[i] = p.nParticle_;
187 |         y[i] = p.y_;
188 |         yDot[i] = p.yDot_;
189 |         i++;
190 |     }
191 | 
192 |     d.write(np > 0);
193 |     U.write(np > 0);
194 |     
195 | Rdt.write(np > 0);
196 | R.write(np > 0);
197 | R0.write(np > 0);
198 | pB.write(np > 0);
199 | pG.write(np > 0);
200 | pG0.write(np > 0);
201 | F0Old.write(np > 0);
202 | F1Old.write(np > 0);
203 |     
204 |     nParticle.write(np > 0);
205 |     y.write(np > 0);
206 |     yDot.write(np > 0);
207 | }
208 | 
209 | 
210 | // * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
211 | 
212 | Foam::Ostream& Foam::operator<<(Ostream& os, const bubble& p)
213 | {
214 |     if (os.format() == IOstream::ASCII)
215 |     {
216 |         os  << static_cast<const particle&>(p)
217 |             << token::SPACE << p.d_
218 |             << token::SPACE << p.U_
219 |             
220 |             << token::SPACE << p.Rdt_
221 |             << token::SPACE << p.R_
222 |             << token::SPACE << p.R0_
223 |             << token::SPACE << p.pB_
224 |             << token::SPACE << p.pG_
225 |             << token::SPACE << p.pG0_
226 |             << token::SPACE << p.F0Old_
227 |             << token::SPACE << p.F1Old_
228 |             
229 |             << token::SPACE << p.nParticle_;
230 |     }
231 |     else
232 |     {
233 |         os  << static_cast<const particle&>(p);
234 |         os.write
235 |         (
236 |             reinterpret_cast<const char*>(&p.d_),
237 | sizeof(p.d_)
238 | + sizeof(p.U_)
239 | + sizeof(p.Rdt_)
240 | + sizeof(p.R_)
241 | + sizeof(p.R0_)
242 | + sizeof(p.pB_)
243 | + sizeof(p.pG_)
244 | + sizeof(p.pG0_)
245 | + sizeof(p.F0Old_)
246 | + sizeof(p.F1Old_)
247 | + sizeof(p.nParticle_)
248 | + sizeof(p.y_)
249 | + sizeof(p.yDot_)
250 |  
251 |     //bubble::sizeofFields
252 |         );
253 |     }
254 | 
255 |     os.check(FUNCTION_NAME);
256 |     return os;
257 | }
258 | 
259 | 
260 | // ************************************************************************* //
261 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubble/bubble.H:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  | 
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | Class
 25 |     Foam::bubble
 26 | 
 27 | Description
 28 |     Spherical bubble class with optional two-way coupling with the
 29 |     continuous phase, bubble-bubble collision, and breakup..
 30 | 
 31 | SourceFiles
 32 |     bubbleI.H
 33 |     bubble.C
 34 |     bubbleIO.C
 35 | 
 36 | \*---------------------------------------------------------------------------*/
 37 | 
 38 | #ifndef bubble_H
 39 | #define bubble_H
 40 | 
 41 | #include "particle.H"
 42 | #include "IOstream.H"
 43 | #include "autoPtr.H"
 44 | #include "interpolationCellPoint.H"
 45 | #include "interpolationCell.H" //
 46 | #include "contiguous.H"
 47 | 
 48 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 49 | 
 50 | namespace Foam
 51 | {
 52 | 
 53 | class bubbleCloud;
 54 | 
 55 | 
 56 | // Forward declaration of friend functions and operators
 57 | 
 58 | class bubble;
 59 | 
 60 | Ostream& operator<<(Ostream&, const bubble&);
 61 | 
 62 | 
 63 | /*---------------------------------------------------------------------------*\
 64 |                            Class bubble Declaration
 65 | \*---------------------------------------------------------------------------*/
 66 | 
 67 | class bubble
 68 | :
 69 |     public particle
 70 | {
 71 |     // Private data
 72 | 
 73 |         //- Diameter
 74 |         scalar d_;
 75 | 
 76 |         //- Velocity of particle
 77 |         vector U_;
 78 | 
 79 | //- temporal derivative of the Radius
 80 | scalar Rdt_;
 81 | //- Radius
 82 | scalar R_;
 83 | //- Initial equilibirium radius
 84 | scalar R0_;
 85 | //- bubble inside pressure
 86 | scalar pB_;
 87 | //- dissolved gas pressure
 88 | scalar pG_;
 89 | scalar pG0_;
 90 | scalar F0Old_;
 91 | scalar F1Old_;
 92 | //added
 93 |         //- Number of particles in parcel
 94 |         scalar nParticle_;
 95 | 
 96 |         //- Spherical deviation
 97 | 	scalar y_;
 98 | 
 99 | 	//- Rate of change of spherical deviation
100 | 	scalar yDot_;
101 | 
102 | public:
103 | 
104 |     friend class Cloud<bubble>;
105 | 
106 |     //- Class used to pass tracking data to the trackToFace function
107 |     class trackingData
108 |     :
109 |         public particle::trackingData
110 |     {
111 |         // Interpolators for continuous phase fields
112 | 
113 |             const interpolationCellPoint<scalar>& rhoInterp_;
114 |             const interpolationCellPoint<vector>& UInterp_;
115 |             const interpolationCellPoint<scalar>& nuInterp_;
116 |             const interpolationCell<scalar>& alpha1Interp_; //
117 |             const interpolationCellPoint<scalar>& pInterp_; // 7-6
118 | 
119 |         //- Local gravitational or other body-force acceleration
120 |         const vector& g_;
121 | 
122 | 
123 |     public:
124 | 
125 |         // Constructors
126 | 
127 |             inline trackingData
128 |             (
129 |                 const bubbleCloud& spc,
130 |                 const interpolationCellPoint<scalar>& rhoInterp,
131 |                 const interpolationCellPoint<vector>& UInterp,
132 |                 const interpolationCellPoint<scalar>& nuInterp,
133 |                 const interpolationCell<scalar>& alpha1Interp, //     
134 |                 const interpolationCellPoint<scalar>& pInterp_, // 7-6
135 |                 const vector& g
136 |             );
137 | 
138 | 
139 |         // Member functions
140 | 
141 |             inline const interpolationCellPoint<scalar>& rhoInterp() const;
142 | 
143 |             inline const interpolationCellPoint<vector>& UInterp() const;
144 | 
145 |             inline const interpolationCellPoint<scalar>& nuInterp() const;
146 |             
147 |             inline const interpolationCell<scalar>& alpha1Interp() const; //    
148 |             inline const interpolationCellPoint<scalar>& pInterp() const; // 7-6
149 | 
150 |             inline const vector& g() const;
151 |     };
152 | 
153 | 
154 |     // Static data members
155 | 
156 |         //- Size in bytes of the fields
157 |         static const std::size_t sizeofFields;
158 | 
159 | 
160 |     // Constructors
161 | 
162 |         //- Construct from components
163 |         inline bubble
164 |         (
165 |             const polyMesh& mesh,
166 |             const vector& position,
167 |             const label celli,
168 |             const scalar d,
169 |             const vector& U
170 |         );
171 | 
172 |         //- Construct from Istream
173 |         bubble
174 |         (
175 |             const polyMesh& mesh,
176 |             Istream& is,
177 |             bool readFields = true,
178 |             bool newFormat = true
179 |         );
180 | 
181 |         //- Construct and return a clone
182 |         virtual autoPtr<particle> clone() const
183 |         {
184 |             return autoPtr<particle>(new bubble(*this));
185 |         }
186 | 
187 |         //- Factory class to read-construct particles used for
188 |         //  parallel transfer
189 |         class iNew
190 |         {
191 |             const polyMesh& mesh_;
192 | 
193 |         public:
194 | 
195 |             iNew(const polyMesh& mesh)
196 |             :
197 |                 mesh_(mesh)
198 |             {}
199 | 
200 |             autoPtr<bubble> operator()(Istream& is) const
201 |             {
202 |                 return autoPtr<bubble>
203 |                 (
204 |                     new bubble(mesh_, is, true)
205 |                 );
206 |             }
207 |         };
208 | 
209 | 
210 |     // Member Functions
211 | 
212 |         // Access
213 | 
214 |             //- Return diameter
215 |             inline scalar& d();
216 | 
217 |             //- Return velocity
218 |             inline vector& U();
219 | 
220 |             //- Return number of particles in parcel
221 |             inline scalar& nParticle();
222 | 
223 |             //- Return spherical deviation
224 |             inline scalar& y();
225 | 
226 |             //- Return change of rate of spherical deviation
227 |             inline scalar& yDot();
228 | 
229 | 
230 |         // Tracking
231 | bool initialEquilibriumRadius(bubbleCloud& cloud, trackingData& td); //add 7-6
232 | 
233 |             //- Move
234 |             bool move(bubbleCloud&, trackingData&, const scalar);
235 | 
236 | 
237 |         // Patch interactions
238 | 
239 |             //- Overridable function to handle the particle hitting a patch
240 |             //  Executed before other patch-hitting functions
241 |             bool hitPatch(bubbleCloud& cloud, trackingData& td);
242 | 
243 |             //- Overridable function to handle the particle hitting a
244 |             //  processorPatch
245 |             void hitProcessorPatch(bubbleCloud& cloud, trackingData& td);
246 | 
247 |             //- Overridable function to handle the particle hitting a wallPatch
248 |             void hitWallPatch(bubbleCloud& cloud, trackingData& td);
249 | 
250 |             //- Transform the physical properties of the particle
251 |             //  according to the given transformation tensor
252 |             virtual void transformProperties(const tensor& T);
253 | 
254 |             //- Transform the physical properties of the particle
255 |             //  according to the given separation vector
256 |             virtual void transformProperties(const vector& separation);
257 | 
258 | 
259 |     // I-O
260 | 
261 |         static void readFields(Cloud<bubble>& c);
262 | 
263 |         static void writeFields(const Cloud<bubble>& c);
264 | 
265 | 
266 |     // Ostream Operator
267 | 
268 |         friend Ostream& operator<<(Ostream&, const bubble&);
269 | };
270 | 
271 | //- Contiguous data for solidParticle
272 | template<> struct is_contiguous<bubble> : std::true_type {};
273 | 
274 | 
275 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
276 | 
277 | } // End namespace Foam
278 | 
279 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
280 | 
281 | #include "bubbleI.H"
282 | 
283 | // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
284 | 
285 | #endif
286 | 
287 | // ************************************************************************* //
288 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubbleCloud/collisionModel.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | \*---------------------------------------------------------------------------*/
 25 | 
 26 | #include "bubbleCloud.H"
 27 | #include "collisionModel.H"
 28 | 
 29 | 
 30 | // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 31 | 
 32 | 
 33 | bool Foam::collisionModel::collidebubbles
 34 | (
 35 |     const scalar dt,
 36 |     bubble& p1,
 37 |     bubble& p2,
 38 |     scalar& m1,
 39 |     scalar& m2
 40 | )
 41 | {
 42 |     bool coalescence = false;
 43 | 
 44 |     const vector pos1(p1.position());
 45 |     const vector pos2(p2.position());
 46 | 
 47 |     const vector& U1 = p1.U();
 48 |     const vector& U2 = p2.U();
 49 | 
 50 |     vector URel(U1 - U2);
 51 | 
 52 |     vector d(pos2 - pos1);
 53 |     scalar magd = mag(d);
 54 | 
 55 |     scalar vAlign = URel & (d/(magd + ROOTVSMALL));
 56 | 
 57 |     // bubbles travel towards each other
 58 |     if (vAlign > 0)
 59 |     {
 60 |         const scalar d1 = p1.d();
 61 |         const scalar d2 = p2.d();
 62 | 
 63 |         scalar sumD = d1 + d2;
 64 | 
 65 |         if (vAlign*dt > magd - 0.5*sumD)
 66 |         {
 67 |             scalar magU1 = mag(U1) + ROOTVSMALL;
 68 |             scalar magU2 = mag(U2) + ROOTVSMALL;
 69 |             vector n1 = U1/magU1;
 70 |             vector n2 = U2/magU2;
 71 | 
 72 |             scalar n1n2 = n1 & n2;
 73 |             scalar n1d = n1 & d;
 74 |             scalar n2d = n2 & d;
 75 | 
 76 |             scalar det = 1.0 - sqr(n1n2);
 77 | 
 78 |             scalar alpha = GREAT;
 79 |             scalar beta = GREAT;
 80 | 
 81 |             if (mag(det) > 1.0e-4)
 82 |             {
 83 |                 beta = -(n2d - n1n2*n1d)/det;
 84 |                 alpha = n1d + n1n2*beta;
 85 |             }
 86 | 
 87 |             alpha /= magU1*dt;
 88 |             beta /= magU2*dt;
 89 | 
 90 |             // Check if collision is possible within this timestep
 91 |             if ((alpha > 0) && (alpha < 1.0) && (beta > 0) && (beta < 1.0))
 92 |             {
 93 |                 vector p1c = pos1 + alpha*U1*dt;
 94 |                 vector p2c = pos2 + beta*U2*dt;
 95 | 
 96 |                 scalar closestDist = mag(p1c - p2c);
 97 | 
 98 |                 scalar collProb =
 99 |                     pow(0.5*sumD/max(0.5*sumD, closestDist), cSpace_)
100 |                    *exp(-cTime_*mag(alpha - beta));
101 |                 scalar prob = ranGen_.sample01<scalar>();
102 | 
103 | 		// collision occurs
104 |                 if (prob < collProb)
105 |                 {
106 |                     if (d1 > d2)
107 |                     {
108 |                         coalescence = this->collideSorted(dt, p1, p2, m1, m2);
109 |                     }
110 |                     else
111 |                     {
112 |                         coalescence = this->collideSorted(dt, p2, p1, m2, m1);
113 |                     }
114 |                 }
115 |             }
116 |         }
117 |     }
118 | 
119 |     return coalescence;
120 | }
121 | 
122 | 
123 | bool Foam::collisionModel::collideSorted
124 | (
125 |     const scalar dt,
126 |     bubble& p1,
127 |     bubble& p2,
128 |     scalar& m1,
129 |     scalar& m2
130 | )
131 | {
132 |     const scalar d1 = p1.d();
133 |     const scalar d2 = p2.d();
134 | 
135 |     const vector& U1 = p1.U();
136 |     const vector& U2 = p2.U();
137 | 
138 |     vector URel = U1 - U2;
139 |     scalar magURel = mag(URel);
140 | 
141 |     scalar mTot = m1 + m2;
142 | 
143 |     scalar gamma = d1/max(ROOTVSMALL, d2);
144 |     scalar f = pow3(gamma) + 2.7*gamma - 2.4*sqr(gamma);
145 | 
146 |     scalar dAve = sqrt(d1*d2);
147 |     scalar WeColl = 0.5*rhop_*sqr(magURel)*dAve/max(ROOTVSMALL, sigma_);
148 | 
149 |     scalar coalesceProb = min(1.0, 2.4*f/max(ROOTVSMALL, WeColl));
150 |     scalar prob = ranGen_.sample01<scalar>();
151 | 
152 |     // Coalescence
153 |     if (prob < coalesceProb)
154 |     {
155 |         p1.U() = (m1*U1 + m2*U2)/(m1+m2);
156 |         
157 |         m1 += m2;
158 |         m2 = -1;
159 | 
160 |         return true;
161 |     }
162 |     // Stretching separation
163 |     else
164 |     {
165 |         scalar gf = sqrt(prob) - sqrt(coalesceProb);
166 |         scalar denom = 1.0 - sqrt(coalesceProb);
167 |         if (denom < 1.0e-5)
168 |         {
169 |             denom = 1.0;
170 |         }
171 |         gf /= denom;
172 | 
173 |         // If gf negative, this means that coalescence is turned off
174 |         // and these parcels should have coalesced
175 |         gf = max(0.0, gf);
176 | 
177 |         vector mr = m1*U1 + m2*U2;
178 |         vector v1p = (mr + m2*gf*URel)/mTot;
179 |         vector v2p = (mr - m1*gf*URel)/mTot;
180 | 
181 |         p1.U() = v1p;
182 |         p2.U() = v2p;        
183 | 
184 | 	return false;
185 |     }
186 | }
187 | 
188 | 
189 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
190 | 
191 | 
192 | Foam::collisionModel::collisionModel
193 | (
194 |     const fvMesh& mesh
195 | )
196 | :
197 |     mesh_(mesh),
198 |     dict_
199 |     (
200 |         IOobject
201 |         (
202 |             "cloudProperties",
203 |             mesh_.time().constant(),
204 |             mesh_,
205 |             IOobject::MUST_READ_IF_MODIFIED,
206 |             IOobject::NO_WRITE
207 |         )
208 |     ),
209 |     active_(readBool(dict_.lookup("collision"))),
210 |     ranGen_(clock::getTime() + pid()),
211 |     cTime_(dict_.lookupOrDefault("cTime", 1.0)),
212 |     cSpace_(dict_.lookupOrDefault("cSpace", 0.3)),
213 |     rhop_(0.0),
214 |     sigma_(0.0)
215 | {
216 | }
217 | 
218 | 
219 | // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
220 | 
221 | 
222 | void Foam::collisionModel::update
223 | (
224 |     bubbleCloud& cloud,
225 |     const scalar dt
226 | )
227 | {
228 |     if (!active_)
229 |     {
230 |         return;
231 |     }
232 | 
233 |     // Store cloud bubble properties
234 |     rhop_ = cloud.rhop();
235 |     sigma_ = cloud.sigma();
236 | 
237 |     // Create pointer to cloud
238 |     bubbleCloud *ptrCloud = const_cast<bubbleCloud*>(&cloud);    
239 | 
240 |     // Create the occupancy list for the cells
241 |     labelList occupancy(mesh_.nCells(), 0);
242 |     forAllIter(Cloud<bubble>, *ptrCloud,  iter)
243 |     {
244 |         occupancy[iter().cell()]++;
245 |     }
246 | 
247 |     // Initialize the sizes of the lists of parcels in each cell
248 |     CompactListList<bubble*> pInCell(occupancy);
249 | 
250 |     // Reset the occupancy to use as a counter
251 |     occupancy = 0;
252 | 
253 |     // Set the parcel pointer lists for each cell
254 |     forAllIter(Cloud<bubble>, *ptrCloud, iter)
255 |     {
256 |         pInCell(iter().cell(), occupancy[iter().cell()]++) = &iter();
257 |     }
258 | 
259 |     // Perform bubble-bubble collision per cell
260 |     for (label celli=0; celli < mesh_.nCells(); celli++)
261 |     {
262 |         UList<bubble*> pInCelli(pInCell[celli]);
263 | 
264 |         if (pInCelli.size() >= 2)
265 |         {
266 |             forAll(pInCelli, i)
267 |             {
268 |                 for (label j=i+1; j<pInCelli.size(); j++)
269 |                 {
270 |                     bubble& p1 = *pInCelli[i];
271 |                     bubble& p2 = *pInCelli[j];
272 | 
273 |                     scalar m1 = rhop_*(4.0/3.0)*constant::mathematical::pi*pow(p1.d()/2.0, 3.0);
274 |                     scalar m2 = rhop_*(4.0/3.0)*constant::mathematical::pi*pow(p2.d()/2.0, 3.0);
275 | 
276 |                     bool massChanged = collidebubbles(dt, p1, p2, m1, m2);
277 |     
278 |                     if (massChanged)
279 |                     {
280 |                         if (m1 > ROOTVSMALL)
281 |                         {
282 |                             p1.d() = cbrt(6.0*m1/(rhop_*constant::mathematical::pi));
283 |                         }
284 |                         else
285 |                         {
286 |                             p1.d() = -1;
287 |                         }
288 |                         if (m2 > ROOTVSMALL)
289 |                         {
290 |                             p2.d() = cbrt(6.0*m2/(rhop_*constant::mathematical::pi));
291 |                         }
292 |                         else
293 |                         {
294 |                             p2.d() = -1;
295 |                         }
296 |                     }
297 |                 }
298 |             }
299 |         }
300 |     }
301 | 
302 |     // Delete all bubbles with negative diameter
303 |     forAllIter(Cloud<bubble>, *ptrCloud, iter)
304 |     {
305 |         bubble& p = iter();
306 |         
307 |         if (p.d() < VSMALL)
308 |         {
309 |             cloud.deleteParticle(p);
310 |         }
311 |     }
312 | }
313 | 
314 | // ************************************************************************* //
315 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubble/bubble.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | \*---------------------------------------------------------------------------*/
 25 | 
 26 | #include "bubbleCloud.H"
 27 | 
 28 | // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 29 | 
 30 | namespace Foam
 31 | {
 32 |     defineTemplateTypeNameAndDebug(Cloud<bubble>, 0);
 33 | }
 34 | 
 35 | // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 36 | 
 37 | bool Foam::bubble::move
 38 | (
 39 |     bubbleCloud& cloud,
 40 |     trackingData& td, 
 41 |     const scalar trackTime
 42 | )
 43 | {
 44 |     td.switchProcessor = false;
 45 |     td.keepParticle = true;
 46 |      
 47 | 
 48 |     while (td.keepParticle && !td.switchProcessor && stepFraction() < 1)
 49 |     {
 50 |         if (debug)
 51 |         {
 52 |             Info<< "Time = " << mesh().time().timeName()
 53 |                 << " trackTime = " << trackTime
 54 |                 << " steptFraction() = " << stepFraction() << endl;
 55 |         }
 56 | 
 57 |         const scalar sfrac = stepFraction();
 58 | 
 59 |         const scalar f = 1 - stepFraction();
 60 |         trackToAndHitFace(f*trackTime*U_, f, cloud, td);
 61 | 
 62 |         const scalar dt = (stepFraction() - sfrac)*trackTime;
 63 | 
 64 |         const tetIndices tetIs = this->currentTetIndices();
 65 |         scalar rhoc = td.rhoInterp().interpolate(this->coordinates(), tetIs);
 66 |         vector Uc = td.UInterp().interpolate(this->coordinates(), tetIs);
 67 |         scalar nuc = td.nuInterp().interpolate(this->coordinates(), tetIs);
 68 |         //scalar alpha1P = td.alpha1Interp().interpolate(this->coordinates(), tetIs);//
 69 |         scalar pc = td.pInterp().interpolate(this->coordinates(), tetIs);//
 70 | 
 71 |         scalar rhop = cloud.rhop();
 72 |         scalar magUr = mag(Uc - U_);
 73 | 
 74 |         //    label cellI = cell();
 75 | 
 76 |         scalar ReFunc = 1.0;
 77 |         scalar Re = magUr*d_/nuc;
 78 |         
 79 |         if (Re >= 0.1 && Re <= 1000.0)
 80 |         {
 81 |             ReFunc += 0.15*pow(Re, 0.687);
 82 |         }
 83 |         if (Re > 1000.0)
 84 |         { 
 85 |             ReFunc = Re/24.0*0.44;
 86 |         }
 87 | 
 88 |         scalar Dc = (24.0*nuc/d_)*ReFunc*(3.0/4.0)*(rhoc/(d_*rhop));
 89 |         
 90 |         // calculate momentum
 91 |         scalar m = rhop*(4.0/3.0)*constant::mathematical::pi*pow(d_/2.0, 3.0);
 92 |         vector i1 = U_*m;
 93 |         
 94 |         U_ = (U_ + dt*(Dc*Uc + (1.0 - rhoc/rhop)*td.g()))/(1.0 + dt*Dc);
 95 | 
 96 | //For bubble size variation
 97 |     scalar pV = cloud.pSat();
 98 |     
 99 |     if (cloud.RPEqn() == 1)
100 |     {
101 |        #include "RPEqn.H"
102 |     }
103 |     else 
104 |     {
105 |        if( pc > 1.25*pV )
106 |        {
107 |           d_ = max(0.000001, d_- 0.01*sqrt(0.66*(pc - 1.25*pV)/rhoc)*dt);
108 |        }
109 |        else
110 |        {
111 |           d_ = min(0.02, d_+ 0.5*sqrt(0.66*(1.25*pV - pc)/rhoc)*dt); 
112 |        } 
113 |     }
114 |     
115 | //LPT to VOF by Linmin Li, it is not suggested for phasechange cases
116 | bool nearInterface = false;
117 | 
118 | vector posP = position(); 
119 | label cellP = mesh().findCell(posP);
120 |         if (mag(i1) > 0.0)
121 |         { 
122 |               cloud.source()[cellP] += - (U_*m - i1 - m * (1.0 - rhoc/rhop) * td.g() * dt); 
123 |         }
124 | scalar alpha1P = td.alpha1Interp().interpolate(posP, cellP);
125 | scalar distanceP = d_/2.0;
126 | for (int j=0; j<6; j++)
127 | {
128 |   int sign=pow(-1,j);
129 |   int coord=j/2;
130 |   vector possurfP=posP;
131 |   possurfP.component(coord) += sign * distanceP ;
132 |   label cellsurfP = mesh().findCell(possurfP);
133 |   if (cellsurfP != (-1))
134 |    {
135 |     scalar alpha1surfP = td.alpha1Interp().interpolate(possurfP, cellsurfP);
136 |     if (alpha1surfP >= 0.5)
137 |      {
138 |        nearInterface = true;
139 |      }
140 |    }
141 | }
142 | 
143 | scalar VPleft;
144 | scalar VdispoCellP;
145 |  
146 | if (nearInterface)
147 | {
148 |    VPleft=pow(d_,3)*Foam::constant::mathematical::pi/6.0;
149 |    VdispoCellP = (1.0-alpha1P)*mesh().cellVolumes()[cellP];
150 | 
151 |    if (VPleft <= VdispoCellP)
152 |    //fill only the eulerian cell at the particle position
153 |    {
154 |        cloud.correctalpha1()[cellP] += VPleft/mesh().cellVolumes()[cellP]; 
155 |        cloud.Usource()[cellP] = (U_-Uc)/dt; 
156 |    }
157 |    else
158 |   // start to fill the neighbour cells
159 |    {
160 |       cloud.correctalpha1()[cellP] = 1.0; 
161 |       
162 |       cloud.Usource()[cellP] = (U_-Uc)/dt; 
163 |       
164 |       // Create dynamic list to store all neighbours
165 |       DynamicList<label> cells(0);
166 |       // Get neighbours of particle Cell
167 |       cells.append(mesh().cellCells()[cellP]);
168 |  
169 |         // Loop over all current neighbours
170 |         forAll(cells, i)
171 |         {
172 |               label cellIn = cells[i]; 
173 |             
174 |          }
175 |    }
176 |    td.keepParticle = false;
177 | }  
178 | //End of LPT to VOF transition 
179 | 
180 | 
181 | if (d_<=0.000001 || d_>=0.001 || alpha1P>0.8)
182 | {
183 |      td.keepParticle = false;
184 | }
185 |         // Check if particle passed given faceZones
186 |         if (face() > -1)
187 |         {
188 |             const faceZoneMesh& fzm = mesh().faceZones();
189 |             
190 |             const labelList fzIDs = cloud.faceZoneIDs();
191 |             
192 |             forAll(fzIDs, i)
193 |             {
194 |                 const faceZone& fz = fzm[fzIDs[i]];
195 | 
196 |                 forAll(fz, j)
197 |                 {                
198 |                     if (fz[j] == face())
199 |                     {
200 |                         cloud.dataDiameter()[Pstream::myProcNo()][i].append(d_);
201 |                         cloud.dataPosition()[Pstream::myProcNo()][i].append(position());
202 |                         cloud.dataNParticle()[Pstream::myProcNo()][i].append(nParticle_);
203 |                     }
204 |                 }
205 |             }
206 |         }
207 |          
208 |     }
209 | 
210 |     return td.keepParticle;
211 | }
212 | 
213 | /* Rayleigh-Plesset: initial equilibrium radius */
214 | //
215 | bool Foam::bubble::initialEquilibriumRadius
216 | (
217 |    bubbleCloud& cloud,
218 |    trackingData& td
219 | )
220 | {
221 |   td.switchProcessor = false;
222 |   td.keepParticle = true;
223 | 
224 | // remember which cell the parcel is in
225 | // since this will change if a face is hit
226 |     const tetIndices tetIs = this->currentTetIndices();
227 |     scalar pc = td.pInterp().interpolate(this->coordinates(), tetIs);//
228 | 
229 | /// initial equlibirium radius
230 | scalar p0 = cloud.p0();
231 | scalar pV = cloud.pSat();
232 | scalar sigma = cloud.sigma();
233 | scalar gamma = cloud.gamma();
234 | scalar R = 0.5*d_;
235 | R_ = 0.5*d_;
236 | Rdt_ = 0.0;
237 | F0Old_ = 0.0;
238 | F1Old_ = 0.0;
239 | // initial guess R0 equal to R
240 | scalar R0 = R;
241 | scalar R0new = R;
242 | scalar R0bar = R;
243 | scalar error = 1;
244 | 
245 | scalar a = (2.0*sigma)/(p0-pV);
246 | int maxIter = 2000;
247 | int iter = 0;
248 | while ((error > 1.0E-06) && (iter < maxIter))
249 | {
250 | if (R < R0)
251 | {
252 |   gamma = 1.4;
253 | }
254 | else
255 | {
256 |   gamma = 1.0;
257 | }
258 |   scalar b = (pow(R,3.0*gamma)/(p0-pV))*(pV-((2.0*sigma)/R)-pc);
259 |   scalar f = pow(R0,3.0*gamma) + a*pow(R0,3.0*gamma-1.0) + b;
260 |   scalar df = 3.0*gamma*pow(R0,3*gamma-1.0) +
261 |   a*(3.0*gamma-1.0)*pow(R0,3.0*gamma-2.0);
262 |   R0bar = R0 - (f/df);
263 | if (R < R0bar)
264 | {
265 |   gamma = 1.4;
266 | }
267 | else
268 | {
269 |   gamma = 1.0;
270 | }
271 |   b = (pow(R,3.0*gamma)/(p0-pV))*(pV-((2.0*sigma)/R)-pc);
272 |   scalar fbar = pow(R0bar,3.0*gamma) + a*pow(R0bar,3.0*gamma-1.0) + b;
273 |   R0new = R0 - (f*f)/(df*(f-fbar));
274 |   R0new = 0.9*R0 + 0.1*R0new;
275 |   error = fabs((R0new-R0)/R0);
276 |   R0 = R0new;
277 |   iter++;
278 | }
279 | R0_ = R0;
280 | pG0_ = p0 + 2.0*sigma/R0_ - pV;
281 | if (R < R0)
282 | {
283 |   gamma = 1.4;
284 | }
285 | else
286 | {
287 |   gamma = 1.0;
288 | }
289 |   pG_ = pG0_*pow(R0_/R_,3.0);
290 |   pB_ = pG_ + pV;
291 | 
292 |   return true;
293 | }
294 | //added7-6
295 | 
296 | bool Foam::bubble::hitPatch(bubbleCloud&, trackingData&)
297 | {
298 |     return false;
299 | }
300 | 
301 | 
302 | void Foam::bubble::hitProcessorPatch
303 | (
304 |     bubbleCloud&,
305 |     trackingData& td
306 | )
307 | {
308 |     td.switchProcessor = true;
309 | }
310 | 
311 | 
312 | void Foam::bubble::hitWallPatch(bubbleCloud& cloud, trackingData&)
313 | {
314 |     const vector nw = normal();
315 | 
316 |     scalar Un = U_ & nw;
317 |     vector Ut = U_ - Un*nw;
318 | 
319 |     if (Un > 0)
320 |     {
321 |         U_ -= (1.0 + 0.8)*Un*nw;
322 |     }
323 | 
324 |     U_ -= 0.09*Ut;
325 | }
326 | 
327 | 
328 | void Foam::bubble::transformProperties(const tensor& T)
329 | {
330 |     particle::transformProperties(T);
331 |     U_ = transform(T, U_);
332 | }
333 | 
334 | 
335 | void Foam::bubble::transformProperties(const vector& separation)
336 | {
337 |     particle::transformProperties(separation);
338 | }
339 | 
340 | 
341 | // ************************************************************************* //
342 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubbleCloud/breakupModel.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | \*---------------------------------------------------------------------------*/
 25 | 
 26 | #include "bubbleCloud.H"
 27 | #include "breakupModel.H"
 28 | 
 29 | 
 30 | // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 31 | 
 32 | 
 33 | void Foam::breakupModel::breakup
 34 | (
 35 |     const scalar dt,
 36 |     const vector g,
 37 |     scalar& d,
 38 |     scalar& nParticle,
 39 |     scalar& y,
 40 |     scalar& yDot,
 41 |     const scalar rhop,
 42 |     const scalar mup,
 43 |     const scalar sigma,
 44 |     const vector& Up,
 45 |     const scalar rhoc,
 46 |     const scalar muc,
 47 |     const scalar Urmag
 48 | )
 49 | {
 50 |     if(model_ == "ETAB")
 51 |     {
 52 |         scalar r = 0.5*d;
 53 |         scalar r2 = r*r;
 54 |         scalar r3 = r*r2;
 55 | 
 56 |         scalar semiMass = nParticle*pow3(d);
 57 | 
 58 |         // Inverse of characteristic viscous damping time
 59 |         scalar rtd = 0.5*TABCmu_*mup/(rhop*r2);
 60 | 
 61 |         // Oscillation frequency (squared)
 62 |         scalar omega2 = TABComega_*sigma/(rhop*r3) - rtd*rtd;
 63 | 
 64 |         if (omega2 > 0)
 65 |         {
 66 |             scalar omega = sqrt(omega2);
 67 |             scalar romega = 1.0/omega;
 68 | 
 69 |             scalar We = rhoc*sqr(Urmag)*r/sigma;
 70 |             scalar Wetmp = We/TABtwoWeCrit_;
 71 | 
 72 |             // Initial values for y and yDot
 73 |             scalar y0 = y - We;
 74 |             scalar yDot0 = yDot + y0*rtd;
 75 | 
 76 |             // Update distortion parameters
 77 |             scalar c = cos(omega*dt);
 78 |             scalar s = sin(omega*dt);
 79 |             scalar e = exp(-rtd*dt);
 80 | 
 81 |             // Update distortion
 82 |             y = We + e*(y0*c + (yDot0/omega)*s);
 83 |             yDot = (We - y)*rtd + e*(yDot0*c - omega*y0*s);
 84 | 
 85 |             scalar y1 = y - Wetmp;
 86 |             scalar y2 = yDot*romega;
 87 | 
 88 |             scalar a = sqrt(y1*y1 + y2*y2);
 89 | 
 90 |             // scotty we may have break-up
 91 |             if (a + Wetmp > 1.0)
 92 |             {
 93 |                 scalar phic = y1/a;
 94 | 
 95 |                 // constrain phic within -1 to 1
 96 |                 phic = max(min(phic, 1), -1);
 97 | 
 98 |                 scalar phit = acos(phic);
 99 |                 scalar phi = phit;
100 |                 scalar quad = -y2/a;
101 |                 if (quad < 0)
102 |                 {
103 |                     phi = constant::mathematical::twoPi - phit;
104 |                 }
105 | 
106 |                 scalar tb = 0;
107 | 
108 |                 if (mag(y) < 1.0)
109 |                 {
110 |                     scalar theta = acos((1.0 - Wetmp)/a);
111 | 
112 |                     if (theta < phi)
113 |                     {
114 |                         if (constant::mathematical::twoPi - theta >= phi)
115 |                         {
116 |                             theta = -theta;
117 |                         }
118 |                         theta += constant::mathematical::twoPi;
119 |                     }
120 |                     tb = (theta - phi)*romega;
121 | 
122 |                     // breakup occurs
123 |                     if (dt > tb)
124 |                     {
125 |                         y = 1.0;
126 |                         yDot = -a*omega*sin(omega*tb + phi);
127 |                     }
128 |                 }
129 |      
130 |                 // update bubble size
131 |                 if (dt > tb)
132 |                 {
133 |                     scalar sqrtWe = AWe_*pow4(We) + 1.0;
134 |                     scalar Kbr = k1_*omega*sqrtWe;
135 | 
136 |                     if (We > WeTransition_)
137 |                     {
138 |                         sqrtWe = sqrt(We);
139 |                         Kbr =k2_*omega*sqrtWe;
140 |                     }
141 | 
142 |                     scalar rWetmp = 1.0/Wetmp;
143 |                     scalar cosdtbu = max(-1.0, min(1.0, 1.0 - rWetmp));
144 |                     scalar dtbu = romega*acos(cosdtbu);
145 |                     scalar decay = exp(-Kbr*dtbu);
146 | 
147 |                     scalar rNew = decay*r;
148 |                     if (rNew < r)
149 |                     {
150 |                         d = 2.0*rNew;
151 |                         y = 0.0;
152 |                         yDot = 0.0;
153 |                     }
154 |                 }
155 |             }
156 |         }
157 |         else
158 |         {
159 |             // reset bubble distortion parameters
160 |             y = 0;
161 |             yDot = 0;
162 |         }
163 | 
164 |         // update the nParticle count to conserve mass
165 |         nParticle = semiMass/pow3(d);
166 |     }
167 |     else if (model_ == "ReitzDiwakar")
168 |     {
169 |         scalar d1 = d;
170 |         scalar nuc = muc/rhoc;
171 |         scalar We = 0.5*rhoc*sqr(Urmag)*d/sigma;
172 |         scalar Re = Urmag*d/nuc;
173 | 
174 |         if (We > Cbag_)
175 |         {
176 |             if (We > Cstrip_*sqrt(Re))
177 |             {
178 |                 scalar dStrip = sqr(2.0*Cstrip_*sigma)/(rhoc*pow3(Urmag)*muc);
179 |                 scalar tauStrip = Cs_*d*sqrt(rhop/rhoc)/Urmag;
180 |                 scalar fraction = dt/tauStrip;
181 | 
182 |                 // new bubble diameter, implicit calculation
183 |                 d = (fraction*dStrip + d)/(1.0 + fraction);
184 |             }
185 |             else
186 |             {
187 |                 scalar dBag = 2.0*Cbag_*sigma/(rhoc*sqr(Urmag));
188 |                 scalar tauBag = Cb_*d*sqrt(rhop*d/sigma);
189 |                 scalar fraction = dt/tauBag;
190 | 
191 |                 // new bubble diameter, implicit calculation
192 |                 d = (fraction*dBag + d)/(1.0 + fraction);
193 |             }
194 | 
195 |             // preserve the total mass/volume by updating the number of
196 |             // particles in parcels due to breakup
197 |             nParticle *= pow3(d1/d);
198 |         }
199 |     }
200 |     else if (model_ == "PilchErdman")
201 |     {
202 |         // Weber number - eq (1)
203 |         scalar We = rhoc*sqr(Urmag)*d/sigma;
204 | 
205 |         // Ohnesorge number - eq (2)
206 |         scalar Oh = mup/sqrt(rhop*d*sigma);
207 | 
208 |         // Critical Weber number - eq (5)
209 |         scalar Wec = 12.0*(1.0 + 1.077*pow(Oh, 1.6));
210 | 
211 |         if (We > Wec)
212 |         {
213 |             // We > 2670, wave crest stripping - eq (12)
214 |             scalar taubBar = 5.5;
215 | 
216 |             if (We < 2670)
217 |             {
218 |                 if (We > 351)
219 |                 {
220 |                     // sheet stripping - eq (11)
221 |                     taubBar = 0.766*pow(We - 12.0, 0.25);
222 |                 }
223 |                 else if (We > 45)
224 |                 {
225 |                     // bag-and-stamen breakup  - eq (10)
226 |                     taubBar = 14.1*pow(We - 12.0, 0.25);
227 |                 }
228 |                 else if (We > 18)
229 |                 {
230 |                     // bag breakup - eq (9)
231 |                     taubBar = 2.45*pow(We - 12.0, 0.25);
232 |                 }
233 |                 else if (We > 12)
234 |                 {
235 |                     // vibrational breakup - eq (8)
236 |                     taubBar = 6.0*pow(We - 12.0, -0.25);
237 |                 }
238 |                 else
239 |                 {
240 |                     // no break-up
241 |                     taubBar = GREAT;
242 |                 }
243 |             }
244 | 
245 |             scalar rho12 = sqrt(rhoc/rhop);
246 | 
247 |             // velocity of fragmenting drop - eq (20)
248 |             scalar Vd = Urmag*rho12*(B1_*taubBar + B2_*sqr(taubBar));
249 | 
250 |             // maximum stable diameter - eq (33)
251 |             scalar Vd1 = sqr(1.0 - Vd/Urmag);
252 |             Vd1 = max(Vd1, SMALL);
253 |             scalar dStable = Wec*sigma/(Vd1*rhoc*sqr(Urmag));
254 | 
255 |             if (d < dStable)
256 |             {
257 |                 // bubble diameter already stable = no break-up
258 |                 // - do not update d and nParticle
259 |                 return;
260 |             }
261 |             else
262 |             {
263 |                 scalar semiMass = nParticle*pow3(d);
264 | 
265 |                 // invert eq (3) to create a dimensional break-up time
266 |                 scalar taub = taubBar*d/(Urmag*rho12);
267 | 
268 |                 // update bubble diameter according to the rate eq (implicitly)
269 |                 scalar frac = dt/taub;
270 |                 d = (d + frac*dStable)/(1.0 + frac);
271 | 
272 |                 // correct the number of particles to conserve mass
273 |                 nParticle = semiMass/pow3(d);
274 |             }
275 |         }
276 |     }
277 | }
278 | 
279 | 
280 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
281 | 
282 | 
283 | Foam::breakupModel::breakupModel
284 | (
285 |     const fvMesh& mesh
286 | )
287 | :
288 |     mesh_(mesh),
289 |     dict_
290 |     (
291 |         IOobject
292 |         (
293 |             "cloudProperties",
294 |             mesh_.time().constant(),
295 |             mesh_,
296 |             IOobject::MUST_READ_IF_MODIFIED,
297 |             IOobject::NO_WRITE
298 |         )
299 |     ),
300 |     model_(word(dict_.lookup("breakupModel"))),
301 |     k1_(0.2),
302 |     k2_(0.2),
303 |     WeTransition_(100.0),
304 |     AWe_(0.0),
305 |     TABComega_(8),
306 |     TABCmu_(5),
307 |     TABtwoWeCrit_(12),
308 |     Cbag_(6.0),
309 |     Cb_(0.785),
310 |     Cstrip_(0.5),
311 |     Cs_(10.0),
312 |     B1_(0.375),
313 |     B2_(0.2274)
314 | {
315 |     if
316 |     (
317 |         model_ != "PilchErdman"
318 |      && model_ != "ETAB"
319 |      && model_ != "ReitzDiwakar"
320 |     )
321 |     {
322 |         Info << endl << "    Breakup model not found - disabled!" << endl;
323 |         model_ = "none";
324 |     }
325 | 
326 |     // ETAB constants
327 |     scalar k21 = k2_/k1_;
328 |     AWe_ = (k21*sqrt(WeTransition_) - 1.0)/pow4(WeTransition_);
329 | }
330 | 
331 | 
332 | // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
333 | 
334 | 
335 | void Foam::breakupModel::update
336 | (
337 |     bubbleCloud& cloud,
338 |     bubble::trackingData& td,
339 |     const scalar dt
340 | )
341 | {
342 |     if (model_ == "none")
343 |     {
344 |         return;
345 |     }
346 | 
347 |     // Constant bubble properties
348 |     const scalar rhop = cloud.rhop();
349 |     const scalar mup = cloud.mup();
350 |     const scalar sigma = cloud.sigma();
351 | 
352 |     // Create pointer to cloud
353 |     bubbleCloud *ptrCloud = const_cast<bubbleCloud*>(&cloud);    
354 | 
355 |     // Loop over all bubbles
356 |     forAllIter(Cloud<bubble>, *ptrCloud,  iter)
357 |     {
358 |         // Cell values of carrier phase
359 |         const tetIndices tetIs = iter().currentTetIndices();
360 |         const scalar rhoc = td.rhoInterp().interpolate(iter().coordinates(), tetIs);
361 |         const vector Uc = td.UInterp().interpolate(iter().coordinates(), tetIs);
362 |         const scalar muc = td.nuInterp().interpolate(iter().coordinates(), tetIs) * rhoc;
363 | 	
364 |         vector Urel = iter().U() - Uc; 
365 |         const scalar Urmag = mag(Urel);
366 | 
367 |         const vector g = td.g();
368 | 
369 |         // Perform for breakup
370 |         breakup
371 |         (
372 |             dt,
373 |             g,
374 |             iter().d(),
375 |             iter().nParticle(),
376 |             iter().y(),
377 |             iter().yDot(),
378 |             rhop,
379 |             mup,
380 |             sigma,
381 |             iter().U(),
382 |             rhoc,
383 |             muc,
384 |             Urmag
385 |         );
386 |     }
387 | }
388 | 
389 | // ************************************************************************* //
390 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/phaseCoupling/phaseCoupling.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software; you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by the
 13 |     Free Software Foundation; either version 2 of the License, or (at your
 14 |     option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be Ubeameful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM; if not, write to the Free Software Foundation,
 23 |     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 UbeamA
 24 | 
 25 | 
 26 | \*---------------------------------------------------------------------------*/
 27 | 
 28 | #include "phaseCoupling.H"
 29 | #include "mathematicalConstants.H"
 30 | #include "clock.H"
 31 | 
 32 | // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 33 | 
 34 | void Foam::phaseCoupling::checkConnection(const label startCell, const label currentID)
 35 | {
 36 |     // Set volume ID
 37 |     vofID_[startCell] = currentID;
 38 | 
 39 |     // Create dynamic list to store all neighbours
 40 |     DynamicList<label> cells(0);
 41 |     // Get neighbours of startCell
 42 |     cells.append(mesh_.cellCells()[startCell]);
 43 | 
 44 |     // Start outer loop
 45 |     while (cells.size() > 0)
 46 |     {
 47 |         // Create new dynamic list to store all new neighbours
 48 |         DynamicList<label> neighbours(0);
 49 | 
 50 |         // Loop over all current neighbours
 51 |         forAll(cells, i)
 52 |         {
 53 |             label cellI = cells[i];
 54 | 
 55 |             // Check if neighbour cell is liquid and has no ID yet
 56 |             if (alpha1_[cellI] > alphaLimit_ && mag(vofID_[cellI] - currentID) > 0.1)
 57 |             {
 58 |                 // Set volume ID
 59 |                 vofID_[cellI] = currentID;
 60 | 
 61 |                 // add neighbours to neighboursNeighbours list
 62 |                 neighbours.append(mesh_.cellCells()[cellI]);
 63 |             }
 64 |         }
 65 |         cells.clear();
 66 |         cells.transfer(neighbours);
 67 |     }
 68 | }
 69 | 
 70 | 
 71 | void Foam::phaseCoupling::levelSetFunction()
 72 | {
 73 |     dimensionedScalar meter = dimensionedScalar("meter", dimLength, 1.0);
 74 | 
 75 |     // Characteristic cell length
 76 |     volScalarField dx
 77 |     (
 78 |         IOobject
 79 |         (
 80 |             "dx",
 81 |             mesh_.time().timeName(),
 82 |             mesh_
 83 |         ),
 84 |         mesh_,
 85 |         dimensionedScalar("dx", dimless, scalar(0.0)),
 86 |         zeroGradientFvPatchScalarField::typeName
 87 |     );
 88 |     dx.primitiveFieldRef() = Foam::cbrt(mesh_.V());
 89 |     dx.correctBoundaryConditions();
 90 | 
 91 |     // Smoothing coefficient
 92 |     dimensionedScalar nun("nun", dimArea, 0.001);
 93 | 
 94 |     // Coefficient for initial field
 95 |     volScalarField Gamma(0.75*dx);
 96 | 
 97 |     // Set initial field
 98 |     psi_ = Gamma*(2.0*alpha1_ - 1.0);
 99 |     volScalarField psi0 = psi_;
100 | 
101 |     // Smoothed signed distance function
102 |     volScalarField signPsi0 = psi0 / Foam::sqrt(sqr(psi0) + sqr(dx));
103 | 
104 |     // Artifical time step size
105 |     volScalarField dt = 0.1*dx;
106 | 
107 |     // Number of iterations
108 |     label nIter = 50;
109 | 
110 |     for (int iter=0; iter<nIter; iter++)
111 |     {
112 |         // Smoothing correction
113 |         volVectorField n = fvc::grad(psi_) / ( mag(fvc::grad(psi_)) + SMALL/meter);
114 |         volScalarField corr = nun*( n && fvc::grad( n &&  fvc::grad(psi_)));
115 | 
116 |         psi_ = psi_ + signPsi0*(scalar(1.0) - mag(fvc::grad(psi_)*meter) - corr)*dt;
117 |         psi_.correctBoundaryConditions();
118 |     }
119 | }
120 | 
121 | 
122 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
123 | 
124 | 
125 | Foam::phaseCoupling::phaseCoupling
126 | (
127 |     const volVectorField& U,
128 |     volScalarField& alpha1,
129 |     volScalarField& alpha2,
130 |     bubbleCloud& bubbleCloud 
131 | )
132 | :
133 |     mesh_(U.mesh()),
134 |     dict_
135 |     (
136 |         IOobject
137 |         (
138 |             "cloudProperties",
139 |             mesh_.time().constant(),
140 |             mesh_,
141 |             IOobject::MUST_READ,
142 |             IOobject::NO_WRITE
143 |         )
144 |     ),
145 |     U_(U),
146 |     alpha1_(alpha1),
147 |     alpha2_(alpha2),
148 |     cloud_(bubbleCloud),
149 |     active_(readBool(dict_.subDict("phaseCoupling").lookup("active"))),
150 |     alphaLimit_(readScalar(dict_.subDict("phaseCoupling").lookup("alphaLimit"))),
151 |     dMax_(readScalar(dict_.subDict("phaseCoupling").lookup("dMax"))),
152 |     sphMax_(readScalar(dict_.subDict("phaseCoupling").lookup("sphericity"))),
153 |     startTime_(readScalar(dict_.subDict("phaseCoupling").lookup("startTime"))),
154 |     nInterval_(readLabel(dict_.subDict("phaseCoupling").lookup("nInterval"))),
155 |     vofID_
156 |     (
157 |         IOobject
158 |         (
159 |             "vofID",
160 |             mesh_.time().timeName(),
161 |             mesh_,
162 |             IOobject::NO_READ,
163 |             IOobject::AUTO_WRITE
164 |         ),
165 |         mesh_,
166 |         dimensionedScalar("vofID", dimless, scalar(0.0)),
167 |         zeroGradientFvPatchScalarField::typeName
168 |     ),
169 |     psi_
170 |     (
171 |         IOobject
172 |         (
173 |             "psi",
174 |             mesh_.time().timeName(),
175 |             mesh_,
176 |             IOobject::NO_READ,
177 |             IOobject::AUTO_WRITE
178 |         ),
179 |         mesh_,
180 |         dimensionedScalar("psi", dimless, scalar(0.0)),
181 |         zeroGradientFvPatchScalarField::typeName
182 |     ),
183 |     source_
184 |     (
185 |         IOobject
186 |         (
187 |             "source",
188 |             mesh_.time().timeName(),
189 |             mesh_,
190 |             IOobject::NO_READ,
191 |             IOobject::NO_WRITE
192 |         ),
193 |         mesh_,
194 |         dimensionedVector("source", dimensionSet(0,1,-2,0,0,0,0), vector(0,0,0)),
195 |         zeroGradientFvPatchScalarField::typeName
196 |     ),
197 |     damping_
198 |     (
199 |         IOobject
200 |         (
201 |             "damping",
202 |             mesh_.time().timeName(),
203 |             mesh_,
204 |             IOobject::NO_READ,
205 |             IOobject::NO_WRITE
206 |         ),
207 |         mesh_,
208 |         dimensionedScalar("damping", dimensionSet(0,0,-1,0,0,0,0), scalar(0.0)),
209 |         zeroGradientFvPatchScalarField::typeName
210 |     ),
211 |     maskalpha1_
212 |     (
213 |         IOobject
214 |         (
215 |             "maskalpha1",
216 |             mesh_.time().timeName(),
217 |             mesh_,
218 |             IOobject::NO_READ,
219 |             IOobject::AUTO_WRITE
220 |         ),
221 |         mesh_,
222 |         dimensionedScalar("maskalpha1", dimless, scalar(0.0)),
223 |         zeroGradientFvPatchScalarField::typeName
224 |     )
225 | {}
226 | 
227 | // * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
228 | 
229 | 
230 | // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
231 | 
232 | 
233 | // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
234 | 
235 | void Foam::phaseCoupling::update()
236 | {
237 |     // Reset volumeID and damping/source fields
238 |     vofID_ *= 0.0;
239 |     damping_ *= 0.0;
240 |     source_ *= 0.0; 
241 |     maskalpha1_ *= 0.0;
242 |     
243 |     if
244 |     (
245 |         !active_
246 |      || mesh_.time().timeIndex() % nInterval_ != 0
247 |      || mesh_.time().time().value() < startTime_
248 |     )
249 |     {
250 |         return;
251 |     }
252 | 
253 | 
254 |     // Global time step
255 |     dimensionedScalar deltaT = mesh_.time().deltaT();
256 | 
257 |     // Local-to-global cell reference
258 |     globalIndex globalNumbering (mesh_.nCells());
259 | 
260 |     // Create the volumeID field
261 |     forAll(mesh_.cells(), cellI)
262 |     {
263 |         // Convert local processor cellIDs to global cellIDs
264 |         label globalCellID = globalNumbering.toGlobal(cellI);
265 | 
266 |         // Cell is considered liquid and not yet marked
267 |         if (alpha1_[cellI] > alphaLimit_ && mag(vofID_[cellI]) < 0.1)
268 |         {
269 |             // Check surrounding cells
270 |             checkConnection(cellI, globalCellID+1);
271 |         }
272 |     }
273 |     vofID_.correctBoundaryConditions();
274 | 
275 | 
276 |     // Correct for parallel processing
277 |     // Number of corrections
278 |     label corr = Foam::log(scalar(Pstream::nProcs())) / Foam::log(2.0) + 1;
279 |     for(int i=0; i<=corr; i++)
280 |     {
281 |         forAll(mesh_.boundary(), patchI)
282 |         {
283 |             // Current patch
284 |             const fvPatch& pPatch = mesh_.boundary()[patchI];
285 | 
286 |             // check if patch is coupled, e.g. processor patch
287 |             if (pPatch.coupled())
288 |             {
289 |                 // loop over all faces of processor patch
290 |                 forAll(pPatch, faceI)
291 |                 {
292 |                     // get cell values
293 |                     const scalar ID_own = vofID_.boundaryField()[patchI].patchInternalField()()[faceI];
294 |                     const scalar ID_nei = vofID_.boundaryField()[patchI].patchNeighbourField()()[faceI];
295 | 
296 |                     // check, if volumeIDs on both sides are fluid
297 |                     if ( (ID_nei > 0.1) && (ID_own > 0.1) )
298 |                     {
299 |                         // check, if volumeIDs on both sides are different
300 |                         if ( mag(ID_nei - ID_own) > 0.1 )
301 |                         {
302 |                             scalar minID = Foam::min(ID_own, ID_nei);
303 |                             scalar maxID = Foam::max(ID_own, ID_nei);
304 | 
305 |                             scalar diff(maxID - minID);
306 |                             volScalarField filtered = diff
307 |                                                   * pos( vofID_ - maxID + 0.1)
308 |                                                   * pos(-vofID_ + maxID + 0.1);
309 |                             vofID_ -= filtered;
310 |                         }
311 |                     }
312 |                 }
313 |             }
314 |         }
315 |         vofID_.correctBoundaryConditions();
316 |     }
317 | 
318 | 
319 |     // Count number of continua and renumber vofID
320 |     {
321 |         volScalarField tmp(vofID_);
322 |         vofID_ = 0.0;
323 |         scalar maxID = gMax(tmp);
324 |         int iter = 1;
325 |         while (maxID > 0.1)
326 |         {
327 |             volScalarField curVolID = pos(tmp - maxID + 0.1);
328 |             vofID_ += iter*curVolID;
329 |             tmp -= maxID*curVolID;
330 |             maxID = gMax(tmp);
331 |             iter++;
332 |         }
333 |     }
334 | 
335 | 
336 |     // Calculate bubble volume, velocity, and position
337 |     // create lists to store data
338 |     label maxID = floor(gMax(vofID_) + 0.5);
339 |     labelList noCells(maxID+1, label(0));
340 |     scalarList cellVolume(maxID+1, scalar(0));
341 |     scalarList volume(maxID+1, scalar(0));
342 |     vectorList position(maxID+1, vector(0,0,0));
343 |     vectorList velocity(maxID+1, vector(0,0,0));
344 | 
345 |     // Loop over all cells and store corresponding data
346 |     forAll(mesh_.cells(), cellI)
347 |     {
348 |         if (vofID_[cellI] > 0.1)
349 |         {
350 |             // Get volume ID
351 |             label volID = floor(vofID_[cellI] + 0.5);
352 | 
353 |             // Store data in corresponding list
354 |             noCells[volID] += 1;
355 |             cellVolume[volID] += mesh_.V()[cellI];
356 |             volume[volID] += alpha1_[cellI]*mesh_.V()[cellI];
357 |             velocity[volID] += alpha1_[cellI]*mesh_.V()[cellI]*U_[cellI];
358 |             position[volID] += alpha1_[cellI]*mesh_.V()[cellI]*mesh_.C()[cellI];
359 |         }
360 |     }
361 | 
362 |     // Account for parallel processing
363 |     reduce( noCells, sumOp<labelList>() );
364 |     reduce( cellVolume, sumOp<scalarList>() );
365 |     reduce( volume, sumOp<scalarList>() );
366 |     reduce( position, sumOp<vectorList>() );
367 |     reduce( velocity, sumOp<vectorList>() );
368 | 
369 |     // Step F: Inject bubbles
370 |     for(int i=1; i<=maxID; i++)
371 |     {
372 |         if (volume[i] > VSMALL)
373 |         {
374 |             // Calculate bubble diameter
375 |             const scalar d = cbrt(6.0*volume[i]/constant::mathematical::pi);
376 | 
377 |             // bubble must be smaller than dMax_
378 |             if ( d < dMax_ ) 
379 |             {
380 |                 // Average cell size for bubble
381 |                 scalar dx = Foam::cbrt(cellVolume[i] / noCells[i]);
382 | 
383 |                 // bubble diameter has to larger than 0.5 average cell size
384 |                 // to suppress very small bubbles
385 |                 if (d > 0.5*dx)
386 |                 {
387 |                     // Weighting of position and velocity
388 |                     vector pos = position[i] / volume[i];
389 |                     vector U = velocity[i] / volume[i];
390 | 
391 |                     // Calculate maximal distance to center of mass for liquid structure
392 |                     // filtered for cells only belonging to given structure
393 |                     volScalarField mask = Foam::pos( vofID_ - i + 0.1)
394 |                                          *Foam::pos(-vofID_ + i + 0.1);
395 |                     vectorField cellCenters = mesh_.C();
396 |                     scalarField distance = Foam::mag(cellCenters - pos)*mask.ref();
397 | 
398 |                     // Sphericity based on ideal sphere
399 |                     scalar sph = 2.0*gMax(distance)/d;
400 | 
401 |                     // Sphericity limit
402 |                     if ( sph < sphMax_ )
403 |                     {
404 |                     
405 |                         // Inject bubble
406 |                         cloud_.inject(pos, d, U, cloud_);
407 | 
408 |                         // Set alpha field and adjust velocity damping field
409 |                         damping_ += GREAT*mask/deltaT;
410 |                         maskalpha1_ = mask*alpha1_;
411 |                         alpha1_ = max(0.0,alpha1_ - 1000.0*mask*alpha1_);
412 |                         alpha2_ = min(1.0,alpha2_ + 1000.0*mask*alpha1_);
413 |                     }
414 |                     
415 |                 }
416 |             }
417 |         }
418 |     }
419 | }
420 | 
421 | // ************************************************************************* //
422 | 


--------------------------------------------------------------------------------
/src/libVOFDBM/bubbleCloud/bubbleCloud.C:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------*\
  2 |   =========                 |
  3 |   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
  4 |    \\    /   O peration     |
  5 |     \\  /    A nd           | Copyright held by original author
  6 |      \\/     M anipulation  |
  7 | -------------------------------------------------------------------------------
  8 | License
  9 |     This file is part of OpenFOAM.
 10 | 
 11 |     OpenFOAM is free software: you can redistribute it and/or modify it
 12 |     under the terms of the GNU General Public License as published by
 13 |     the Free Software Foundation, either version 3 of the License, or
 14 |     (at your option) any later version.
 15 | 
 16 |     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
 17 |     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 18 |     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 19 |     for more details.
 20 | 
 21 |     You should have received a copy of the GNU General Public License
 22 |     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 23 | 
 24 | \*---------------------------------------------------------------------------*/
 25 | 
 26 | #include "bubbleCloud.H"
 27 | #include "fvMesh.H"
 28 | #include "volFields.H"
 29 | #include "interpolationCellPoint.H"
 30 | 
 31 | // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 32 | 
 33 | 
 34 | void Foam::bubbleCloud::createbubbleDataFiles()
 35 | {
 36 |     // resize file pointer
 37 |     cloudDataFilesPtr_.resize(faceZoneIDs_.size());
 38 |     
 39 |     forAll (cloudDataFilesPtr_, i)
 40 |     {
 41 |         if (!cloudDataFilesPtr_[i] && Pstream::master() && faceZoneIDs_.size())
 42 |         {
 43 |             word startTimeName = this->db().time().timeName(this->db().time().startTime().value());
 44 | 
 45 |             fileName cloudDataFileDir = "postProcessing/bubbleCloud/" + startTimeName + "/";
 46 | 
 47 |             fileName dataFile = faceZoneNames_[i] + "_cloudData.dat";
 48 |         
 49 |             mkDir(cloudDataFileDir);
 50 | 
 51 |             cloudDataFilesPtr_[i].reset
 52 |             (
 53 |                 new OFstream
 54 |                 (
 55 |                     cloudDataFileDir/dataFile
 56 |                 )
 57 |             ); 
 58 | 
 59 |             cloudDataFilesPtr_[i]() << "// time" << tab << tab
 60 |                                     << "diameter" << tab << tab
 61 |                                     << "position" << tab << tab
 62 |                                     << "nParticle" << endl;
 63 | 	}
 64 |     }
 65 | }
 66 | 
 67 | 
 68 | void Foam::bubbleCloud::info()
 69 | {
 70 |     label cloudSize = (*this).size();
 71 |     reduce( cloudSize, sumOp<label>() );
 72 | 
 73 |     Info<< endl << "bubble cloud: " << endl
 74 |         << "    Number of bubbles : " << cloudSize << endl;
 75 |     if (cloudSize > 0)
 76 |     {
 77 |         Info<< "    Max diameter [mu]  : " << 1e6*Dmax() << endl
 78 |             << "    D10 diameter [mu]  : " << 1e6*Dij(1,0) << endl
 79 |             << "    D32 diameter [mu]  : " << 1e6*Dij(3,2) << endl;
 80 |     }
 81 |     Info<< endl;
 82 | }
 83 | 
 84 | 
 85 | Foam::scalar Foam::bubbleCloud::Dij
 86 | (
 87 |     const label i,
 88 |     const label j
 89 | )
 90 | {
 91 |     scalar si = 0.0;
 92 |     scalar sj = 0.0;
 93 |     forAllIter(Cloud<bubble>, *this, iter)
 94 |     {
 95 |         bubble& p = iter();
 96 |         si += p.nParticle()*pow(p.d(), i);
 97 |         sj += p.nParticle()*pow(p.d(), j);
 98 |     }
 99 | 
100 |     reduce(si, sumOp<scalar>());
101 |     reduce(sj, sumOp<scalar>());
102 | 
103 |     return si/sj;
104 | }
105 | 
106 | 
107 | Foam::scalar Foam::bubbleCloud::Dmax()
108 | {
109 |     scalar d = -GREAT;
110 |     forAllIter(Cloud<bubble>, *this, iter)
111 |     {
112 |         bubble& p = iter();
113 |         d = max(d, p.d());
114 |     }
115 | 
116 |     reduce(d, maxOp<scalar>());
117 | 
118 |     return max(0.0, d);
119 | }
120 | 
121 | 
122 | // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
123 | 
124 | 
125 | Foam::bubbleCloud::bubbleCloud
126 | (
127 |     const fvMesh& mesh,
128 |     const dimensionedVector& g,
129 |     const word& cloudName,
130 |     bool readFields
131 | )
132 | :
133 |     Cloud<bubble>(mesh, cloudName, false),
134 |     mesh_(mesh),
135 |     g_(g),
136 |     particleProperties_
137 |     (
138 |         IOobject
139 |         (
140 |             "particleProperties",
141 |             mesh_.time().constant(),
142 |             mesh_,
143 |             IOobject::MUST_READ_IF_MODIFIED,
144 |             IOobject::NO_WRITE
145 |         )
146 |     ),
147 |     
148 |     p0_(dimensionedScalar(particleProperties_.lookup("p0")).value()),
149 |     gamma_(dimensionedScalar(particleProperties_.lookup("gamma")).value()),
150 |     posP1_(dimensionedVector(particleProperties_.lookup("posP1")).value()),
151 |     dP1_(dimensionedScalar(particleProperties_.lookup("dP1")).value()),
152 |     UP1_(dimensionedVector(particleProperties_.lookup("UP1")).value()),
153 |     posP2_(dimensionedVector(particleProperties_.lookup("posP2")).value()),
154 |     dP2_(dimensionedScalar(particleProperties_.lookup("dP2")).value()),
155 |     UP2_(dimensionedVector(particleProperties_.lookup("UP2")).value()),
156 |     tInjStart_(dimensionedScalar(particleProperties_.lookup("tInjStart")).value()),
157 |     tInjEnd_(dimensionedScalar(particleProperties_.lookup("tInjEnd")).value()),
158 |  //
159 |     dict_
160 |     (
161 |         IOobject
162 |         (
163 |             "cloudProperties",
164 |             mesh_.time().constant(),
165 |             mesh_,
166 |             IOobject::MUST_READ_IF_MODIFIED,
167 |             IOobject::NO_WRITE
168 |         )
169 |     ),
170 | 
171 |     phaseName_(word(dict_.lookup("phaseName"))),
172 |     faceZoneIDs_(),
173 |     faceZoneNames_(),
174 |     cloudDataFilesPtr_(),
175 |     dataDiameter_(),
176 |     dataPosition_(),
177 |     source_(mesh_.nCells(), Zero),
178 |     correctalpha1_(mesh_.nCells(), 0), //7-9   
179 |     
180 |     momentumSource_
181 |     (
182 |         IOobject
183 |         (
184 |             "momentumSource",
185 |             mesh_.time().timeName(),
186 |             mesh_,
187 |             IOobject::NO_READ,
188 |             IOobject::NO_WRITE
189 |         ),
190 |         mesh_,
191 |         dimensionedVector("zero", dimensionSet(1,-2,-2,0,0,0,0),vector::zero)
192 |     ),
193 |     USource_
194 |     (
195 |         IOobject
196 |         (
197 |             "USource",
198 |             mesh_.time().timeName(),
199 |             mesh_,
200 |             IOobject::NO_READ,
201 |             IOobject::AUTO_WRITE
202 |         ),
203 |         mesh_,
204 |         dimensionedVector("zero", dimensionSet(0,1,-2,0,0,0,0),vector::zero)
205 |     ),
206 |     Addalpha1_
207 |     (
208 |         IOobject
209 |         (
210 |             "Addalpha1",
211 |             mesh_.time().timeName(),
212 |             mesh_,
213 |             IOobject::NO_READ,
214 |             IOobject::AUTO_WRITE
215 |         ),
216 |         mesh_,
217 |         dimensionedScalar("zero", dimensionSet(0,0,0,0,0,0,0),0)
218 |     ),
219 |     collision_(mesh_),
220 |     breakup_(mesh_)
221 | {
222 |     if (readFields)
223 |     {
224 |         bubble::readFields(*this);
225 |     }
226 | 
227 |     // Collect face zones for postprocessing
228 |     wordList faceZoneNames(dict_.lookup("faceZones"));
229 |     const faceZoneMesh& fzm = mesh_.faceZones();
230 |     DynamicList<label> zoneIDs;
231 |     DynamicList<word> zoneNames;
232 | 
233 |     Info<< nl << type() << " faceZones" << endl;
234 |     forAll(faceZoneNames, i)
235 |     {
236 |         const word& zoneName = faceZoneNames[i];
237 |         label zoneI = fzm.findZoneID(zoneName);
238 | 
239 |         if (zoneI != -1)
240 |         {
241 |             zoneIDs.append(zoneI);
242 |             zoneNames.append(zoneName);
243 | 
244 | 	    const faceZone& fz = fzm[zoneI];
245 |             label nFaces = returnReduce(fz.size(), sumOp<label>());
246 |             Info<< "    " << zoneName << " faces: " << nFaces << nl;
247 | 	}
248 |     }
249 | 
250 |     faceZoneNames_.transfer(zoneNames);
251 |     faceZoneIDs_.transfer(zoneIDs);
252 |     if(!faceZoneIDs_.size())
253 |     {
254 |         Info<< "    none" << endl;
255 |     }
256 |     Info << endl;
257 | 
258 |     // Get phase properties
259 |     const dictionary& transportProperties = db().lookupObject<IOdictionary>
260 |     (
261 |         "transportProperties"
262 |     );
263 |           
264 |     // surface tension
265 |     rhop_ = readScalar(transportProperties.subDict(phaseName_).lookup("rho"));
266 |     
267 |     // dynamic viscosity
268 |     mup_ = readScalar(transportProperties.subDict(phaseName_).lookup("nu"))*rhop_;
269 | 
270 |     // surface tension
271 |     sigma_ = readScalar(transportProperties.lookup("sigma"));
272 |     
273 |     // surface tension
274 |     pSat_ = readScalar(transportProperties.lookup("pSat")); //
275 |     
276 |     RPEqn_ = readScalar(transportProperties.lookup("RPEqn")); //for swith on/off RPEqn
277 |     
278 |     // Create postProcessing data file
279 |     createbubbleDataFiles();
280 |     dataDiameter_.setSize(Pstream::nProcs());
281 |     dataPosition_.setSize(Pstream::nProcs());
282 |     dataNParticle_.setSize(Pstream::nProcs());
283 |     forAll(dataDiameter_, i)
284 |     {
285 |         dataDiameter_[i].setSize(faceZoneIDs_.size());
286 |         dataNParticle_[i].setSize(faceZoneIDs_.size());
287 |         dataPosition_[i].setSize(faceZoneIDs_.size());
288 |     }
289 | }
290 | 
291 | //injector 
292 | 
293 | void Foam::bubbleCloud::injector
294 | (
295 |   bubbleCloud& cloud, 
296 |   bubble::trackingData &td
297 | )
298 | {
299 |   label cellI = 1;
300 |   label tetFaceI = 1;
301 |   label tetPtI = 1;
302 |   mesh_.findCellFacePt(cloud.posP1_, cellI, tetFaceI, tetPtI); 
303 |   bubble* ptr1=new bubble(mesh_,cloud.posP1_,cellI,cloud.dP1_,cloud.UP1_);
304 |   ptr1->initialEquilibriumRadius(cloud, td);
305 |   Cloud<bubble>::addParticle(ptr1);
306 |   mesh_.findCellFacePt(cloud.posP2_, cellI, tetFaceI, tetPtI); 
307 |   bubble* ptr2=new bubble(mesh_,cloud.posP2_,cellI,cloud.dP2_,cloud.UP2_);
308 |   ptr2->initialEquilibriumRadius(cloud, td);
309 |   Cloud<bubble>::addParticle(ptr2);
310 | }
311 | 
312 | 
313 | 
314 | // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
315 | 
316 | void Foam::bubbleCloud::move()
317 | {
318 |     // Reset data collection from processors
319 |     dataDiameter_.clear();
320 |     dataPosition_.clear();
321 |     dataNParticle_.clear();
322 |     dataDiameter_.setSize(Pstream::nProcs());
323 |     dataPosition_.setSize(Pstream::nProcs());
324 |     dataNParticle_.setSize(Pstream::nProcs());
325 |     forAll(dataDiameter_, i)
326 |     {
327 |         dataDiameter_[i].setSize(faceZoneIDs_.size());
328 |         dataPosition_[i].setSize(faceZoneIDs_.size());
329 |         dataNParticle_[i].setSize(faceZoneIDs_.size());
330 |     }
331 | 
332 |     const volScalarField& rho = mesh_.lookupObject<const volScalarField>("rho");
333 |     const volVectorField& U = mesh_.lookupObject<const volVectorField>("U");
334 |     const volScalarField& nu = mesh_.lookupObject<const volScalarField>("nu");
335 |     const volScalarField& alpha1 = mesh_.lookupObject<const volScalarField>("alpha.transformphase"); //
336 |     const volScalarField& p = mesh_.lookupObject<const volScalarField>("p"); //
337 | 
338 |     interpolationCellPoint<scalar> rhoInterp(rho);
339 |     interpolationCellPoint<vector> UInterp(U);
340 |     interpolationCellPoint<scalar> nuInterp(nu);
341 |         interpolationCell<scalar> alpha1Interp(alpha1); //
342 |         interpolationCellPoint<scalar> pInterp(p); //
343 |         
344 |    
345 |     bubble::trackingData
346 |         td(*this, rhoInterp, UInterp, nuInterp, alpha1Interp, pInterp, g_.value()); //
347 | 
348 |     // Move bubbles
349 |     Cloud<bubble>::move(*this, td, mesh_.time().deltaTValue());
350 | 
351 |     // bubble collision
352 |     collision_.update(*this, mesh_.time().deltaTValue());
353 | 
354 |     // Secondary breakup
355 |     breakup_.update(*this, td, mesh_.time().deltaTValue());
356 | 
357 |     
358 |     // Collect data from all processors for postprocessing and write to file
359 |     Pstream::gatherList(dataDiameter_);
360 |     Pstream::gatherList(dataPosition_);
361 |     Pstream::gatherList(dataNParticle_);
362 |     for (int i=0; i<Pstream::nProcs(); i++)
363 |     {
364 |         // loop over all face zones
365 |         forAll(dataDiameter_[i], j)
366 |         {
367 |             // loop over all data points
368 | 	    forAll(dataDiameter_[i][j], k)
369 |             {
370 |                 if(Pstream::master())
371 |                 {
372 |                     cloudDataFilesPtr_[j]() << this->db().time().value() << tab << dataDiameter_[i][j][k] << tab << dataPosition_[i][j][k] << tab << dataNParticle_[i][j][k]<< endl;
373 |                 }
374 |             }
375 |         }
376 |     }
377 | 
378 |     info();
379 |      
380 |     //added    
381 |         if(mesh_.time().value()> this->tInjStart_ &&
382 |         mesh_.time().value()< this->tInjEnd_ )
383 |         {
384 |             this->injector(*this, td);
385 |         }
386 | //end  
387 | }
388 | 
389 | 
390 | void Foam::bubbleCloud::inject
391 | (
392 |     vector position,
393 |     const scalar diameter,
394 |     const vector velocity,
395 |     bubbleCloud& cloud
396 | )
397 | {
398 | 
399 |     const volScalarField& rho = mesh_.lookupObject<const volScalarField>("rho");
400 |     const volVectorField& U = mesh_.lookupObject<const volVectorField>("U");
401 |     const volScalarField& nu = mesh_.lookupObject<const volScalarField>("nu");
402 |     const volScalarField& alpha1 = mesh_.lookupObject<const volScalarField>("alpha.transformphase"); //
403 |     const volScalarField& p = mesh_.lookupObject<const volScalarField>("p"); //
404 | 
405 |     interpolationCellPoint<scalar> rhoInterp(rho);
406 |     interpolationCellPoint<vector> UInterp(U);
407 |     interpolationCellPoint<scalar> nuInterp(nu);
408 |         interpolationCell<scalar> alpha1Interp(alpha1); //
409 |         interpolationCellPoint<scalar> pInterp(p); //
410 |      
411 |     bubble::trackingData
412 |         td(*this, rhoInterp, UInterp, nuInterp, alpha1Interp, pInterp, g_.value()); //
413 | 
414 | 
415 |     label celli;
416 |     label tetFacei;
417 |     label tetPti;
418 | 
419 |     volVectorField cellCentres = mesh_.C();
420 | 
421 |     // Find the cell, tetFacei and tetPti for point position
422 |     mesh_.findCellFacePt
423 |     (
424 |         position,
425 |         celli,
426 |         tetFacei,
427 |         tetPti
428 |     );
429 | 
430 |     label proci = -1;
431 | 
432 |     if (celli >= 0)
433 |     {
434 |         proci = Pstream::myProcNo();
435 |     }
436 | 
437 |     reduce(proci, maxOp<label>());
438 | 
439 |     // Ensure that only one processor attempts to insert this Parcel
440 |     if (proci != Pstream::myProcNo())
441 |     {
442 |         celli = -1;
443 |         tetFacei = -1;
444 |         tetPti = -1;
445 |     }
446 | 
447 |     // Last chance - find nearest cell and try that one - the point is
448 |     // probably on an edge
449 |     if (proci == -1)
450 |     {
451 |         celli = mesh_.findNearestCell(position);
452 | 
453 |         if (celli >= 0)
454 |         {
455 |             position += 1e-3*(cellCentres[celli] - position);
456 | 
457 |             mesh_.findCellFacePt
458 |             (
459 |                 position,
460 |                 celli,
461 |                 tetFacei,
462 |                 tetPti
463 |             );
464 | 
465 |             if (celli > 0)
466 |             {
467 |                 proci = Pstream::myProcNo();
468 |             }
469 |         }
470 | 
471 |         reduce(proci, maxOp<label>());
472 | 
473 |         if (proci != Pstream::myProcNo())
474 |         {
475 |             celli = -1;
476 |             tetFacei = -1;
477 |             tetPti = -1;
478 |         }
479 |     }
480 | 
481 |     if (celli > -1)
482 |     {
483 |         if(mag(velocity) > 0.01) //to avoid adding particles in damped cells
484 |         {
485 |            bubble* pPtr = new bubble(mesh_, position, celli, diameter, velocity);
486 |            pPtr->initialEquilibriumRadius(cloud, td);
487 |            Cloud<bubble>::addParticle(pPtr);
488 |         }
489 |     }
490 | }
491 | 
492 | 
493 | 
494 | // ************************************************************************* //
495 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------