OpenFOAM-5.x/tutorials/multiphase/reactingMultiphaseEulerFoam/laminar/mixerVessel2D/constant/phaseProperties

/*--------------------------------*- C++ -*----------------------------------*\
| =========                 |                                                 |
| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
|  \\    /   O peration     | Version:  dev                                   |
|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
|    \\/     M anipulation  |                                                 |
\*---------------------------------------------------------------------------*/
FoamFile
{
    version     2.0;
    format      ascii;
    class       dictionary;
    location    "constant";
    object      phaseProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

type heatAndMomentumTransferMultiphaseSystem;

phases (water oil mercury air);

water
{
    type            purePhaseModel;
    diameterModel   constant;
    constantCoeffs
    {
        d               1e-3;
    }

    residualAlpha 1e-3;
}

oil
{
    type            purePhaseModel;
    diameterModel constant;
    constantCoeffs
    {
        d               1e-3;
    }

    residualAlpha 1e-3;
}

mercury
{
    type            purePhaseModel;
    diameterModel constant;
    constantCoeffs
    {
        d               1e-3;
    }

    residualAlpha 1e-3;
}

air
{
    type            purePhaseModel;
    diameterModel   isothermal;
    isothermalCoeffs
    {
        d0              1e-3;
        p0              1e5;
    }

    residualAlpha 1e-3;
}

blending
{
    default
    {
        type            linear;
        minFullyContinuousAlpha.water 0.7;
        minPartlyContinuousAlpha.water 0.5;
        minFullyContinuousAlpha.oil 0.7;
        minPartlyContinuousAlpha.oil 0.5;
        minFullyContinuousAlpha.mercury 0.7;
        minPartlyContinuousAlpha.mercury 0.5;
        minFullyContinuousAlpha.air 0.7;
        minPartlyContinuousAlpha.air 0.5;
    }
}

surfaceTension
(
    (air and water)
    {
        type            constant;
        sigma           0.07;
    }
    (air and oil)
    {
        type            constant;
        sigma           0.07;
    }
    (air and mercury)
    {
        type            constant;
        sigma           0.07;
    }
    (water and oil)
    {
        type            constant;
        sigma           0;
    }
    (water and mercury)
    {
        type            constant;
        sigma           0;
    }
    (oil and mercury)
    {
        type            constant;
        sigma           0;
    }
);

interfaceCompression
(
    (air and water)     0
    (air and oil)       0
    (air and mercury)   0
    (water and oil)     0
    (water and mercury) 0
    (oil and mercury)   0
);

aspectRatio
();

drag
(
    (air in water)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (water in air)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (air and water)
    {
        type            segregated;

        m               0.5;
        n               8;
        swarmCorrection
        {
            type        none;
        }
    }


    (air in oil)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (oil in air)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (air and oil)
    {
        type            segregated;

        m               0.5;
        n               8;
        swarmCorrection
        {
            type        none;
        }
    }


    (air in mercury)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (mercury in air)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (air and mercury)
    {
        type            segregated;

        m               0.5;
        n               8;
        swarmCorrection
        {
            type        none;
        }
    }



    (water in oil)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (oil in water)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (water and oil)
    {
        type            segregated;

        m               0.5;
        n               8;
        swarmCorrection
        {
            type        none;
        }
    }


    (water in mercury)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (mercury in water)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (water and mercury)
    {
        type            segregated;

        m               0.5;
        n               8;
        swarmCorrection
        {
            type        none;
        }
    }



    (oil in mercury)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (mercury in oil)
    {
        type            SchillerNaumann;

        residualRe      1e-3;
        swarmCorrection
        {
            type        none;
        }
    }

    (oil and mercury)
    {
        type            segregated;

        m               0.5;
        n               8;
        swarmCorrection
        {
            type        none;
        }
    }
);

virtualMass
(
    (air in water)
    {
        type            constantCoefficient;
        Cvm             0.5;
    }

    (air in oil)
    {
        type            constantCoefficient;
        Cvm             0.5;
    }

    (air in mercury)
    {
        type            constantCoefficient;
        Cvm             0.5;
    }
);

heatTransfer
(
    (air in water)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (water in air)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (air in oil)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (oil in air)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (air in mercury)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (mercury in air)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }


    (water in oil)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (oil in water)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (water in mercury)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (mercury in water)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }


    (oil in mercury)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }

    (mercury in oil)
    {
        type            RanzMarshall;
        residualAlpha   1e-3;
    }
);

wallLubrication
();

turbulentDispersion
();

// Minimum allowable pressure
pMin            10000;


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