businessLogic.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_EXAMPLE_DATATASK_OPTIMISER_BUSINESSLOGIC_HPP
#define RTCTK_EXAMPLE_DATATASK_OPTIMISER_BUSINESSLOGIC_HPP
 
#include "computation.hpp"
#include "rtctk/componentFramework/oldbIf.hpp"
#include "rtctk/componentFramework/optimisable.hpp"
#include "rtctk/componentFramework/rtcComponent.hpp"
#include "rtctk/componentFramework/runtimeRepoIf.hpp"
 
namespace rtctk::exampleDataTask {
 
using namespace rtctk::componentFramework;
 
using LifeCycle = Optimisable<RtcComponent>;
 
class BusinessLogic : public LifeCycle::BizLogicIf {
public:
    using ComponentType = LifeCycle;
 
    BusinessLogic(const std::string& name, ServiceContainer& services)
        : m_rtr(services.Get<RuntimeRepoIf>())
        , m_oldb(services.Get<OldbIf>())
        , m_dp_slopes("/common/static/wfs_1/slopes")
        , m_dp_nacts("/common/static/dm_1/acts")
        , m_dp_im("/" + name + "/" + "dynamic/im")
        , m_dp_cm("/" + name + "/" + "dynamic/cm")
        , m_dp_stats_time("/" + name + "/" + "statistics/computation/time")
        , m_computation() {
        // create some data points
        m_oldb.CreateDataPoint<double>(m_dp_stats_time);
        m_oldb.SetDataPoint<double>(m_dp_stats_time, 0.0);
    }
 
    void ActivityInitialising(StopToken st) override {
        m_computation.SetStaticConfig(m_rtr.GetDataPoint<int32_t>(m_dp_slopes),
                                      m_rtr.GetDataPoint<int32_t>(m_dp_nacts));
 
        m_computation.SetDynamicConfig(m_rtr.GetDataPoint<MatrixBuffer<float>>(m_dp_im));
    }
 
    void ActivityUpdating(StopToken st, const JsonPayload& arg) override {
        m_computation.SetDynamicConfig(m_rtr.GetDataPoint<MatrixBuffer<float>>(m_dp_im));
    }
 
    void ActivityOptimising(StopToken st, const JsonPayload& arg) override {
        auto result = m_computation.Compute(ParseAlgorithm(arg));
 
        m_rtr.WriteDataPoint<MatrixBuffer<float>>(m_dp_cm, result.cm);
        m_oldb.SetDataPoint<double>(m_dp_stats_time, result.stats.elapsed.count());
    }
 
private:
    Computation::Algorithm ParseAlgorithm(const JsonPayload& arg) {
        const std::string alg_key = "algorithm";
 
        if (not arg.contains(alg_key)) {
            std::stringstream err_text;
            err_text << "No algorithm specified: ";
            for (auto& [key, value] : arg.items()) {
                err_text << " " << key << " : " << value;
            }
            CII_THROW(RtctkException, err_text.str());
        }
 
        std::string value = arg[alg_key];
 
        if (value == "SimpleInversion") {
            return Computation::Algorithm::SimpleInversion;
        } else if (value == "PythonInversion") {
            return Computation::Algorithm::PythonInversion;
        } else {
            std::stringstream err_text;
            err_text << "Invalid algorithm specified: ";
            for (auto& [key, value] : arg.items()) {
                err_text << " " << key << " : " << value;
            }
            CII_THROW(RtctkException, err_text.str());
        }
    }
 
    // used services
    RuntimeRepoIf& m_rtr;
    OldbIf& m_oldb;
 
    // datapoints
    DataPointPath m_dp_slopes;
    DataPointPath m_dp_nacts;
    DataPointPath m_dp_im;
    DataPointPath m_dp_cm;
    DataPointPath m_dp_stats_time;
 
    Computation m_computation;
};
 
}  // namespace rtctk::exampleDataTask
 
#endif  // RTCTK_EXAMPLE_DATATASK_OPTIMISER_BUSINESSLOGIC_HPP