EclOutput.hpp

/*
   Copyright 2019 Statoil 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_IO_ECLOUTPUT_HPP
#define OPM_IO_ECLOUTPUT_HPP

#include <opm/io/eclipse/EclIOdata.hpp>
#include <opm/io/eclipse/PaddedOutputString.hpp>

#include <cstdint>
#include <fstream>
#include <ios>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>

namespace Opm::EclIO::OutputStream {
    class Restart;
    class SummarySpecification;
} // namespace Opm::EclIO::OutputStream

namespace Opm::EclIO {

class EclOutput
{
public:
    EclOutput(const std::string&            filename,
              const bool                    formatted,
              const std::ios_base::openmode mode = std::ios::out);

    template<typename T>
    void write(const std::string& name,
               const std::vector<T>& data)
    {
        static_assert(std::is_same_v<T, int>    ||
                      std::is_same_v<T, float>  ||
                      std::is_same_v<T, double> ||
                      std::is_same_v<T, bool>   ||
                      std::is_same_v<T, char>,
                      "EclOutput::write<T>: T must be int, float, double, bool, or char");

        eclArrType arrType = MESS;
        int element_size = 4;

        if constexpr (std::is_same_v<T, int>) {
            arrType = INTE;
        }
        else if constexpr (std::is_same_v<T, float>) {
            arrType = REAL;
        }
        else if constexpr (std::is_same_v<T, double>) {
            arrType = DOUB;
            element_size = 8;
        }
        else if constexpr (std::is_same_v<T, bool>) {
            arrType = LOGI;
        }
        else if constexpr (std::is_same_v<T, char>) {
            if (!data.empty()) {
                throw std::invalid_argument {
                    "EclOutput::write<char>: non-empty data is not supported; "
                    "use message() for MESS-type records"
                };
            }
        }

        if (isFormatted) {
            writeFormattedHeader(name, data.size(), arrType, element_size);
            if (arrType != MESS) {
                writeFormattedArray(data);
            }
        }
        else {
            writeBinaryHeader(name, data.size(), arrType, element_size);
            if (arrType != MESS) {
                writeBinaryArray(data);
            }
        }
    }

    // when this function is used array type will be assumed C0NN (not CHAR).
    // Also in cases where element size is 8 or less, element size will be 8.

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

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

    void set_ix() { ix_standard = true; }

    friend class OutputStream::Restart;
    friend class OutputStream::SummarySpecification;

private:
    void writeStringVector(const std::string&              name,
                           const std::vector<std::string>& strings,
                           const eclArrType                charType,
                           const int                       charPerStr);

    void writeBinaryHeader(const std::string& arrName, std::int64_t size, eclArrType arrType, int element_size);

    template <typename T>
    void writeBinaryArray(const std::vector<T>& data);

    void writeBinaryCharArray(const std::vector<std::string>& data, int element_size);
    void writeBinaryCharArray(const std::vector<PaddedOutputString<8>>& data);

    void writeFormattedHeader(const std::string& arrName, int size, eclArrType arrType, int element_size);

    template <typename T>
    void writeFormattedArray(const std::vector<T>& data);

    void writeFormattedCharArray(const std::vector<std::string>& data, int element_size);
    void writeFormattedCharArray(const std::vector<PaddedOutputString<8>>& data);

    void writeArrayType(const eclArrType arrType);
    std::string make_real_string_ecl(float value) const;
    std::string make_real_string_ix(float value) const;
    std::string make_doub_string_ecl(double value) const;
    std::string make_doub_string_ix(double value) const;

    bool isFormatted, ix_standard;
    std::ofstream ofileH;
};

template<>
void EclOutput::write<std::string>(const std::string& name,
                                   const std::vector<std::string>& data);

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

} // namespace Opm::EclIO

#endif // OPM_IO_ECLOUTPUT_HPP