CreateIterationNumberBasedTimeStepping.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#include "CreateIterationNumberBasedTimeStepping.h"
 
#include <string>
 
#include "BaseLib/Algorithm.h"
#include "BaseLib/ConfigTree.h"
#include "IterationNumberBasedTimeStepping.h"
#include "TimeStepAlgorithm.h"
 
namespace NumLib
{
 
IterationNumberBasedTimeSteppingParameters
parseIterationNumberBasedTimeStepping(BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "IterationNumberBasedTimeStepping");

    auto const t_initial = config.getConfigParameter<double>("t_initial");
    auto const t_end = config.getConfigParameter<double>("t_end");
    if (t_end < t_initial)
    {
        OGS_FATAL(
            "iteration number based timestepping: t_end({}) is smaller than "
            "t_initial({})",
            t_end,
            t_initial);
    }

    auto const initial_dt = config.getConfigParameter<double>("initial_dt");
    auto const minimum_dt = config.getConfigParameter<double>("minimum_dt");
    auto const maximum_dt = config.getConfigParameter<double>("maximum_dt");
 
    auto number_iterations =
        config.getConfigParameter<std::vector<int>>("number_iterations");
    auto multiplier =
        config.getConfigParameter<std::vector<double>>("multiplier");
 
    std::string const multiplier_interpolation_type_string =
        config.getConfigParameter<std::string>("multiplier_interpolation_type",
                                               "PiecewiseConstant");
    auto const multiplier_interpolation_type =
        (multiplier_interpolation_type_string == "PiecewiseLinear")
            ? MultiplyerInterpolationType::PiecewiseLinear
            : MultiplyerInterpolationType::PiecewiseConstant;
 
    return {t_initial,
            t_end,
            minimum_dt,
            maximum_dt,
            initial_dt,
            multiplier_interpolation_type,
            std::move(number_iterations),
            std::move(multiplier)};
}

std::unique_ptr<TimeStepAlgorithm> createIterationNumberBasedTimeStepping(
    IterationNumberBasedTimeSteppingParameters&& parameters,
    std::vector<double> const& fixed_times_for_output)
{
    if (parameters.t_end < parameters.t_initial)
    {
        OGS_FATAL(
            "iteration number based timestepping: end time ({}) is smaller "
            "than initial time ({})",
            parameters.t_end,
            parameters.t_initial);
    }
 
    return std::make_unique<IterationNumberBasedTimeStepping>(
        parameters.t_initial, parameters.t_end, parameters.minimum_dt,
        parameters.maximum_dt, parameters.initial_dt,
        parameters.multiplier_interpolation_type,
        std::move(parameters.number_iterations),
        std::move(parameters.multiplier), fixed_times_for_output);
}
 
}  // namespace NumLib