step_size_controller_base.h

Go to the documentation of this file.

/*
 * Copyright 2021 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include "num_collect/base/exception.h"
#include "num_collect/base/precondition.h"
#include "num_collect/logging/log_tag_view.h"
#include "num_collect/logging/logging_macros.h"
#include "num_collect/logging/logging_mixin.h"
#include "num_collect/ode/concepts/formula.h"
#include "num_collect/ode/error_tolerances.h"
#include "num_collect/ode/step_size_limits.h"
 
namespace num_collect::ode {
 
template <typename Derived, concepts::formula Formula>
class step_size_controller_base : public logging::logging_mixin {
public:
    using formula_type = Formula;
 
    using problem_type = typename formula_type::problem_type;
 
    using variable_type = typename problem_type::variable_type;
 
    using scalar_type = typename problem_type::scalar_type;
 
    auto limits(const step_size_limits<scalar_type>& val) -> Derived& {
        limits_ = val;
        return derived();
    }
 
    [[nodiscard]] auto limits() const -> const step_size_limits<scalar_type>& {
        return limits_;
    }
 
    auto tolerances(const error_tolerances<variable_type>& val) -> Derived& {
        tolerances_ = val;
        return derived();
    }
 
    [[nodiscard]] auto tolerances() const
        -> const error_tolerances<variable_type>& {
        return tolerances_;
    }
 
    auto reduction_rate(const scalar_type& val) -> Derived& {
        NUM_COLLECT_PRECONDITION(val > static_cast<scalar_type>(0),
            "Rate to reduce step sizes when error is large must be a positive "
            "value.");
        reduction_rate_ = val;
        return derived();
    }
 
protected:
    explicit step_size_controller_base(logging::log_tag_view tag)
        : logging::logging_mixin(tag) {}
 
    [[nodiscard]] auto derived() noexcept -> Derived& {
        return *static_cast<Derived*>(this);
    }
 
    [[nodiscard]] auto derived() const noexcept -> const Derived& {
        return *static_cast<const Derived*>(this);
    }
 
    [[nodiscard]] auto reduce_if_needed(scalar_type& step_size,
        const variable_type& variable, const variable_type& error) -> bool {
        const bool tolerance_satisfied = tolerances().check(variable, error);
        if (!tolerance_satisfied) {
            if (step_size > limits_.lower_limit()) {
                NUM_COLLECT_LOG_TRACE(this->logger(),
                    "Error tolerance not satisfied with step size {}.",
                    step_size);
                step_size *= reduction_rate_;
                step_size = limits_.apply(step_size);
                return true;
            }
            NUM_COLLECT_LOG_WARNING(this->logger(),
                "Error tolerance not satisfied even with the lowest step size "
                "{} (error: {}).",
                step_size, tolerances().calc_norm(variable, error));
        }
        return false;
    }
 
private:
    step_size_limits<scalar_type> limits_{};
 
    error_tolerances<variable_type> tolerances_{};
 
    static constexpr auto default_reduction_rate =
        static_cast<scalar_type>(0.5);
 
    scalar_type reduction_rate_{default_reduction_rate};
};
 
}  // namespace num_collect::ode