WellTest.hpp

Go to the documentation of this file.

/*
  Copyright 2017 SINTEF Digital, Mathematics and Cybernetics.
  Copyright 2017 Statoil ASA.
  Copyright 2017 IRIS
  Copyright 2019 Norce
 
  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 OPM_WELL_TEST_HEADER_INCLUDED
#define OPM_WELL_TEST_HEADER_INCLUDED
 
#include <opm/common/utility/TimeService.hpp>
 
#include <opm/input/eclipse/Units/UnitSystem.hpp>
 
#include <cstddef>
#include <limits>
#include <string>
#include <string_view>
#include <unordered_set>
#include <vector>
 
namespace Opm
{
 
class DeferredLogger;
template<typename Scalar, typename IndexTraits> class SingleWellState;
class UnitSystem;
class WellEconProductionLimits;
template<typename Scalar, typename IndexTraits> class WellInterfaceGeneric;
class WellTestState;
 
template<typename Scalar, typename IndexTraits>
class WellTest {
public:
    explicit WellTest(const WellInterfaceGeneric<Scalar, IndexTraits>& well) : well_(well) {}
 
    void updateWellTestStateEconomic(const SingleWellState<Scalar, IndexTraits>& ws,
                                     const double simulation_time,
                                     const bool write_message_to_opmlog,
                                     const bool during_well_test,
                                     WellTestState& well_test_state,
                                     bool zero_group_target,
                                     const UnitSystem& unit_system,
                                     const time_point start_time,
                                     DeferredLogger& deferred_logger,
                                     std::string* closure_reason = nullptr) const;
 
    void updateWellTestStateCECON(const SingleWellState<Scalar, IndexTraits>& ws,
                                  const double simulation_time,
                                  const bool write_message_to_opmlog,
                                  WellTestState& well_test_state,
                                  const UnitSystem& unit_system,
                                  const time_point start_time,
                                  DeferredLogger& deferred_logger) const;
 
    void updateWellTestStatePhysical(const double simulation_time,
                                     const bool write_message_to_opmlog,
                                     WellTestState& well_test_state,
                                     DeferredLogger& deferred_logger) const;
 
private:
    struct RatioLimitCheckReport {
        static constexpr int INVALIDCOMPLETION = std::numeric_limits<int>::max();
        static constexpr Scalar INFINITE_RATIO = std::numeric_limits<Scalar>::infinity();
        bool ratio_limit_violated = false;
        int worst_offending_completion = INVALIDCOMPLETION;
        Scalar violation_extent = 0.0;
        std::string ratio_name{};
        UnitSystem::measure ratio_measure = UnitSystem::measure::identity;
        Scalar ratio_value = 0.0;
        Scalar ratio_limit = 0.0;
    };
 
    struct RateLimitCheckReport {
        std::string_view quantity_name{};
        UnitSystem::measure rate_measure = UnitSystem::measure::identity;
        Scalar rate_value = 0.0;
        Scalar rate_limit = 0.0;
    };
 
    void reportEconomicLimitClosure(const std::string& when,
                                    const std::string& reason,
                                    const bool write_message_to_opmlog,
                                    std::string* closure_reason,
                                    DeferredLogger& deferred_logger) const;
 
    static std::string rateViolationReason(const UnitSystem& unit_system,
                                           const RateLimitCheckReport& report,
                                           const bool on_potentials);
 
    static std::string ratioViolationReason(const UnitSystem& unit_system,
                                            std::string_view ratio_name,
                                            const UnitSystem::measure ratio_measure,
                                            const Scalar ratio_value,
                                            const Scalar ratio_limit);
 
    template<class RatioFunc>
    void checkMaxRatioLimit(const SingleWellState<Scalar, IndexTraits>& ws,
                            const Scalar max_ratio_limit,
                            const RatioFunc& ratioFunc,
                            const std::unordered_set<int>& excluded_completions,
                            const std::string& ratio_name,
                            const UnitSystem::measure ratio_measure,
                            RatioLimitCheckReport& report) const;
 
    template<class RatioFunc>
    bool checkMaxRatioLimitWell(const SingleWellState<Scalar, IndexTraits>& ws,
                                const Scalar max_ratio_limit,
                                const RatioFunc& ratioFunc,
                                const std::unordered_set<int>& excluded_completions,
                                Scalar& well_ratio_value) const;
 
    template<class RatioFunc>
    void checkMaxRatioLimitCompletions(const SingleWellState<Scalar, IndexTraits>& ws,
                                       const Scalar max_ratio_limit,
                                       const Scalar well_ratio_value,
                                       const RatioFunc& ratioFunc,
                                       const std::unordered_set<int>& excluded_completions,
                                       const std::string& ratio_name,
                                       const UnitSystem::measure ratio_measure,
                                       RatioLimitCheckReport& report) const;
 
    bool checkRateEconLimits(const WellEconProductionLimits& econ_production_limits,
                             const std::vector<Scalar>& rates_or_potentials,
                             RateLimitCheckReport& report) const;
 
    RatioLimitCheckReport
    checkRatioEconLimits(const WellEconProductionLimits& econ_production_limits,
                         const SingleWellState<Scalar, IndexTraits>& ws,
                         const std::unordered_set<int>& excluded_completions,
                         DeferredLogger& deferred_logger) const;
 
    std::string completionDescriptor(int complnum) const;
 
    bool closeOffendingCompletion(int offending_completion,
                                  bool close_connections_below,
                                  double simulation_time,
                                  bool write_message_to_opmlog,
                                  WellTestState& well_test_state,
                                  const std::string& when,
                                  const std::string& reason,
                                  std::string_view ratio_subject,
                                  std::unordered_set<int>& closed_this_event,
                                  DeferredLogger& deferred_logger) const;
 
    const WellInterfaceGeneric<Scalar, IndexTraits>& well_; 
};
 
}
 
#endif // OPM_WELL_TEST_HEADER_INCLUDED