Esempio n. 1
0
    static void updateHysteresis(Params &params, const FluidState &fluidState)
    {
        typedef MathToolbox<typename FluidState::Scalar> FsToolbox;

        switch (params.approach()) {
        case EclTwoPhaseGasOil: {
            Scalar So = FsToolbox::scalarValue(fluidState.saturation(oilPhaseIdx));

            params.oilWaterParams().update(/*pcSw=*/0.0, /*krwSw=*/0.0, /*krnSw=*/0.0);
            params.gasOilParams().update(/*pcSw=*/So, /*krwSw=*/So, /*krnSw=*/So);
            break;
        }

        case EclTwoPhaseOilWater: {
            Scalar Sw = FsToolbox::scalarValue(fluidState.saturation(waterPhaseIdx));

            params.oilWaterParams().update(/*pcSw=*/Sw, /*krwSw=*/Sw, /*krnSw=*/Sw);
            params.gasOilParams().update(/*pcSw=*/0.0, /*krwSw=*/0.0, /*krnSw=*/0.0);
            break;
        }

        case EclTwoPhaseGasWater: {
            Scalar Sw = FsToolbox::scalarValue(fluidState.saturation(waterPhaseIdx));

            params.oilWaterParams().update(/*pcSw=*/Sw, /*krwSw=*/Sw, /*krnSw=*/0);
            params.gasOilParams().update(/*pcSw=*/1.0, /*krwSw=*/0.0, /*krnSw=*/Sw);
            break;
        }
        }
    }
    static void relativePermeabilities(ContainerT &values,
                                       const Params &params,
                                       const FluidState &fluidState)
    {
        switch (params.approach()) {
        case EclStone1Approach:
            Stone1Material::relativePermeabilities(values,
                                                   params.template getRealParams<EclStone1Approach>(),
                                                   fluidState);
            break;

        case EclStone2Approach:
            Stone2Material::relativePermeabilities(values,
                                                   params.template getRealParams<EclStone2Approach>(),
                                                   fluidState);
            break;

        case EclDefaultApproach:
            DefaultMaterial::relativePermeabilities(values,
                                                    params.template getRealParams<EclDefaultApproach>(),
                                                    fluidState);
            break;

        case EclTwoPhaseApproach:
            TwoPhaseMaterial::relativePermeabilities(values,
                                                     params.template getRealParams<EclTwoPhaseApproach>(),
                                                     fluidState);
            break;
        }
    }
    /*
     * Hysteresis parameters for gas-oil
     * @see EclHysteresisTwoPhaseLawParams::pcSwMdc(...)
     * @see EclHysteresisTwoPhaseLawParams::krnSwMdc(...)
     * \param params Parameters
     */
    static void setGasOilHysteresisParams(const Scalar& pcSwMdc,
                                          const Scalar& krnSwMdc,
                                          Params& params)
    {
        switch (params.approach()) {
        case EclStone1Approach:
            Stone1Material::setGasOilHysteresisParams(pcSwMdc, krnSwMdc,
                                     params.template getRealParams<EclStone1Approach>());
            break;

        case EclStone2Approach:
            Stone2Material::setGasOilHysteresisParams(pcSwMdc, krnSwMdc,
                                     params.template getRealParams<EclStone2Approach>());
            break;

        case EclDefaultApproach:
            DefaultMaterial::setGasOilHysteresisParams(pcSwMdc, krnSwMdc,
                                     params.template getRealParams<EclDefaultApproach>());
            break;

        case EclTwoPhaseApproach:
            TwoPhaseMaterial::setGasOilHysteresisParams(pcSwMdc, krnSwMdc,
                                     params.template getRealParams<EclTwoPhaseApproach>());
            break;
        }
    }
Esempio n. 4
0
    static void capillaryPressures(ContainerT &values,
                                   const Params &params,
                                   const FluidState &fluidState)
    {
        typedef typename std::remove_reference<decltype(values[0])>::type Evaluation;
        typedef MathToolbox<typename FluidState::Scalar> FsToolbox;

        switch (params.approach()) {
        case EclTwoPhaseGasOil: {
            const Evaluation& So =
                FsToolbox::template decay<Evaluation>(fluidState.saturation(oilPhaseIdx));

            values[oilPhaseIdx] = 0.0;
            values[gasPhaseIdx] = GasOilMaterialLaw::twoPhaseSatPcnw(params.gasOilParams(), So);
            break;
        }

        case EclTwoPhaseOilWater: {
            const Evaluation& Sw =
                FsToolbox::template decay<Evaluation>(fluidState.saturation(waterPhaseIdx));

            values[waterPhaseIdx] = 0.0;
            values[oilPhaseIdx] = OilWaterMaterialLaw::twoPhaseSatPcnw(params.oilWaterParams(), Sw);
            break;
        }

        case EclTwoPhaseGasWater: {
            const Evaluation& Sw =
                FsToolbox::template decay<Evaluation>(fluidState.saturation(waterPhaseIdx));

            values[waterPhaseIdx] = 0.0;
            values[gasPhaseIdx] =
                OilWaterMaterialLaw::twoPhaseSatPcnw(params.oilWaterParams(), Sw)
                + GasOilMaterialLaw::twoPhaseSatPcnw(params.gasOilParams(), 0.0);
            break;
        }

        }
    }
    static void updateHysteresis(Params &params, const FluidState &fluidState)
    {
        switch (params.approach()) {
        case EclStone1Approach:
            Stone1Material::updateHysteresis(params.template getRealParams<EclStone1Approach>(),
                                             fluidState);
            break;

        case EclStone2Approach:
            Stone2Material::updateHysteresis(params.template getRealParams<EclStone2Approach>(),
                                             fluidState);
            break;

        case EclDefaultApproach:
            DefaultMaterial::updateHysteresis(params.template getRealParams<EclDefaultApproach>(),
                                              fluidState);
            break;

        case EclTwoPhaseApproach:
            TwoPhaseMaterial::updateHysteresis(params.template getRealParams<EclTwoPhaseApproach>(),
                                               fluidState);
            break;
        }
    }