blackoilmodel.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  This file is part of the Open Porous Media project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
 
  Consult the COPYING file in the top-level source directory of this
  module for the precise wording of the license and the list of
  copyright holders.
*/
#ifndef OPM_BLACK_OIL_MODEL_HPP
#define OPM_BLACK_OIL_MODEL_HPP
 
#include <opm/material/densead/Math.hpp>
 
#include <opm/material/fluidsystems/BlackOilFluidSystem.hpp>
 
#include <opm/models/blackoil/blackoilmodules.hpp>
#include <opm/models/blackoil/blackoilboundaryratevector.hh>
#include <opm/models/blackoil/blackoildarcyfluxmodule.hh>
#include <opm/models/blackoil/blackoilextensivequantities.hh>
#include <opm/models/blackoil/blackoilvariableandequationindices.hh>
#include <opm/models/blackoil/blackoilintensivequantities.hh>
#include <opm/models/blackoil/blackoillocalresidual.hh>
#include <opm/models/blackoil/blackoilnewtonmethod.hpp>
#include <opm/models/blackoil/blackoilprimaryvariables.hh>
#include <opm/models/blackoil/blackoilproblem.hh>
#include <opm/models/blackoil/blackoilproperties.hh>
#include <opm/models/blackoil/blackoilratevector.hh>
#include <opm/models/blackoil/blackoiltwophaseindices.hh>
 
#include <opm/models/common/multiphasebasemodel.hh>
 
#include <opm/models/io/vtkblackoilmodule.hpp>
#include <opm/models/io/vtkcompositionmodule.hpp>
#include <opm/models/io/vtkdiffusionmodule.hpp>
 
#include <opm/models/utils/propertysystem.hh>
 
#include <cassert>
#include <istream>
#include <limits>
#include <memory>
#include <ostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <tuple>
#include <vector>
 
namespace Opm {
 
template <class TypeTag>
class BlackOilModel;
 
}
 
namespace Opm::Properties {
 
namespace TTag {
 
struct BlackOilModel
{ using InheritsFrom = std::tuple<MultiPhaseBaseModel>; };
 
} // namespace TTag
 
template<class TypeTag>
struct LocalResidual<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilLocalResidual<TypeTag>; };
 
template<class TypeTag>
struct NewtonMethod<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilNewtonMethod<TypeTag>; };
 
template<class TypeTag>
struct Model<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilModel<TypeTag>; };
 
template<class TypeTag>
struct BaseProblem<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilProblem<TypeTag>; };
 
template<class TypeTag>
struct RateVector<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilRateVector<TypeTag>; };
 
template<class TypeTag>
struct BoundaryRateVector<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilBoundaryRateVector<TypeTag>; };
 
template<class TypeTag>
struct PrimaryVariables<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilPrimaryVariables<TypeTag>; };
 
template<class TypeTag>
struct IntensiveQuantities<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilIntensiveQuantities<TypeTag>; };
 
template<class TypeTag>
struct ExtensiveQuantities<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilExtensiveQuantities<TypeTag>; };
 
template<class TypeTag>
struct FluxModule<TypeTag, TTag::BlackOilModel>
{ using type = BlackOilDarcyFluxModule<TypeTag>; };
 
template<class TypeTag>
struct Indices<TypeTag, TTag::BlackOilModel>
{
    using type = BlackOilVariableAndEquationIndices<getPropValue<TypeTag, Properties::EnableSolvent>(),
                                                    getPropValue<TypeTag, Properties::EnableExtbo>(),
                                                    getPropValue<TypeTag, Properties::EnablePolymer>(),
                                                    getPropValue<TypeTag, Properties::EnergyModuleType>() == EnergyModules::FullyImplicitThermal,
                                                    getPropValue<TypeTag, Properties::EnableFoam>(),
                                                    getPropValue<TypeTag, Properties::EnableBrine>(),
                                                    /*PVOffset=*/0,
                                                    getPropValue<TypeTag, Properties::EnableBioeffects>()>;
};
 
template<class TypeTag>
struct FluidSystem<TypeTag, TTag::BlackOilModel>
{
public:
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using Evaluation = GetPropType<TypeTag, Properties::Evaluation>;
    using type = BlackOilFluidSystem<Scalar>;
};
 
// by default, all ECL extension modules are disabled
template<class TypeTag>
struct EnableSolvent<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableExtbo<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnablePolymer<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnablePolymerMW<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableFoam<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableBrine<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableVapwat<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableDisgasInWater<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableSaltPrecipitation<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableBioeffects<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnergyModuleType<TypeTag, TTag::BlackOilModel>
{ static constexpr EnergyModules value = EnergyModules::NoTemperature; };
 
template<class TypeTag>
struct EnableDiffusion<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableDispersion<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableConvectiveMixing<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct EnableMech<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct RunAssemblyOnGpu<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
template<class TypeTag>
struct BlackOilEnergyScalingFactor<TypeTag, TTag::BlackOilModel>
{
private:
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    static constexpr Scalar alpha =
        getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>() ? 1000.0 : 1.0;
 
public:
    using type = Scalar;
    static constexpr Scalar value = 1.0/(30.0*4184.0*alpha);
};
 
template<class TypeTag>
struct BlackOilUreaScalingFactor<TypeTag, TTag::BlackOilModel>
{
private:
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    static constexpr Scalar alpha =
        getPropValue<TypeTag, Properties::BlackoilConserveSurfaceVolume>() ? 1000.0 : 1.0;
 
public:
    using type = Scalar;
    static constexpr Scalar value = 1.0/(10.0*alpha);
};
 
// by default, ebos formulates the conservation equations in terms of mass not surface
// volumes
template<class TypeTag>
struct BlackoilConserveSurfaceVolume<TypeTag, TTag::BlackOilModel>
{ static constexpr bool value = false; };
 
} // namespace Opm::Properties
 
namespace Opm {
 
template<class TypeTag >
class BlackOilModel
    : public MultiPhaseBaseModel<TypeTag>
{
public:
    using Indices = GetPropType<TypeTag, Properties::Indices>;
    using FluidSystem = GetPropType<TypeTag, Properties::FluidSystem>;
    using PrimaryVariables = GetPropType<TypeTag, Properties::PrimaryVariables>;
 
private:
    using Implementation = GetPropType<TypeTag, Properties::Model>;
    using ParentType = MultiPhaseBaseModel<TypeTag>;
 
    using Scalar = GetPropType<TypeTag, Properties::Scalar>;
    using Simulator = GetPropType<TypeTag, Properties::Simulator>;
    using Discretization = GetPropType<TypeTag, Properties::Discretization>;
    using ElementContext = GetPropType<TypeTag, Properties::ElementContext>;
 
    enum { numComponents = FluidSystem::numComponents };
    enum { numEq = getPropValue<TypeTag, Properties::NumEq>() };
 
    static constexpr bool compositionSwitchEnabled =
        Indices::compositionSwitchIdx != std::numeric_limits<unsigned>::max();
    static constexpr bool enableBioeffects = getPropValue<TypeTag, Properties::EnableBioeffects>();
    static constexpr bool enableDiffusion = getPropValue<TypeTag, Properties::EnableDiffusion>();
    static constexpr bool enableDispersion = getPropValue<TypeTag, Properties::EnableDispersion>();
    static constexpr bool enableExtbo = getPropValue<TypeTag, Properties::EnableExtbo>();
    static constexpr bool enablePolymer = getPropValue<TypeTag, Properties::EnablePolymer>();
    static constexpr bool enableSolvent = getPropValue<TypeTag, Properties::EnableSolvent>();
    static constexpr EnergyModules energyModuleType = getPropValue<TypeTag, Properties::EnergyModuleType>();
    static constexpr bool enableFullyImplicitThermal = energyModuleType == EnergyModules::FullyImplicitThermal;
    static constexpr bool waterEnabled = Indices::waterEnabled;
 
    using BioeffectsModule = BlackOilBioeffectsModule<TypeTag, enableBioeffects>;
    using DiffusionModule = BlackOilDiffusionModule<TypeTag, enableDiffusion>;
    using DispersionModule = BlackOilDispersionModule<TypeTag, enableDispersion>;
    using EnergyModule = BlackOilEnergyModule<TypeTag, energyModuleType>;
    using ExtboModule = BlackOilExtboModule<TypeTag, enableExtbo>;
    using PolymerModule = BlackOilPolymerModule<TypeTag, enablePolymer>;
    using SolventModule = BlackOilSolventModule<TypeTag, enableSolvent>;
 
public:
    using LocalResidual = GetPropType<TypeTag, Properties::LocalResidual>;
 
    explicit BlackOilModel(Simulator& simulator)
        : ParentType(simulator)
    {
        eqWeights_.resize(numEq, 1.0);
    }
 
    static void registerParameters()
    {
        ParentType::registerParameters();
 
        if constexpr (enableSolvent) {
            SolventModule::registerParameters();
        }
        if constexpr (enableExtbo) {
            ExtboModule::registerParameters();
        }
        if constexpr (enablePolymer) {
            PolymerModule::registerParameters();
        }
        if constexpr (enableFullyImplicitThermal) {
            EnergyModule::registerParameters();
        }
        if constexpr (enableDiffusion) {
            DiffusionModule::registerParameters();
        }
        if constexpr (enableBioeffects) {
            BioeffectsModule::registerParameters();
        }
 
        // register runtime parameters of the VTK output modules
        VtkBlackOilModule<TypeTag>::registerParameters();
        VtkCompositionModule<TypeTag>::registerParameters();
        if constexpr (enableDiffusion) {
            VtkDiffusionModule<TypeTag>::registerParameters();
        }
    }
 
    static std::string name()
    { return "blackoil"; }
 
    std::string primaryVarName(unsigned pvIdx) const
    {
        if (pvIdx == Indices::waterSwitchIdx) {
            return "water_switching";
        }
        else if (pvIdx == Indices::pressureSwitchIdx) {
            return "pressure_switching";
        }
        else if (pvIdx == Indices::compositionSwitchIdx) {
            return "composition_switching";
        }
 
        if constexpr (enableSolvent) {
            if (SolventModule::primaryVarApplies(pvIdx)) {
                return SolventModule::primaryVarName(pvIdx);
            }
        }
 
        if constexpr (enableExtbo) {
            if (ExtboModule::primaryVarApplies(pvIdx)) {
                return ExtboModule::primaryVarName(pvIdx);
            }
        }
 
        if constexpr (enablePolymer) {
            if (PolymerModule::primaryVarApplies(pvIdx)) {
                return PolymerModule::primaryVarName(pvIdx);
            }
        }
 
        if constexpr (enableFullyImplicitThermal) {
            if (EnergyModule::primaryVarApplies(pvIdx)) {
                return EnergyModule::primaryVarName(pvIdx);
            }
        }
 
        throw std::logic_error("Invalid primary variable index");
    }
 
    std::string eqName(int eqIdx) const
    {
        if (Indices::conti0EqIdx <= eqIdx && eqIdx < Indices::conti0EqIdx + numComponents) {
            std::ostringstream oss;
            oss << "conti_" << FluidSystem::phaseName(eqIdx - Indices::conti0EqIdx);
            return oss.str();
        }
 
        if constexpr (enableSolvent) {
            if (SolventModule::eqApplies(eqIdx)) {
                return SolventModule::eqName(eqIdx);
            }
        }
 
        if constexpr (enableExtbo) {
            if (ExtboModule::eqApplies(eqIdx)) {
                return ExtboModule::eqName(eqIdx);
            }
        }
 
        if constexpr (enablePolymer) {
            if (PolymerModule::eqApplies(eqIdx)) {
                return PolymerModule::eqName(eqIdx);
            }
        }
 
        if constexpr (enableFullyImplicitThermal) {
            if (EnergyModule::eqApplies(eqIdx)) {
                return EnergyModule::eqName(eqIdx);
            }
        }
 
        throw std::logic_error("Invalid equation index");
    }
 
    Scalar primaryVarWeight(unsigned globalDofIdx, unsigned pvIdx) const
    {
        // do not care about the auxiliary equations as they are supposed to scale
        // themselves
        if (globalDofIdx >= this->numGridDof()) {
            return 1.0;
        }
 
        // saturations are always in the range [0, 1]!
        if (Indices::waterSwitchIdx == pvIdx) {
            return 1.0;
        }
 
        // oil pressures usually are in the range of 100 to 500 bars for typical oil
        // reservoirs (which is the only relevant application for the black-oil model).
        else if (int(Indices::pressureSwitchIdx) == int(pvIdx)) {
            return 1.0 / 300e5;
        }
 
        // deal with primary variables stemming from the solvent module
        if constexpr (enableSolvent) {
            if (SolventModule::primaryVarApplies(pvIdx)) {
                return SolventModule::primaryVarWeight(pvIdx);
            }
        }
 
        // deal with primary variables stemming from the extBO module
        if constexpr (enableExtbo) {
            if (ExtboModule::primaryVarApplies(pvIdx)) {
                return ExtboModule::primaryVarWeight(pvIdx);
            }
        }
 
        // deal with primary variables stemming from the polymer module
        if constexpr (enablePolymer) {
            if (PolymerModule::primaryVarApplies(pvIdx)) {
                return PolymerModule::primaryVarWeight(pvIdx);
            }
        }
 
        // deal with primary variables stemming from the energy module
        if constexpr (enableFullyImplicitThermal) {
            if (EnergyModule::primaryVarApplies(pvIdx)) {
                return EnergyModule::primaryVarWeight(pvIdx);
            }
        }
 
        // if the primary variable is either the gas saturation, Rs or Rv
        assert(Indices::compositionSwitchIdx == pvIdx);
 
        switch (this->solution(0)[globalDofIdx].primaryVarsMeaningGas()) {
        case PrimaryVariables::GasMeaning::Sg: return 1.0; // gas saturation
        case PrimaryVariables::GasMeaning::Rs: return 1.0 / 250.; // gas dissolution factor
        case PrimaryVariables::GasMeaning::Rv: return 1.0 / 0.025; // oil vaporization factor
        default: throw std::logic_error("Invalid primary variable meaning flag for gas");
        }
    }
 
    Scalar eqWeight(unsigned globalDofIdx, unsigned eqIdx) const
    {
        // do not care about the auxiliary equations as they are supposed to scale
        // themselves
        if (globalDofIdx >= this->numGridDof()) {
            return 1.0;
        }
 
        return eqWeights_[eqIdx];
    }
 
    void setEqWeight(unsigned eqIdx, Scalar value)
    { eqWeights_[eqIdx] = value; }
 
    template <class DofEntity>
    void serializeEntity(std::ostream& outstream, const DofEntity& dof)
    {
        const unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
 
        // write phase state
        if (!outstream.good()) {
            throw std::runtime_error("Could not serialize degree of freedom " + std::to_string(dofIdx));
        }
 
        // write the primary variables
        const auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
        for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx) {
            outstream << priVars[eqIdx] << " ";
        }
 
        // write the pseudo primary variables
        outstream << static_cast<int>(priVars.primaryVarsMeaningGas()) << " ";
        outstream << static_cast<int>(priVars.primaryVarsMeaningWater()) << " ";
        outstream << static_cast<int>(priVars.primaryVarsMeaningPressure()) << " ";
 
        outstream << priVars.pvtRegionIndex() << " ";
 
        if constexpr (enableSolvent) {
            SolventModule::serializeEntity(asImp_(), outstream, dof);
        }
        if constexpr (enableExtbo) {
            ExtboModule::serializeEntity(asImp_(), outstream, dof);
        }
        if constexpr (enablePolymer) {
            PolymerModule::serializeEntity(asImp_(), outstream, dof);
        }
        if constexpr (enableFullyImplicitThermal) {
            EnergyModule::serializeEntity(asImp_(), outstream, dof);
        }
    }
 
    template <class DofEntity>
    void deserializeEntity(std::istream& instream,
                           const DofEntity& dof)
    {
        const unsigned dofIdx = static_cast<unsigned>(asImp_().dofMapper().index(dof));
 
        // read in the "real" primary variables of the DOF
        auto& priVars = this->solution(/*timeIdx=*/0)[dofIdx];
        for (unsigned eqIdx = 0; eqIdx < numEq; ++eqIdx) {
            if (!instream.good()) {
                throw std::runtime_error("Could not deserialize degree of freedom " + std::to_string(dofIdx));
            }
            instream >> priVars[eqIdx];
        }
 
        // read the pseudo primary variables
        unsigned primaryVarsMeaningGas;
        instream >> primaryVarsMeaningGas;
 
        unsigned primaryVarsMeaningWater;
        instream >> primaryVarsMeaningWater;
 
        unsigned primaryVarsMeaningPressure;
        instream >> primaryVarsMeaningPressure;
 
        unsigned pvtRegionIdx;
        instream >> pvtRegionIdx;
 
        if (!instream.good()) {
            throw std::runtime_error("Could not deserialize degree of freedom " + std::to_string(dofIdx));
        }
 
        if constexpr (enableSolvent) {
            SolventModule::deserializeEntity(asImp_(), instream, dof);
        }
        if constexpr (enableExtbo) {
            ExtboModule::deserializeEntity(asImp_(), instream, dof);
        }
        if constexpr (enablePolymer) {
            PolymerModule::deserializeEntity(asImp_(), instream, dof);
        }
        if constexpr (enableFullyImplicitThermal) {
            EnergyModule::deserializeEntity(asImp_(), instream, dof);
        }
 
        using PVM_G = typename PrimaryVariables::GasMeaning;
        using PVM_W = typename PrimaryVariables::WaterMeaning;
        using PVM_P = typename PrimaryVariables::PressureMeaning;
        priVars.setPrimaryVarsMeaningGas(static_cast<PVM_G>(primaryVarsMeaningGas));
        priVars.setPrimaryVarsMeaningWater(static_cast<PVM_W>(primaryVarsMeaningWater));
        priVars.setPrimaryVarsMeaningPressure(static_cast<PVM_P>(primaryVarsMeaningPressure));
 
        priVars.setPvtRegionIndex(pvtRegionIdx);
    }
 
    template <class Restarter>
    void deserialize(Restarter& res)
    {
        ParentType::deserialize(res);
 
        // set the PVT indices of the primary variables. This is also done by writing
        // them into the restart file and re-reading them, but it is better to calculate
        // them from scratch because the input could have been changed in this regard...
        ElementContext elemCtx(this->simulator_);
        for (const auto& elem : elements(this->gridView())) {
            elemCtx.updateStencil(elem);
            for (unsigned dofIdx = 0; dofIdx < elemCtx.numPrimaryDof(/*timIdx=*/0); ++dofIdx) {
                const unsigned globalDofIdx = elemCtx.globalSpaceIndex(dofIdx, /*timIdx=*/0);
                updatePvtRegionIndex_(this->solution(/*timeIdx=*/0)[globalDofIdx],
                                      elemCtx,
                                      dofIdx,
                                      /*timeIdx=*/0);
            }
        }
 
        this->solution(/*timeIdx=*/1) = this->solution(/*timeIdx=*/0);
    }
 
/*
    // hack: this interferes with the static polymorphism trick
protected:
    friend ParentType;
    friend Discretization;
*/
 
    template <class Context>
    void supplementInitialSolution_(PrimaryVariables& priVars,
                                    const Context& context,
                                    unsigned dofIdx,
                                    unsigned timeIdx)
    { updatePvtRegionIndex_(priVars, context, dofIdx, timeIdx); }
 
    void registerOutputModules_()
    {
        ParentType::registerOutputModules_();
 
        // add the VTK output modules which make sense for the blackoil model
        if constexpr (enableSolvent) {
            SolventModule::registerOutputModules(asImp_(), this->simulator_);
        }
        if constexpr (enablePolymer) {
            PolymerModule::registerOutputModules(asImp_(), this->simulator_);
        }
        if constexpr (enableFullyImplicitThermal) {
            EnergyModule::registerOutputModules(asImp_(), this->simulator_);
        }
        if constexpr (enableBioeffects) {
            BioeffectsModule::registerOutputModules(asImp_(), this->simulator_);
        }
 
        this->addOutputModule(std::make_unique<VtkBlackOilModule<TypeTag>>(this->simulator_));
        this->addOutputModule(std::make_unique<VtkCompositionModule<TypeTag>>(this->simulator_));
 
        if constexpr (enableDiffusion) {
            this->addOutputModule(std::make_unique<VtkDiffusionModule<TypeTag>>(this->simulator_));
        }
    }
 
private:
    std::vector<Scalar> eqWeights_;
 
    Implementation& asImp_()
    { return *static_cast<Implementation*>(this); }
 
    const Implementation& asImp_() const
    { return *static_cast<const Implementation*>(this); }
 
    template <class Context>
    void updatePvtRegionIndex_(PrimaryVariables& priVars,
                               const Context& context,
                               unsigned dofIdx,
                               unsigned timeIdx)
    {
        const unsigned regionIdx = context.problem().pvtRegionIndex(context, dofIdx, timeIdx);
        priVars.setPvtRegionIndex(regionIdx);
    }
};
 
} // namespace Opm
 
#endif // OPM_BLACK_OIL_MODEL_HPP