SimulatorOutput.hpp

Go to the documentation of this file.

/*
  Copyright (c) 2013 Uni Research 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_SIMULATOR_OUTPUT_HPP
#define OPM_SIMULATOR_OUTPUT_HPP

// need complete def. of this since we use it in template
#include <opm/core/utility/Event.hpp>
#include <opm/core/utility/share_obj.hpp>

#include <memory>  // unique_ptr, shared_ptr
#include <vector>

struct UnstructuredGrid;

namespace Opm {

// forward definitions
class Deck;
class EclipseState;
class OutputWriter;
namespace parameter { class ParameterGroup; }
class SimulatorState;
class SimulatorTimer;
class TimeMap;
class WellState;
struct PhaseUsage;

class SimulatorOutputBase {
protected:
    SimulatorOutputBase (const parameter::ParameterGroup& p,
                         std::shared_ptr <const EclipseState> eclipseState,
                         const Opm::PhaseUsage &phaseUsage,
                         std::shared_ptr <const UnstructuredGrid> grid,
                         std::shared_ptr <const SimulatorTimer> timer,
                         std::shared_ptr <const SimulatorState> state,
                         std::shared_ptr <const WellState> wellState);

    virtual ~SimulatorOutputBase ();

    operator std::function <void ()> ();

    std::shared_ptr <const SimulatorTimer> timer_;
    std::shared_ptr <const TimeMap> timeMap_;
    std::shared_ptr <const SimulatorState> reservoirState_;
    std::shared_ptr <const WellState> wellState_;

    std::unique_ptr <OutputWriter> writer_;

    virtual void writeOutput ();

    virtual void sync ();

private:
    std::vector <double>::size_type next_;

    std::vector <double> times_;
};

template <typename Simulator>
struct SimulatorOutput : public SimulatorOutputBase {
    SimulatorOutput (const parameter::ParameterGroup& params,
                     std::shared_ptr <const EclipseState> eclipseState,
                     const Opm::PhaseUsage &phaseUsage,
                     std::shared_ptr <const UnstructuredGrid> grid,
                     std::shared_ptr <const SimulatorTimer> timer,
                     std::shared_ptr <const SimulatorState> state,
                     std::shared_ptr <const WellState> wellState,
                     std::shared_ptr <Simulator> sim)
        // send all other parameters to base class
        : SimulatorOutputBase (params, eclipseState, phaseUsage,
                               grid, timer, state, wellState)

        // store reference to simulator in derived class
        , sim_ (sim) {

        // connect simulation with output writer
        sim->timestep_completed ().add (*this);
    }

    SimulatorOutput (const parameter::ParameterGroup& params,
                     const EclipseState& eclipseState,
                     const Opm::PhaseUsage &phaseUsage,
                     const UnstructuredGrid& grid,
                     const SimulatorTimer& timer,
                     const SimulatorState& state,
                     const WellState& wellState,
                     Simulator& sim)
        // send all other parameters to base class
        : SimulatorOutputBase (params,
                               share_obj (eclipseState),
                               phaseUsage,
                               share_obj (grid),
                               share_obj (timer),
                               share_obj (state),
                               share_obj (wellState))

        // store reference to simulator in derived class
        , sim_ (share_obj (sim)) {

        // connect simulation with output writer
        sim_->timestep_completed ().add (*this);
    }
protected:
    // forward this request to the simulator
    virtual void sync () { sim_->sync (); }

private:
    std::shared_ptr <Simulator> sim_;
};

}

#endif /* OPM_SIMULATOR_OUTPUT_HPP */