OutputStream.hpp

/*
  Copyright (c) 2019 Equinor ASA
  Copyroght (c) 2026 OPM-OP 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_IO_OUTPUTSTREAM_HPP_INCLUDED
#define OPM_IO_OUTPUTSTREAM_HPP_INCLUDED

#include <opm/io/eclipse/PaddedOutputString.hpp>
#include <opm/common/utility/TimeService.hpp>

#include <array>
#include <chrono>
#include <ios>
#include <memory>
#include <string>
#include <vector>

namespace Opm { namespace EclIO {

    class EclOutput;

}} // namespace Opm::EclIO

namespace Opm { namespace EclIO { namespace OutputStream {

    struct Formatted { bool set; };
    struct Unified   { bool set; };

    struct ResultSet
    {
        std::string outputDir;

        std::string baseName;
    };

    class Init
    {
    public:
        explicit Init(const ResultSet& rset,
                      const Formatted& fmt);

        ~Init();

        Init(const Init& rhs) = delete;
        Init(Init&& rhs);

        Init& operator=(const Init& rhs) = delete;
        Init& operator=(Init&& rhs);

        void write(const std::string&      kw,
                   const std::vector<int>& data);

        void write(const std::string&       kw,
                   const std::vector<bool>& data);

        void write(const std::string&        kw,
                   const std::vector<float>& data);

        void write(const std::string&         kw,
                   const std::vector<double>& data);

        void write(const std::string&                        kw,
                   const std::vector<PaddedOutputString<8>>& data);


        void message(const std::string& msg);

    private:
        std::unique_ptr<EclOutput> stream_;

        void open(const std::string& fname,
                  const bool         formatted);

        EclOutput& stream();

        template <typename T>
        void writeImpl(const std::string&    kw,
                       const std::vector<T>& data);
    };

    class Restart
    {
    public:
        explicit Restart(const ResultSet& rset,
                         const int        seqnum,
                         const Formatted& fmt,
                         const Unified&   unif);

        ~Restart();

        Restart(const Restart& rhs) = delete;
        Restart(Restart&& rhs);

        Restart& operator=(const Restart& rhs) = delete;
        Restart& operator=(Restart&& rhs);

        void message(const std::string& msg);

        void write(const std::string&      kw,
                   const std::vector<int>& data);

        void write(const std::string&       kw,
                   const std::vector<bool>& data);

        void write(const std::string&        kw,
                   const std::vector<float>& data);

        void write(const std::string&         kw,
                   const std::vector<double>& data);

        void write(const std::string&              kw,
                   const std::vector<std::string>& data);

        void write(const std::string&                        kw,
                   const std::vector<PaddedOutputString<8>>& data);

    private:
        std::unique_ptr<EclOutput> stream_;

        void openUnified(const std::string& fname,
                         const bool         formatted,
                         const int          seqnum);

        void openNew(const std::string& fname,
                     const bool         formatted);

        void openExisting(const std::string&   fname,
                          const bool           formatted,
                          const std::streampos writePos);

        EclOutput& stream();

        template <typename T>
        void writeImpl(const std::string&    kw,
                       const std::vector<T>& data);
    };

    class RFT
    {
    public:
        struct OpenExisting { bool set; };

        explicit RFT(const ResultSet&    rset,
                     const Formatted&    fmt,
                     const OpenExisting& existing);

        ~RFT();

        RFT(const RFT& rhs) = delete;
        RFT(RFT&& rhs);

        RFT& operator=(const RFT& rhs) = delete;
        RFT& operator=(RFT&& rhs);

        void write(const std::string&      kw,
                   const std::vector<int>& data);

        void write(const std::string&        kw,
                   const std::vector<float>& data);

        void write(const std::string&                        kw,
                   const std::vector<PaddedOutputString<8>>& data);

    private:
        std::unique_ptr<EclOutput> stream_;

        void open(const std::string& fname,
                  const bool         formatted,
                  const bool         existing);

        EclOutput& stream();

        template <typename T>
        void writeImpl(const std::string&    kw,
                       const std::vector<T>& data);
    };

    class SummarySpecification
    {
    public:
        using StartTime = time_point;

        enum class UnitConvention
        {
            Metric = 1,
            Field  = 2,
            Lab    = 3,
            Pvt_M  = 4,
        };

        struct RestartSpecification
        {
            std::string root;
            int step;
        };

        class Parameters
        {
        public:
            void add(const std::string& keyword,
                     const std::string& wgname,
                     const int          num,
                     const std::string& unit);

            friend class SummarySpecification;

        private:
            std::vector<PaddedOutputString<8>> keywords{};
            std::vector<PaddedOutputString<8>> wgnames{};
            std::vector<int>                   nums{};
            std::vector<PaddedOutputString<8>> units{};
        };

        explicit SummarySpecification(const ResultSet&            rset,
                                      const Formatted&            fmt,
                                      const UnitConvention        uconv,
                                      const std::array<int,3>&    cartDims,
                                      const RestartSpecification& restart,
                                      const StartTime             start,
                                      const StartTime             computeStart);

        ~SummarySpecification();

        SummarySpecification(const SummarySpecification& rhs) = delete;
        SummarySpecification(SummarySpecification&& rhs);

        SummarySpecification& operator=(const SummarySpecification& rhs) = delete;
        SummarySpecification& operator=(SummarySpecification&& rhs);

        void write(const Parameters& params, const bool simulationFinished,
                   const int currentStep, const int basic);

    private:
        int unit_;
        int restartStep_;
        std::array<int,3> cartDims_;
        StartTime startDate_;
        StartTime computeStart_;
        std::vector<PaddedOutputString<8>> restart_;

        std::unique_ptr<EclOutput> stream_;

        void rewindStream();
        void flushStream();

        EclOutput& stream();
    };

    std::unique_ptr<EclOutput>
    createSummaryFile(const ResultSet& rset,
                      const int        seqnum,
                      const Formatted& fmt,
                      const Unified&   unif);

    std::string outputFileName(const ResultSet&   rsetDescriptor,
                               const std::string& ext);

}}} // namespace Opm::EclIO::OutputStream

#endif //  OPM_IO_OUTPUTSTREAM_HPP_INCLUDED