EclipseIO.hpp

Go to the documentation of this file.

/*
  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 <map>
#include <memory>
#include <string>
#include <vector>
 
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/NNC.hpp>
 
#include <opm/output/data/Cells.hpp>
#include <opm/output/data/Solution.hpp>
#include <opm/output/data/Wells.hpp>
#include <opm/output/eclipse/RestartValue.hpp>
 
namespace Opm { namespace out {
    class Summary;
}} // namespace Opm::out
 
namespace Opm {
 
class EclipseState;
class Schedule;
class SummaryConfig;
class SummaryState;
 
class EclipseIO {
public:
    EclipseIO( const EclipseState& es,
               EclipseGrid grid,
               const Schedule& schedule,
               const SummaryConfig& summary_config);
 
 
 
 
    void writeInitial( data::Solution simProps = data::Solution(), std::map<std::string, std::vector<int> > int_data = {}, const NNC& nnc = NNC());
 
    void overwriteInitialOIP( const data::Solution& simProps );
 
    void writeTimeStep( const SummaryState& st,
                        int report_step,
                        bool isSubstep,
                        double seconds_elapsed,
                        RestartValue value,
                        const bool write_double = false);
 
 
    /*
      Will load solution data and wellstate from the restart
      file. This method will consult the IOConfig object to get
      filename and report step to restart from.
 
      The map keys should be a map of keyword names and their
      corresponding dimension object, i.e. to load the state from a
      simple two phase simulation you would pass:
 
         keys = {{"PRESSURE" , UnitSystem::measure::pressure},
                 {"SWAT" , UnitSystem::measure::identity }}
 
      For a three phase black oil simulation you would add pairs for
      SGAS, RS and RV. If you ask for keys which are not found in the
      restart file an exception will be raised, the happens if the
      size of a vector is wrong.
 
      The function will consult the InitConfig object in the
      EclipseState object to determine which file and report step to
      load.
 
      The return value is of type 'data::Solution', which is the same
      container type which is used by the EclipseIO, but observe
      that the dim and target elements carry no information:
 
         - The returned double data has been converted to SI.
         . The target is unconditionally set to 'RESTART_SOLUTION'
 
      The extra_keys argument can be used to request additional
      kewyords from the restart value. The extra vectors will be
      stored in the 'extra' field of the RestartValue return
      value. These values must have been added to the restart file
      previosuly with the extra argument to the writeTimeStep()
      method. If the bool value in the map is true the value is
      required, and the output layer will throw an exception if it is
      missing, if the bool is false missing keywords will be ignored
      (there will *not* be an empty vector in the return value).
    */
    RestartValue loadRestart(SummaryState& summary_state, const std::vector<RestartKey>& solution_keys, const std::vector<RestartKey>& extra_keys = {}) const;
    const out::Summary& summary();
 
    EclipseIO( const EclipseIO& ) = delete;
    ~EclipseIO();
 
private:
    class Impl;
    std::unique_ptr< Impl > impl;
 
};
 
} // namespace Opm
 
 
#endif // OPM_ECLIPSE_WRITER_HPP