CreateFixedTimeStepping.cpp

Go to the documentation of this file.

 
#include "CreateFixedTimeStepping.h"
 
#include <string>
 
#include "BaseLib/ConfigTree.h"
#include "BaseLib/Error.h"
#include "FixedTimeStepping.h"
#include "TimeStepAlgorithm.h"
 
namespace NumLib
{
class TimeStepAlgorithm;
std::unique_ptr<TimeStepAlgorithm> createFixedTimeStepping(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "FixedTimeStepping");
 
    auto const t_initial = config.getConfigParameter<double>("t_initial");
    auto const t_end = config.getConfigParameter<double>("t_end");
    auto const delta_ts = config.getConfigSubtree("timesteps");
 
    std::vector<double> timesteps;
    double t_curr = t_initial;
    double delta_t = 0.0;
 
    // TODO: consider adding call "listNonEmpty" to config tree
    auto const range = delta_ts.getConfigSubtreeList("pair");
    if (range.begin() == range.end())
    {
        OGS_FATAL("no timesteps have been given");
    }
    for (auto const pair : range)
    {
        auto const repeat = pair.getConfigParameter<std::size_t>("repeat");
        delta_t = pair.getConfigParameter<double>("delta_t");
 
        if (repeat == 0)
        {
            OGS_FATAL("<repeat> is zero.");
        }
        if (delta_t <= 0.0)
        {
            OGS_FATAL("timestep <delta_t> is <= 0.0.");
        }
 
        if (t_curr <= t_end)
        {
            auto const new_size = timesteps.size() + repeat;
            try
            {
                timesteps.resize(new_size, delta_t);
            }
            catch (std::length_error const& e)
            {
                OGS_FATAL(
                    "Resize of the time steps vector failed for the requested "
                    "new size {:d}. Probably there is not enough memory ({:g} "
                    "GiB requested).\n"
                    "Thrown exception: {:s}",
                    new_size,
                    new_size * sizeof(double) / 1024. / 1024. / 1024.,
                    e.what());
            }
            catch (std::bad_alloc const& e)
            {
                OGS_FATAL(
                    "Resize of the time steps vector failed for the requested "
                    "new size {:d}. Probably there is not enough memory ({:g} "
                    "GiB requested).\n"
                    "Thrown exception: {:s}",
                    new_size, new_size * sizeof(double) / 1024. / 1024. / 1024.,
                    e.what());
            }
 
            t_curr += repeat * delta_t;
        }
    }
 
    // append last delta_t until t_end is reached
    if (t_curr <= t_end)
    {
        auto const repeat =
            static_cast<std::size_t>(std::ceil((t_end - t_curr) / delta_t));
        auto const new_size = timesteps.size() + repeat;
        try
        {
            timesteps.resize(new_size, delta_t);
        }
        catch (std::length_error const& e)
        {
            OGS_FATAL(
                "Resize of the time steps vector failed for the requested new "
                "size {:d}. Probably there is not enough memory ({:g} GiB "
                "requested).\n"
                "Thrown exception: {:s}",
                new_size,
                new_size * sizeof(double) / 1024. / 1024. / 1024.,
                e.what());
        }
        catch (std::bad_alloc const& e)
        {
            OGS_FATAL(
                "Resize of the time steps vector failed for the requested new "
                "size {:d}. Probably there is not enough memory ({:g} GiB "
                "requested).\n"
                "Thrown exception: {:s}",
                new_size, new_size * sizeof(double) / 1024. / 1024. / 1024.,
                e.what());
        }
    }
 
    return std::make_unique<FixedTimeStepping>(t_initial, t_end, timesteps);
}
}  // end of namespace NumLib