Merge pull request #1071 from PowerGridModel/feature/remove-calc-fn-from-job-dispatch

Clean-up main model: make job dispatch calculation agnostic

Author: figueroa1395

power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -21,18 +21,22 @@ template <class MainModel, class... ComponentType>
 class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
     : public JobDispatchInterface<JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>> {
   public:
-    JobDispatchAdapter(std::reference_wrapper<MainModel> model) : model_{std::move(model)} {}
+    JobDispatchAdapter(std::reference_wrapper<MainModel> model_reference,
+                       std::reference_wrapper<MainModelOptions const> options)
+        : model_reference_{model_reference}, options_{options} {}
     JobDispatchAdapter(JobDispatchAdapter const& other)
-        : model_copy_{std::make_unique<MainModel>(other.model_.get())},
-          model_{std::ref(*model_copy_)},
+        : model_copy_{std::make_unique<MainModel>(other.model_reference_.get())},
+          model_reference_{std::ref(*model_copy_)},
+          options_{std::ref(other.options_)},
           components_to_update_{other.components_to_update_},
           update_independence_{other.update_independence_},
           independence_flags_{other.independence_flags_},
           all_scenarios_sequence_{other.all_scenarios_sequence_} {}
     JobDispatchAdapter& operator=(JobDispatchAdapter const& other) {
         if (this != &other) {
-            model_copy_ = std::make_unique<MainModel>(other.model_.get());
-            model_ = std::ref(*model_copy_);
+            model_copy_ = std::make_unique<MainModel>(other.model_reference_.get());
+            model_reference_ = std::ref(*model_copy_);
+            options_ = std::ref(other.options_);
             components_to_update_ = other.components_to_update_;
             update_independence_ = other.update_independence_;
             independence_flags_ = other.independence_flags_;
@@ -42,15 +46,17 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
     }
     JobDispatchAdapter(JobDispatchAdapter&& other) noexcept
         : model_copy_{std::move(other.model_copy_)},
-          model_{model_copy_ ? std::ref(*model_copy_) : std::move(other.model_)},
+          model_reference_{model_copy_ ? std::ref(*model_copy_) : std::move(other.model_reference_)},
+          options_{other.options_},
           components_to_update_{std::move(other.components_to_update_)},
           update_independence_{std::move(other.update_independence_)},
           independence_flags_{std::move(other.independence_flags_)},
           all_scenarios_sequence_{std::move(other.all_scenarios_sequence_)} {}
     JobDispatchAdapter& operator=(JobDispatchAdapter&& other) noexcept {
         if (this != &other) {
             model_copy_ = std::move(other.model_copy_);
-            model_ = model_copy_ ? std::ref(*model_copy_) : std::move(other.model_);
+            model_reference_ = model_copy_ ? std::ref(*model_copy_) : std::move(other.model_reference_);
+            options_ = other.options_;
             components_to_update_ = std::move(other.components_to_update_);
             update_independence_ = std::move(other.update_independence_);
             independence_flags_ = std::move(other.independence_flags_);
@@ -66,10 +72,9 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
     // to call derived-class implementation details as part of the CRTP pattern.
     friend class JobDispatchInterface<JobDispatchAdapter>;
 
-    static constexpr Idx ignore_output{-1};
-
     std::unique_ptr<MainModel> model_copy_;
-    std::reference_wrapper<MainModel> model_;
+    std::reference_wrapper<MainModel> model_reference_;
+    std::reference_wrapper<MainModelOptions const> options_;
 
     main_core::utils::ComponentFlags<ComponentType...> components_to_update_{};
     main_core::update::independence::UpdateIndependence<ComponentType...> update_independence_{};
@@ -80,26 +85,22 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
 
     std::mutex calculation_info_mutex_;
 
-    // TODO(figueroa1395): Keep calculation_fn at the adapter level only
-    template <typename Calculate>
-        requires std::invocable<std::remove_cvref_t<Calculate>, MainModel&, MutableDataset const&, bool>
-    void calculate_impl(Calculate&& calculation_fn, MutableDataset const& result_data, Idx scenario_idx) const {
-        std::forward<Calculate>(calculation_fn)(model_.get(), result_data.get_individual_scenario(scenario_idx), false);
+    void calculate_impl(MutableDataset const& result_data, Idx scenario_idx) const {
+        MainModel::calculator(options_.get(), model_reference_.get(), result_data.get_individual_scenario(scenario_idx),
+                              false);
     }
 
-    template <typename Calculate>
-        requires std::invocable<std::remove_cvref_t<Calculate>, MainModel&, MutableDataset const&, Idx>
-    void cache_calculate_impl(Calculate&& calculation_fn) const {
+    void cache_calculate_impl() const {
         // calculate once to cache topology, ignore results, all math solvers are initialized
         try {
-            std::forward<Calculate>(calculation_fn)(model_.get(),
-                                                    {
-                                                        false,
-                                                        1,
-                                                        "sym_output",
-                                                        model_.get().meta_data(),
-                                                    },
-                                                    true);
+            MainModel::calculator(options_.get(), model_reference_.get(),
+                                  {
+                                      false,
+                                      1,
+                                      "sym_output",
+                                      model_reference_.get().meta_data(),
+                                  },
+                                  true);
         } catch (SparseMatrixError const&) { // NOLINT(bugprone-empty-catch) // NOSONAR
             // missing entries are provided in the update data
         } catch (NotObservableError const&) { // NOLINT(bugprone-empty-catch) // NOSONAR
@@ -110,33 +111,35 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
     void prepare_job_dispatch_impl(ConstDataset const& update_data) {
         // cache component update order where possible.
         // the order for a cacheable (independent) component by definition is the same across all scenarios
-        components_to_update_ = model_.get().get_components_to_update(update_data);
+        components_to_update_ = model_reference_.get().get_components_to_update(update_data);
         update_independence_ = main_core::update::independence::check_update_independence<ComponentType...>(
-            model_.get().state(), update_data);
+            model_reference_.get().state(), update_data);
         std::ranges::transform(update_independence_, independence_flags_.begin(),
                                [](auto const& comp) { return comp.is_independent(); });
         all_scenarios_sequence_ = std::make_shared<main_core::utils::SequenceIdx<ComponentType...>>(
             main_core::update::get_all_sequence_idx_map<ComponentType...>(
-                model_.get().state(), update_data, 0, components_to_update_, update_independence_, false));
+                model_reference_.get().state(), update_data, 0, components_to_update_, update_independence_, false));
     }
 
     void setup_impl(ConstDataset const& update_data, Idx scenario_idx) {
         current_scenario_sequence_cache_ = main_core::update::get_all_sequence_idx_map<ComponentType...>(
-            model_.get().state(), update_data, scenario_idx, components_to_update_, update_independence_, true);
+            model_reference_.get().state(), update_data, scenario_idx, components_to_update_, update_independence_,
+            true);
         auto const current_scenario_sequence = get_current_scenario_sequence_view_();
-        model_.get().template update_components<cached_update_t>(update_data, scenario_idx, current_scenario_sequence);
+        model_reference_.get().template update_components<cached_update_t>(update_data, scenario_idx,
+                                                                           current_scenario_sequence);
     }
 
     void winddown_impl() {
-        model_.get().restore_components(get_current_scenario_sequence_view_());
+        model_reference_.get().restore_components(get_current_scenario_sequence_view_());
         std::ranges::for_each(current_scenario_sequence_cache_, [](auto& comp_seq_idx) { comp_seq_idx.clear(); });
     }
 
-    CalculationInfo get_calculation_info_impl() const { return model_.get().calculation_info(); }
+    CalculationInfo get_calculation_info_impl() const { return model_reference_.get().calculation_info(); }
 
     void thread_safe_add_calculation_info_impl(CalculationInfo const& info) {
         std::lock_guard const lock{calculation_info_mutex_};
-        model_.get().merge_calculation_info(info);
+        model_reference_.get().merge_calculation_info(info);
     }
 
     auto get_current_scenario_sequence_view_() const {

power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp

@@ -8,26 +8,22 @@
 #include "job_interface.hpp"
 
 #include "main_core/calculation_info.hpp"
-#include "main_core/update.hpp"
 
 #include <thread>
 
 namespace power_grid_model {
 
 class JobDispatch {
   public:
-    static constexpr Idx ignore_output{-1};
     static constexpr Idx sequential{-1};
 
-    // TODO(figueroa1395): remove calculation_fn dependency
-    // TODO(figueroa1395): add concept to Adapter template parameter
     // TODO(figueroa1395): add generic template parameters for update_data and result_data
-    template <typename Adapter, typename Calculate>
-    static BatchParameter batch_calculation(Adapter& adapter, Calculate&& calculation_fn,
-                                            MutableDataset const& result_data, ConstDataset const& update_data,
-                                            Idx threading = sequential) {
+    template <typename Adapter, typename ResultDataset, typename UpdateDataset>
+        requires std::is_base_of_v<JobDispatchInterface<Adapter>, Adapter>
+    static BatchParameter batch_calculation(Adapter& adapter, ResultDataset const& result_data,
+                                            UpdateDataset const& update_data, Idx threading = sequential) {
         if (update_data.empty()) {
-            adapter.calculate(std::forward<Calculate>(calculation_fn), result_data);
+            adapter.calculate(result_data);
             return BatchParameter{};
         }
 
@@ -41,14 +37,13 @@ class JobDispatch {
         }
 
         // calculate once to cache, ignore results
-        adapter.cache_calculate(std::forward<Calculate>(calculation_fn)); // TODO(figueroa1395): Time this step
+        adapter.cache_calculate();
 
         // error messages
         std::vector<std::string> exceptions(n_scenarios, "");
 
         adapter.prepare_job_dispatch(update_data);
-        auto single_job =
-            single_thread_job(adapter, std::forward<Calculate>(calculation_fn), result_data, update_data, exceptions);
+        auto single_job = single_thread_job(adapter, result_data, update_data, exceptions);
 
         job_dispatch(single_job, n_scenarios, threading);
 
@@ -58,11 +53,10 @@ class JobDispatch {
     }
 
   private:
-    template <typename Adapter, typename Calculate>
-    static auto single_thread_job(Adapter& base_adapter, Calculate&& calculation_fn, MutableDataset const& result_data,
-                                  ConstDataset const& update_data, std::vector<std::string>& exceptions) {
-        return [&base_adapter, &exceptions, calculation_fn_ = std::forward<Calculate>(calculation_fn), &result_data,
-                &update_data](Idx start, Idx stride, Idx n_scenarios) {
+    template <typename Adapter, typename ResultDataset, typename UpdateDataset>
+    static auto single_thread_job(Adapter& base_adapter, ResultDataset const& result_data,
+                                  UpdateDataset const& update_data, std::vector<std::string>& exceptions) {
+        return [&base_adapter, &exceptions, &result_data, &update_data](Idx start, Idx stride, Idx n_scenarios) {
             assert(n_scenarios <= narrow_cast<Idx>(exceptions.size()));
 
             CalculationInfo thread_info;
@@ -92,8 +86,8 @@ class JobDispatch {
                 adapter = copy_adapter_functor();
             };
 
-            auto run = [&adapter, &calculation_fn_, &result_data, &thread_info](Idx scenario_idx) {
-                adapter.calculate(calculation_fn_, result_data, scenario_idx);
+            auto run = [&adapter, &result_data, &thread_info](Idx scenario_idx) {
+                adapter.calculate(result_data, scenario_idx);
                 main_core::merge_into(thread_info, adapter.get_calculation_info());
             };
 

power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -17,41 +17,63 @@
 namespace power_grid_model {
 template <typename Adapter> class JobDispatchInterface {
   public:
-    template <typename Calculate, typename ResultDataset>
-        requires requires(Adapter& adapter, Calculate&& calculation_fn, ResultDataset const& result_data,
-                          Idx scenario_idx) {
-            {
-                adapter.calculate_impl(std::forward<Calculate>(calculation_fn), result_data, scenario_idx)
-            } -> std::same_as<void>;
+    // the multiple  NOSONARs are used to avoid the complaints about the unnamed concepts
+    template <typename ResultDataset>
+    void calculate(ResultDataset const& result_data, Idx pos = 0)
+        requires requires(Adapter& adapter) { // NOSONAR
+            { adapter.calculate_impl(result_data, pos) } -> std::same_as<void>;
         }
-    void calculate(Calculate&& calculation_fn, ResultDataset const& result_data, Idx scenario_idx = 0) {
-        return static_cast<Adapter*>(this)->calculate_impl(std::forward<Calculate>(calculation_fn), result_data,
-                                                           scenario_idx);
+    {
+        return static_cast<Adapter*>(this)->calculate_impl(result_data, pos);
     }
 
-    template <typename Calculate>
-        requires requires(Adapter& adapter, Calculate&& calculation_fn) {
-            { adapter.cache_calculate_impl(std::forward<Calculate>(calculation_fn)) } -> std::same_as<void>;
+    void cache_calculate()
+        requires requires(Adapter& adapter) { // NOSONAR
+            { adapter.cache_calculate_impl() } -> std::same_as<void>;
         }
-    void cache_calculate(Calculate&& calculation_fn) {
-        return static_cast<Adapter*>(this)->cache_calculate_impl(std::forward<Calculate>(calculation_fn));
+    {
+        return static_cast<Adapter*>(this)->cache_calculate_impl();
     }
 
-    template <typename UpdateDataset> void prepare_job_dispatch(UpdateDataset const& update_data) {
+    template <typename UpdateDataset>
+    void prepare_job_dispatch(UpdateDataset const& update_data)
+        requires requires(Adapter& adapter) { // NOSONAR
+            { adapter.prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
+        }
+    {
         return static_cast<Adapter*>(this)->prepare_job_dispatch_impl(update_data);
     }
 
-    template <typename UpdateDataset> void setup(UpdateDataset const& update_data, Idx scenario_idx) {
+    template <typename UpdateDataset>
+    void setup(UpdateDataset const& update_data, Idx scenario_idx)
+        requires requires(Adapter& adapter) { // NOSONAR
+            { adapter.setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
+        }
+    {
         return static_cast<Adapter*>(this)->setup_impl(update_data, scenario_idx);
     }
 
-    void winddown() { return static_cast<Adapter*>(this)->winddown_impl(); }
+    void winddown()
+        requires requires(Adapter& adapter) { // NOSONAR
+            { adapter.winddown_impl() } -> std::same_as<void>;
+        }
+    {
+        return static_cast<Adapter*>(this)->winddown_impl();
+    }
 
-    CalculationInfo get_calculation_info() const {
+    CalculationInfo get_calculation_info() const
+        requires requires(Adapter& adapter) { // NOSONAR
+            { adapter.get_calculation_info_impl() } -> std::same_as<CalculationInfo>;
+        }
+    {
         return static_cast<const Adapter*>(this)->get_calculation_info_impl();
     }
 
-    void thread_safe_add_calculation_info(CalculationInfo const& info) {
+    void thread_safe_add_calculation_info(CalculationInfo const& info)
+        requires requires(Adapter& adapter) { // NOSONAR
+            { adapter.thread_safe_add_calculation_info_impl(info) } -> std::same_as<void>;
+        }
+    {
         static_cast<Adapter*>(this)->thread_safe_add_calculation_info_impl(info);
     }
 

power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp

@@ -69,7 +69,6 @@ class MainModel {
     Run the calculation function in batch on the provided update data.
 
     The calculation function should be able to run standalone.
-    It should output to the provided result_data if the trailing argument is not ignore_output.
 
     threading
         < 0 sequential
@@ -79,9 +78,8 @@ class MainModel {
     */
     BatchParameter calculate(Options const& options, MutableDataset const& result_data,
                              ConstDataset const& update_data) {
-        JobDispatchAdapter<Impl, AllComponents> adapter{std::ref(impl())};
-        return JobDispatch::batch_calculation(adapter, Impl::calculator(options), result_data, update_data,
-                                              options.threading);
+        JobDispatchAdapter<Impl, AllComponents> adapter{std::ref(impl()), std::ref(options)};
+        return JobDispatch::batch_calculation(adapter, result_data, update_data, options.threading);
     }
 
     CalculationInfo calculation_info() const { return impl().calculation_info(); }

power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp

@@ -544,14 +544,13 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
   public:
-    static auto calculator(Options const& options) {
-        return [options](MainModelImpl& model, MutableDataset const& target_data, bool cache_run) {
-            auto sub_opt = options; // copy
-            sub_opt.err_tol = cache_run ? std::numeric_limits<double>::max() : options.err_tol;
-            sub_opt.max_iter = cache_run ? 1 : options.max_iter;
+    static auto calculator(Options const& options, MainModelImpl& model, MutableDataset const& target_data,
+                           bool cache_run) {
+        auto sub_opt = options; // copy
+        sub_opt.err_tol = cache_run ? std::numeric_limits<double>::max() : options.err_tol;
+        sub_opt.max_iter = cache_run ? 1 : options.max_iter;
 
-            model.calculate(sub_opt, target_data);
-        };
+        model.calculate(sub_opt, target_data);
     }
 
     CalculationInfo calculation_info() const { return calculation_info_; }