feat: initial forcings engine implementation

Author: program--

Diff for: include/forcing/ForcingEngineDataProvider.hpp

@@ -0,0 +1,52 @@
+#include "GenericDataProvider.hpp"
+#include <NGenConfig.h>
+
+#if NGEN_WITH_PYTHON
+#  include "bmi/Bmi_Py_Adapter.hpp"
+#else
+#  error ForcingEngineDataProvider requires Python support.
+#endif
+
+#include <memory>
+
+namespace data_access {
+
+struct ForcingEngineDataProvider
+  : public GenericDataProvider
+{
+    static_assert(
+        ngen::exec_info::with_python,
+        "ForcingEngineDataProvider requires Python support."
+    );
+
+    explicit ForcingEngineDataProvider(const std::string& init);
+
+    ~ForcingEngineDataProvider() override;
+
+    auto get_available_variable_names()
+      -> boost::span<const std::string> override;
+
+    auto get_data_start_time()
+      -> long override;
+
+    auto get_data_stop_time()
+      -> long override;
+
+    auto record_duration()
+      -> long override;
+
+    auto get_ts_index_for_time(const time_t& epoch_time)
+      -> size_t override;
+
+    auto get_value(const CatchmentAggrDataSelector& selector, ReSampleMethod m)
+      -> double override;
+
+    auto get_values(const CatchmentAggrDataSelector& selector, data_access::ReSampleMethod m)
+      -> std::vector<double> override;
+
+  private:
+    models::bmi::Bmi_Py_Adapter instance_;
+    std::vector<std::string> outputs_;
+};
+
+} // namespace data_access

Diff for: src/forcing/CMakeLists.txt

@@ -14,6 +14,7 @@ target_include_directories(forcing PUBLIC
         )
 
 target_link_libraries(forcing PUBLIC
+        NGen::config_header
         Boost::boost                # Headers-only Boost
         Threads::Threads
 )
@@ -22,4 +23,8 @@ if(NGEN_WITH_NETCDF)
     target_link_libraries(forcing PUBLIC NetCDF)
 endif()
 
+if(NGEN_WITH_PYTHON)
+    target_link_libraries(forcing PUBLIC pybind11::embed NGen::core)
+endif()
+
 #target_compile_options(forcing PUBLIC -std=c++14 -Wall)

Diff for: src/forcing/ForcingEngineDataProvider.cpp

@@ -0,0 +1,85 @@
+#include "ForcingEngineDataProvider.hpp"
+
+#include <boost/core/span.hpp>
+#include <boost/utility/string_view.hpp>
+
+namespace data_access {
+
+ForcingEngineDataProvider::ForcingEngineDataProvider(const std::string& init)
+  : instance_(
+      "ForcingEngine",
+      init,
+      "NextGen_Forcings_Engine.BMIForcingsEngine",
+      true,
+      true,
+      utils::getStdOut()
+    )
+  , outputs_(instance_.GetOutputVarNames())
+{};
+
+ForcingEngineDataProvider::~ForcingEngineDataProvider() = default;
+
+auto ForcingEngineDataProvider::get_available_variable_names()
+  -> boost::span<const std::string>
+{
+    return outputs_;
+}
+
+auto ForcingEngineDataProvider::get_data_start_time()
+  -> long
+{
+    // FIXME: Temporary, but most likely incorrect, cast
+    return static_cast<int64_t>(instance_.GetStartTime());
+}
+
+auto ForcingEngineDataProvider::get_data_stop_time()
+  -> long
+{
+    // FIXME: Temporary, but most likely incorrect, cast
+    return static_cast<int64_t>(instance_.GetEndTime());
+}
+
+auto ForcingEngineDataProvider::record_duration()
+  -> long
+{
+    // FIXME: Temporary, but most likely incorrect, cast
+    return static_cast<int64_t>(instance_.GetTimeStep());
+}
+
+auto ForcingEngineDataProvider::get_ts_index_for_time(const time_t& epoch_time)
+  -> size_t
+{
+    // TODO: implementation
+    throw std::runtime_error{"not implemented"};
+}
+
+auto ForcingEngineDataProvider::get_value(const CatchmentAggrDataSelector& selector, ReSampleMethod m)
+  -> double
+{
+    const std::string var_name  = selector.get_variable_name();
+    const std::string divide_id = selector.get_id();
+    const std::size_t count     = instance_.GetVarNbytes("CAT-ID") / instance_.GetVarItemsize("CAT-ID");
+    const auto divide_int_id    = std::atoi(divide_id.data() + divide_id.find('-'));
+    const auto ids              = boost::span<const int>{static_cast<int*>(instance_.GetValuePtr("CAT-ID")), count};
+    const auto* pos             = std::find(ids.cbegin(), ids.cend(), divide_int_id);
+
+    if (pos == std::end(ids)) {
+        throw std::runtime_error("Failed to get variable");
+    }
+
+    const auto result_index = static_cast<int>(std::distance(ids.cbegin(), pos));    
+    const auto values = boost::span<const double>{
+      static_cast<double*>(instance_.GetValuePtr(var_name)),
+      static_cast<std::size_t>(instance_.GetVarNbytes(var_name) / instance_.GetVarItemsize(var_name))
+    };
+
+    return values[result_index];
+}
+
+auto ForcingEngineDataProvider::get_values(const CatchmentAggrDataSelector& selector, data_access::ReSampleMethod m)
+  -> std::vector<double>
+{
+    return {0.0};
+}
+
+} // namespace data_access

Diff for: test/CMakeLists.txt

@@ -417,6 +417,18 @@ ngen_add_test(
 )
 #endif()
 
+ngen_add_test(
+    test_bmi_forcing
+    OBJECTS
+        forcing/ForcingEngineDataProvider_Test.cpp
+    LIBRARIES
+        NGen::core
+        NGen::forcing
+        NGen::ngen_bmi
+    REQUIRES
+        NGEN_WITH_PYTHON
+)
+
 ########################## Primary Combined Unit Test Target
 ngen_add_test(
     test_unit

Diff for: test/forcing/ForcingEngineDataProvider_Test.cpp

@@ -0,0 +1,30 @@
+#include <gtest/gtest.h>
+
+#include "ForcingEngineDataProvider.hpp"
+
+#include <boost/range/combine.hpp>
+
+TEST(ForcingEngineDataProviderTest, Initialization) {
+    auto interp_ = utils::ngenPy::InterpreterUtil::getInstance();
+
+    data_access::ForcingEngineDataProvider provider{
+        "extern/ngen-forcing/NextGen_Forcings_Engine_BMI/NextGen_Forcings_Engine/config.yml"
+    };
+
+    const auto outputs_test = provider.get_available_variable_names();
+    const auto outputs_expected = {
+        "CAT-ID",
+        "U2D_ELEMENT",
+        "V2D_ELEMENT",
+        "LWDOWN_ELEMENT",
+        "SWDOWN_ELEMENT",
+        "T2D_ELEMENT",
+        "Q2D_ELEMENT",
+        "PSFC_ELEMENT",
+        "RAINRATE_ELEMENT"
+    };
+    
+    for (decltype(auto) output : boost::combine(outputs_test, outputs_expected)) {
+        EXPECT_EQ(output.get<0>(), output.get<1>());
+    }
+}