ScheduleBlock.hpp

/*
  Copyright 2021 Equinor 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 SCHEDULE_BLOCK_HPP
#define SCHEDULE_BLOCK_HPP

#include <opm/common/OpmLog/KeywordLocation.hpp>
#include <opm/common/utility/TimeService.hpp>

#include <opm/input/eclipse/Deck/DeckKeyword.hpp>

#include <cstddef>
#include <optional>
#include <vector>

namespace Opm {
    class UnitSystem;
}

namespace Opm {

class DeckOutput;

enum class ScheduleTimeType {
    START = 0,
    DATES = 1,
    TSTEP = 2,
    RESTART = 3,
};

/*
  The ScheduleBlock is collection of all the Schedule keywords from one
  report step.
*/

class ScheduleBlock
{
public:
    ScheduleBlock() = default;
    ScheduleBlock(const KeywordLocation& location,
                  ScheduleTimeType time_type,
                  const time_point& start_time);
    std::size_t size() const;
    void push_back(const DeckKeyword& keyword);
    std::optional<DeckKeyword> get(const std::string& kw) const;
    const time_point& start_time() const;
    const std::optional<time_point>& end_time() const;
    void end_time(const time_point& t);
    ScheduleTimeType time_type() const;
    const KeywordLocation& location() const;
    const DeckKeyword& operator[](const std::size_t index) const;
    std::vector<DeckKeyword>::const_iterator begin() const;
    std::vector<DeckKeyword>::const_iterator end() const;

    bool operator==(const ScheduleBlock& other) const;
    static ScheduleBlock serializationTestObject();

    void clearKeywords();

    template<class Serializer>
    void serializeOp(Serializer& serializer)
    {
        serializer(m_time_type);
        serializer(m_start_time);
        serializer(m_end_time);
        serializer(m_keywords);
        serializer(m_location);
    }

    void dump_deck(const UnitSystem& usys,
                   DeckOutput&       output,
                   time_point&       current_time) const;

private:
    ScheduleTimeType m_time_type{ScheduleTimeType::START};
    time_point m_start_time{};
    std::optional<time_point> m_end_time{};
    KeywordLocation m_location{};
    std::vector<DeckKeyword> m_keywords{};

    void dump_time(const UnitSystem& usys,
                   time_point        current_time,
                   DeckOutput&       output) const;

    void writeDates(DeckOutput& output) const;

    void writeTStep(const UnitSystem& usys,
                    time_point        current_time,
                    DeckOutput&       output) const;
};

} // end namespace Opm

#endif // SCHEDULE_BLOCK_HPP