temporal_hybrid_model.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Julia Bicker, René Schmieding
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* 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.
*/
 
#ifndef MIO_TEMPORAL_HYBRID_MODEL_H
#define MIO_TEMPORAL_HYBRID_MODEL_H
 
#include <algorithm>
#include <functional>
#include <type_traits>
 
#include "memilio/config.h"
 
namespace mio
{
namespace hybrid
{
 
template <class CurrentModel, class TargetModel>
void convert_model(const CurrentModel&, TargetModel&) = delete;
 
template <class Model1, class Model2, class ResultType1, class ResultType2>
class TemporalHybridSimulation
{
 
public:
    //Functions returning the result/current state of both models
    using result1_function = std::function<ResultType1(const Model1&, ScalarType t)>;
    using result2_function = std::function<ResultType2(const Model2&, ScalarType t)>;
 
    //Should return true when the simulation should be continued with the model that is not used currently i.e. a switch needs to be applied
    using switching_condition =
        std::function<bool(const ResultType1& state_model1, const ResultType2& state_model2, bool model1_used)>;
 
    TemporalHybridSimulation(Model1&& model1, Model2&& model2, const result1_function& result1,
                             const result2_function& result2, bool initially_use_model1, ScalarType t0 = 0,
                             ScalarType dt = 0.1)
        : m_model1(std::move(model1))
        , m_model2(std::move(model2))
        , m_result1(result1)
        , m_result2(result2)
        , m_using_model1(initially_use_model1)
        , m_t(t0)
        , m_dt(dt)
    {
    }
 
    void advance(ScalarType tmax, const switching_condition& switch_model)
    {
        while (m_t < tmax) {
            bool condition = switch_model(get_result_model1(), get_result_model2(), m_using_model1);
            if (m_using_model1 &&
                condition) { //currently model1 is used, but the condition to switch to model2 is fulfilled
                convert_model(m_model1, m_model2);
                m_using_model1 = false;
            }
            else if (
                !m_using_model1 &&
                condition) { //currently model2 is used, but the condition to switch is fulfilled i.e. we need to switch to model1
                convert_model(m_model2, m_model1);
                m_using_model1 = true;
            }
            //else{Switching condition is not fulfilled and currently used model is just advanced}
            ScalarType next_step = std::min(m_dt, tmax - m_t);
            if (m_using_model1) {
                m_model1.advance(m_t + next_step);
            }
            else {
                m_model2.advance(m_t + next_step);
            }
            m_t += next_step;
        }
    }
 
    ResultType1 get_result_model1() const
    {
        return m_result1(m_model1, m_t);
    }
 
    ResultType2 get_result_model2() const
    {
        return m_result2(m_model2, m_t);
    }
 
    const auto& get_model1() const
    {
        return m_model1;
    }
    auto& get_model1()
    {
        return m_model1;
    }
 
    const auto& get_model2() const
    {
        return m_model2;
    }
    auto& get_model2()
    {
        return m_model2;
    }
 
    const auto& using_model1() const
    {
        return m_using_model1;
    }
    auto& using_model1()
    {
        return m_using_model1;
    }
 
private:
    Model1 m_model1; 
    Model2 m_model2; 
    result1_function m_result1; 
    result2_function m_result2; 
    bool m_using_model1; 
    ScalarType m_t; 
    ScalarType m_dt; 
};
 
} //namespace hybrid
 
} //namespace mio
 
#endif //MIO_TEMPORAL_HYBRID_MODEL_H