re-introduce model_reference_

Signed-off-by: Santiago Figueroa Manrique <[email protected]>

Author: figueroa1395

power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -21,18 +21,21 @@ template <class MainModel, class... ComponentType>
 class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
     : public JobDispatchInterface<JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>> {
   public:
-    JobDispatchAdapter(MainModel& model, std::reference_wrapper<MainModelOptions const> options)
-        : model_{std::make_unique<MainModel>(model)}, options_{options} {}
+    JobDispatchAdapter(std::reference_wrapper<MainModel> model_reference,
+                       std::reference_wrapper<MainModelOptions const> options)
+        : model_reference_{model_reference}, options_{options} {}
     JobDispatchAdapter(JobDispatchAdapter const& other)
-        : model_{std::make_unique<MainModel>(*other.model_)},
+        : 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_ = std::make_unique<MainModel>(*other.model_);
+            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_;
@@ -42,15 +45,17 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
         return *this;
     }
     JobDispatchAdapter(JobDispatchAdapter&& other) noexcept
-        : model_{std::move(other.model_)},
+        : model_copy_{std::move(other.model_copy_)},
+          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_ = std::move(other.model_);
+            model_copy_ = std::move(other.model_copy_);
+            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_);
@@ -59,15 +64,16 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
         }
         return *this;
     }
-    ~JobDispatchAdapter() { model_.reset(); }
+    ~JobDispatchAdapter() { model_copy_.reset(); }
 
   private:
     // Grant the CRTP base (JobDispatchInterface<JobDispatchAdapter>) access to
     // JobDispatchAdapter's private members. This allows the base class template
     // to call derived-class implementation details as part of the CRTP pattern.
     friend class JobDispatchInterface<JobDispatchAdapter>;
 
-    std::unique_ptr<MainModel> model_;
+    std::unique_ptr<MainModel> model_copy_;
+    std::reference_wrapper<MainModel> model_reference_;
     std::reference_wrapper<MainModelOptions const> options_;
 
     main_core::utils::ComponentFlags<ComponentType...> components_to_update_{};
@@ -80,18 +86,19 @@ class JobDispatchAdapter<MainModel, ComponentList<ComponentType...>>
     std::mutex calculation_info_mutex_;
 
     void calculate_impl(MutableDataset const& result_data, Idx scenario_idx) const {
-        MainModel::calculator(options_.get(), *model_, result_data.get_individual_scenario(scenario_idx), false);
+        MainModel::calculator(options_.get(), model_reference_.get(), result_data.get_individual_scenario(scenario_idx),
+                              false);
     }
 
     void cache_calculate_impl() const {
         // calculate once to cache topology, ignore results, all math solvers are initialized
         try {
-            MainModel::calculator(options_.get(), *model_,
+            MainModel::calculator(options_.get(), model_reference_.get(),
                                   {
                                       false,
                                       1,
                                       "sym_output",
-                                      model_->meta_data(),
+                                      model_reference_.get().meta_data(),
                                   },
                                   true);
         } catch (SparseMatrixError const&) { // NOLINT(bugprone-empty-catch) // NOSONAR
@@ -104,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_components_to_update(update_data);
-        update_independence_ =
-            main_core::update::independence::check_update_independence<ComponentType...>(model_->state(), 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_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_->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_->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_->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_->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_->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_->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/main_model.hpp

@@ -78,7 +78,7 @@ class MainModel {
     */
     BatchParameter calculate(Options const& options, MutableDataset const& result_data,
                              ConstDataset const& update_data) {
-        JobDispatchAdapter<Impl, AllComponents> adapter{impl(), std::ref(options)};
+        JobDispatchAdapter<Impl, AllComponents> adapter{std::ref(impl()), std::ref(options)};
         return JobDispatch::batch_calculation(adapter, result_data, update_data, options.threading);
     }