EclipseIO.hpp

/*
  Copyright (c) 2013 Andreas Lauser
  Copyright (c) 2013 Uni Research AS
  Copyright (c) 2014 IRIS 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_ECLIPSE_WRITER_HPP
#define OPM_ECLIPSE_WRITER_HPP
 
#include <opm/input/eclipse/EclipseState/Grid/NNC.hpp>
 
#include <opm/output/data/Solution.hpp>
#include <opm/output/eclipse/RestartValue.hpp>
 
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace Opm {
 
class EclipseGrid;
class EclipseState;
class RestartKey;
class Schedule;
class SummaryConfig;
class SummaryState;
class UDQState;
class WellTestState;
 
} // namespace Opm
 
namespace Opm::Action {
    class State;
} // namespace Opm::Action
 
namespace Opm::out {
    class Summary;
} // namespace Opm::out
 
namespace Opm {

class EclipseIO
{
public:
    EclipseIO(const EclipseState&  es,
              EclipseGrid          grid,
              const Schedule&      schedule,
              const SummaryConfig& summary_config,
              const std::string&   basename = std::string{},
              const bool           writeEsmry = false);

    EclipseIO(const EclipseIO&) = delete;

    EclipseIO& operator=(const EclipseIO&) = delete;

    ~EclipseIO();

    void writeInitial(data::Solution simProps = data::Solution(),
                      std::map<std::string, std::vector<int>> int_data = {},
                      const std::vector<NNCdata>& nnc = {});
 

    void writeInitial(std::vector<data::Solution>,
                      std::map<std::string, std::vector<int>> int_data = {},
                      const std::vector<NNCdata>& nnc = {});
 
 
    void writeInitial(std::vector<data::Solution>,
                      std::map<std::string, std::vector<int>> int_data = {},
                      const NNCCollection& nnc_col = {});
 

    void writeTimeStep(const Action::State& action_state,
                       const WellTestState& wtest_state,
                       const SummaryState&  st,
                       const UDQState&      udq_state,
                       int                  report_step,
                       bool                 isSubstep,
                       double               seconds_elapsed,
                       RestartValue         value,
                       const bool           write_double = false,
                       std::optional<int>   time_step = std::nullopt,
                       const bool           isFinalWriteOut = false);

    void writeTimeStep(const Action::State&      action_state,
                       const WellTestState&      wtest_state,
                       const SummaryState&       st,
                       const UDQState&           udq_state,
                       int                       report_step,
                       bool                      isSubstep,
                       double                    seconds_elapsed,
                       std::vector<RestartValue> value,
                       const bool                write_double = false,
                       std::optional<int>        time_step = std::nullopt,
                       const bool                isFinalWriteOut = false);
 

    RestartValue loadRestart(Action::State&                 action_state,
                             SummaryState&                  summary_state,
                             const std::vector<RestartKey>& solution_keys,
                             const std::vector<RestartKey>& extra_keys = {}) const;

    data::Solution loadRestartSolution(const std::vector<RestartKey>& solution_keys,
                                       const int                      report_step) const;

    const out::Summary& summary() const;

    const SummaryConfig& finalSummaryConfig() const;
 
private:
    class Impl;

    std::unique_ptr<Impl> impl;
};
 
} // namespace Opm
 
#endif // OPM_ECLIPSE_WRITER_HPP