WDFAC.hpp

/*
  Copyright 2023 Equinor.

  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 3 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/>.
*/

#ifndef WDFAC_HPP_HEADER_INCLUDED
#define WDFAC_HPP_HEADER_INCLUDED

#include <stdexcept>

#include <fmt/format.h>

namespace Opm {
    class Connection;
    class DeckRecord;
    class WellConnections;
} // namespace Opm

namespace Opm { namespace RestartIO {
    struct RstWell;
}} // namespace Opm::RestartIO

namespace Opm {

    class WDFAC
    {
    public:
        struct Correlation
        {
            double coeff_a{0.0};

            double exponent_b{0.0};

            double exponent_c{0.0};

            static Correlation serializationTestObject();

            bool operator==(const Correlation& other) const;

            bool operator!=(const Correlation& other) const
            {
                return ! (*this == other);
            }

            template <class Serializer>
            void serializeOp(Serializer& serializer)
            {
                serializer(this->coeff_a);
                serializer(this->exponent_b);
                serializer(this->exponent_c);
            }
        };

        WDFAC() = default;

        explicit WDFAC(const RestartIO::RstWell& rst_well);

        static WDFAC serializationTestObject();

        void updateWDFAC(const DeckRecord& record);

        void updateWDFACCOR(const DeckRecord& record);

        void updateWDFACType(const WellConnections& connections);

        void updateTotalCF(const WellConnections& connections);

        template <typename DensityCallback, typename GasViscCallback>
        double getDFactor(DensityCallback&& rhoGS,
                          GasViscCallback&& gas_visc,
                          const Connection& conn) const
        {
            switch (this->m_type) {
            case WDFacType::NONE:
                return 0.0;

            case WDFacType::DFACTOR:
                return this->scaledWellLevelDFactor(this->m_d, conn);

            case WDFacType::DAKEMODEL:
                return this->dakeModelDFactor(rhoGS(), gas_visc(), conn);

            case WDFacType::CON_DFACTOR:
                return this->connectionLevelDFactor(conn);
            }

            throw std::runtime_error {
                fmt::format(fmt::runtime("Unknown D-Factor model '{}'"),
                            static_cast<int>(this->m_type))
            };
        }

        const Correlation& getDFactorCorrelationCoefficients() const
        {
            return this->m_corr;
        }

        bool useDFactor() const;

        bool operator==(const WDFAC& other) const;

        bool operator!=(const WDFAC& other) const
        {
            return ! (*this == other);
        }

        template <class Serializer>
        void serializeOp(Serializer& serializer)
        {
            serializer(this->m_type);
            serializer(this->m_d);
            serializer(this->m_total_cf);
            serializer(this->m_corr);
        }

    private:
        enum class WDFacType
        {
            NONE = 1,

            DFACTOR = 2,

            DAKEMODEL = 3,

            CON_DFACTOR = 4,
        };

        WDFacType m_type { WDFacType::NONE };

        double m_d{0.0};

        double m_total_cf{-1.0};

        Correlation m_corr{};

        double connectionLevelDFactor(const Connection& conn) const;

        double dakeModelDFactor(const double      rhoGS,
                                const double      gas_visc,
                                const Connection& conn) const;

        double scaledWellLevelDFactor(const double      dfac,
                                      const Connection& conn) const;
    };

} // namespace Opm

#endif  // WDFAC_HPP_HEADER_INCLUDED