AdaptiveTimeStepping.hpp

Go to the documentation of this file.

/*
  Copyright 2014 IRIS AS
  Copyright 2015 Dr. Blatt - HPC-Simulation-Software & Services
  Copyright 2015 Statoil 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_SUBSTEPPING_HEADER_INCLUDED
#define OPM_SUBSTEPPING_HEADER_INCLUDED

#include <iostream>
#include <utility>

#include <opm/core/utility/parameters/ParameterGroup.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/core/simulator/SimulatorTimer.hpp>
#include <opm/core/simulator/TimeStepControlInterface.hpp>

namespace Opm {


    // AdaptiveTimeStepping
    //---------------------

    class AdaptiveTimeStepping
    {
    public:
        AdaptiveTimeStepping( const parameter::ParameterGroup& param,
                              const boost::any& pinfo=boost::any(),
                              const bool terminal_output = true );

        template <class Solver, class State, class WellState>
        void step( const SimulatorTimer& timer,
                   Solver& solver, State& state, WellState& well_state );

        template <class Solver, class State, class WellState>
        void step( const SimulatorTimer& timer,
                   Solver& solver, State& state, WellState& well_state,
                   OutputWriter& outputWriter );

    protected:
        template <class Solver, class State, class WellState>
        void stepImpl( const SimulatorTimer& timer,
                       Solver& solver, State& state, WellState& well_state,
                       OutputWriter* outputWriter);

        typedef std::unique_ptr< TimeStepControlInterface > TimeStepControlType;

        TimeStepControlType timeStepControl_; 
        const double restart_factor_;         
        const double growth_factor_;          
        const double max_growth_;             
        const double max_time_step_;          
        const int solver_restart_max_;        
        const bool solver_verbose_;           
        const bool timestep_verbose_;         
        double suggested_next_timestep_;      
        bool full_timestep_initially_;        
    };
}

#include <opm/core/simulator/AdaptiveTimeStepping_impl.hpp>
#endif