InterRegFlows.hpp

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:
/*
  Copyright 2022 Equinor AS
 
  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_INTERREG_FLOWS_MODULE_HPP
#define OPM_INTERREG_FLOWS_MODULE_HPP
 
#include <opm/output/data/InterRegFlowMap.hpp>
 
#include <algorithm>
#include <cstddef>
#include <string>
#include <utility>
#include <vector>
 
 
namespace Opm {
 
    class InterRegFlowMap;
 
    class InterRegFlowMapSingleFIP
    {
    public:
        struct Cell {
            int activeIndex{-1};
 
            int cartesianIndex{-1};
 
            bool isInterior{true};
        };
 
        friend class InterRegFlowMap;
 
        explicit InterRegFlowMapSingleFIP(const std::vector<int>& region);
 
        void addConnection(const Cell& source,
                           const Cell& destination,
                           const data::InterRegFlowMap::FlowRates& rates);
 
        void compress();
 
        void clear();
 
        const data::InterRegFlowMap& getInterRegFlows() const;
 
        std::size_t getLocalMaxRegionID() const;
 
        bool assignGlobalMaxRegionID(const std::size_t regID);
 
        template <class MessageBufferType>
        void write(MessageBufferType& buffer) const
        {
            // Note: this->region_ is *intentionally* omitted here.
            buffer.write(this->maxGlobalRegionID_);
            this->iregFlow_.write(buffer);
        }
 
        template <class MessageBufferType>
        void read(MessageBufferType& buffer)
        {
            auto otherMaxRegionID = 0 * this->maxGlobalRegionID_;
            buffer.read(otherMaxRegionID);
            this->maxGlobalRegionID_ = std::max(this->maxGlobalRegionID_, otherMaxRegionID);
 
            this->iregFlow_.read(buffer);
            this->isReadFromStream_ = true;
        }
 
    private:
        std::vector<int> region_{};
 
        std::size_t maxLocalRegionID_{0};
 
        std::size_t maxGlobalRegionID_{0};
 
        data::InterRegFlowMap iregFlow_{};
 
        bool isReadFromStream_{false};
 
        InterRegFlowMapSingleFIP() = default;
    };
 
    class InterRegFlowMap
    {
    public:
        struct SingleRegion {
            std::string name;
 
            std::reference_wrapper<const std::vector<int>> definition;
        };
 
        using Cell = InterRegFlowMapSingleFIP::Cell;
 
        InterRegFlowMap() = default;
 
        static InterRegFlowMap
        createMapFromNames(std::vector<std::string> names);
 
        explicit InterRegFlowMap(const std::size_t                numCells,
                                 const std::vector<SingleRegion>& regions,
                                 const std::size_t                declaredMaxRegID = 0);
 
        InterRegFlowMap(const InterRegFlowMap& rhs) = default;
        InterRegFlowMap(InterRegFlowMap&& rhs) noexcept = default;
 
        InterRegFlowMap& operator=(const InterRegFlowMap& rhs) = default;
        InterRegFlowMap& operator=(InterRegFlowMap&& rhs) noexcept = default;
 
        void addConnection(const Cell& source,
                           const Cell& destination,
                           const data::InterRegFlowMap::FlowRates& rates);
 
        void compress();
 
        void clear();
 
        const std::vector<std::string>& names() const;
 
        std::vector<data::InterRegFlowMap> getInterRegFlows() const;
 
        std::vector<std::size_t> getLocalMaxRegionID() const;
 
        bool assignGlobalMaxRegionID(const std::vector<std::size_t>& regID);
 
        bool readIsConsistent() const;
 
        bool wantInterRegflowSummary() const
        {
            return !this->regionMaps_.empty();
        }
 
        template <class MessageBufferType>
        void write(MessageBufferType& buffer) const
        {
            buffer.write(this->names_.size());
            for (const auto& name : this->names_) {
                buffer.write(name);
            }
 
            for (const auto& map : this->regionMaps_) {
                map.write(buffer);
            }
        }
 
        template <class MessageBufferType>
        void read(MessageBufferType& buffer)
        {
            const auto names = this->readNames(buffer);
 
            if (names == this->names_) {
                // Input stream holds the maps in expected order (common
                // case).  Read the maps and merge with internal values.
                for (auto& map : this->regionMaps_) {
                    map.read(buffer);
                }
            }
            else {
                // Input stream does not hold the maps in expected order (or
                // different number of maps).  Unexpected.  Read the values
                // from the input stream, but do not merge with internal
                // values.
                auto map = InterRegFlowMapSingleFIP {
                    std::vector<int>(this->numCells_, 1)
                };
 
                const auto numMaps = names.size();
                for (auto n = 0*numMaps; n < numMaps; ++n) {
                    map.read(buffer);
                }
 
                this->readIsConsistent_ = false;
            }
        }
 
    private:
        std::vector<InterRegFlowMapSingleFIP> regionMaps_{};
 
        std::vector<std::string> names_;
 
        std::size_t numCells_{0};
 
        bool readIsConsistent_{true};
 
        template <class MessageBufferType>
        std::vector<std::string> readNames(MessageBufferType& buffer) const
        {
            auto numNames = 0 * this->names_.size();
            buffer.read(numNames);
 
            auto names = std::vector<std::string>(numNames);
            for (auto name = 0*numNames; name < numNames; ++name) {
                buffer.read(names[name]);
            }
 
            return names;
        }
    };
} // namespace Opm
 
#endif // OPM_INTERREG_FLOWS_MODULE_HPP