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