WellPerformanceEventTracker.hpp

Go to the documentation of this file.

/*
  Copyright 2026 Equinor ASA.
 
  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_PERFORMANCE_EVENT_TRACKER_HEADER_INCLUDED
#define OPM_WELL_PERFORMANCE_EVENT_TRACKER_HEADER_INCLUDED
 
#include <opm/input/eclipse/Schedule/Well/Well.hpp>
 
#include <opm/output/data/Wells.hpp>
 
#include <map>
#include <string>
#include <utility>
#include <vector>
 
namespace Opm
{
 
class Schedule;
 
struct WellStatusSnapshot {
    using ConnectionID = std::pair<int, std::size_t>;
 
    struct Entry {
        WellStatus status {WellStatus::SHUT};
 
        std::vector<ConnectionID> openConnections {};
 
        std::vector<ConnectionID> closedBelowOffender {};
 
        std::vector<int> openCompletions {};
 
        int topCompletion {0};
 
        bool operator==(const Entry& rhs) const
        {
            return (this->status == rhs.status)
                && (this->openConnections == rhs.openConnections)
                && (this->closedBelowOffender == rhs.closedBelowOffender)
                && (this->openCompletions == rhs.openCompletions)
                && (this->topCompletion == rhs.topCompletion);
        }
 
        template <class Serializer>
        void serializeOp(Serializer& serializer)
        {
            serializer(status);
            serializer(openConnections);
            serializer(closedBelowOffender);
            serializer(openCompletions);
            serializer(topCompletion);
        }
    };
 
    std::map<std::string, Entry> wells {};
 
    bool operator==(const WellStatusSnapshot& rhs) const
    {
        return this->wells == rhs.wells;
    }
 
    template <class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(wells);
    }
};
 
class WellPerformanceEventTracker
{
public:
    void beginTimeStep(const Schedule& schedule,
                       int reportStep,
                       WellStatusSnapshot snapshot);
 
    void commitTimeStep(const Schedule& schedule, int reportStep);
 
    void applyDeckChanges(WellStatusSnapshot snapshot);
 
    void recordWellStatusChangeForRetry(const std::string& wellName, WellStatus status);
 
    void accumulate(WellStatusSnapshot current);
 
    const data::WellPerformanceEvents& events(const std::string& wellName) const;
 
    static WellPerformanceEventTracker serializationTestObject();
 
    bool operator==(const WellPerformanceEventTracker& rhs) const
    {
        return (this->events_ == rhs.events_) && (this->previous_ == rhs.previous_)
            && (this->lastAccepted_ == rhs.lastAccepted_)
            && (this->hasLastAccepted_ == rhs.hasLastAccepted_)
            && (this->injector_ == rhs.injector_)
            && (this->pendingStatusEvents_ == rhs.pendingStatusEvents_);
    }
 
    template <class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(events_);
        serializer(previous_);
        serializer(lastAccepted_);
        serializer(hasLastAccepted_);
        serializer(injector_);
        serializer(pendingStatusEvents_);
    }
 
private:
    std::map<std::string, data::WellPerformanceEvents> events_ {};
 
    WellStatusSnapshot previous_ {};
 
    WellStatusSnapshot lastAccepted_ {};
 
    bool hasLastAccepted_ {false};
 
    std::map<std::string, bool> injector_ {};
 
    std::map<std::string, data::WellPerformanceEvents> pendingStatusEvents_ {};
 
    void accumulate(WellStatusSnapshot current, bool trackStatus);
};
 
} // namespace Opm
 
#endif // OPM_WELL_PERFORMANCE_EVENT_TRACKER_HEADER_INCLUDED