Cleanup main model: dependency inversion main model impl info

power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp

@@ -4,13 +4,13 @@
 
 #pragma once
 
-#include "logging_impl.hpp"
+#include "multi_threaded_logging.hpp"
 
 #include <map>
 
 namespace power_grid_model {
 namespace common::logging {
-class CalculationInfo final : public Logger {
+class CalculationInfo : public Logger {
     using Data = std::map<LogEvent, double>;
 
   public:
@@ -86,7 +86,24 @@ class CalculationInfo final : public Logger {
     Report report() const { return data_; }
     void clear() { data_.clear(); }
 };
+
+inline Logger& merge_into(Logger& destination, CalculationInfo const& source) {
+    for (const auto& [tag, value] : source.report()) {
+        destination.log(tag, value);
+    }
+    return destination;
+}
+
+class MultiThreadedCalculationInfo : public MultiThreadedLoggerImpl<CalculationInfo> {
+  public:
+    using MultiThreadedLoggerImpl<CalculationInfo>::MultiThreadedLoggerImpl;
+    using Report = CalculationInfo::Report;
+
+    Report report() const { return get().report(); }
+    void clear() { get().clear(); }
+};
 } // namespace common::logging
 
 using common::logging::CalculationInfo;
+using common::logging::MultiThreadedCalculationInfo;
 } // namespace power_grid_model

power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp

@@ -6,6 +6,7 @@
 
 #include <cmath>
 #include <complex>
+#include <concepts>
 #include <cstddef>
 #include <cstdint>
 #include <limits>

power_grid_model_c/power_grid_model/include/power_grid_model/common/logging.hpp

@@ -60,6 +60,10 @@ class Logger {
     Logger& operator=(Logger const&) = default;
 };
 
+struct MultiThreadedLogger : public Logger {
+    virtual std::unique_ptr<Logger> create_child() = 0;
+};
+
 } // namespace common::logging
 
 using common::logging::LogEvent;

power_grid_model_c/power_grid_model/include/power_grid_model/common/logging_impl.hpp

@@ -26,4 +26,6 @@ class NoLogger : public Logger {
     }
 };
 
+inline Logger& merge_into(Logger& destination, NoLogger const& /*source*/) { return destination; }
+
 } // namespace power_grid_model::common::logging

power_grid_model_c/power_grid_model/include/power_grid_model/common/multi_threaded_logging.hpp

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <[email protected]>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "logging_impl.hpp"
+
+#include <mutex>
+
+namespace power_grid_model::common::logging {
+
+template <std::derived_from<Logger> LoggerType>
+    requires requires(LoggerType& destination, LoggerType const& source) {
+        { merge_into(destination, source) };
+    }
+class MultiThreadedLoggerImpl : public MultiThreadedLogger {
+    using SubThreadLogger = LoggerType;
+
+  public:
+    class ThreadLogger : public SubThreadLogger {
+      public:
+        ThreadLogger(MultiThreadedLoggerImpl& parent) : parent_{&parent} {}
+        ThreadLogger(ThreadLogger const&) = default;
+        ThreadLogger& operator=(ThreadLogger const&) = default;
+        ThreadLogger(ThreadLogger&&) noexcept = default;
+        ThreadLogger& operator=(ThreadLogger&&) noexcept = default;
+        ~ThreadLogger() override { sync(); }
+        void sync() const { parent_->sync(*this); }
+
+      private:
+        MultiThreadedLoggerImpl* parent_;
+    };
+
+    std::unique_ptr<Logger> create_child() override { return std::make_unique<ThreadLogger>(*this); }
+    LoggerType& get() { return log_; }
+    LoggerType const& get() const { return log_; }
+
+    void log(LogEvent tag) override { log_.log(tag); }
+    void log(LogEvent tag, std::string_view message) override { log_.log(tag, message); }
+    void log(LogEvent tag, double value) override { log_.log(tag, value); }
+    void log(LogEvent tag, Idx value) override { log_.log(tag, value); }
+
+  private:
+    friend class ThreadLogger;
+
+    LoggerType log_;
+    std::mutex mutex_;
+
+    void sync(ThreadLogger const& logger) {
+        std::lock_guard const lock{mutex_};
+        merge_into(log_, static_cast<SubThreadLogger const&>(logger));
+    }
+};
+
+using NoMultiThreadedLogger = MultiThreadedLoggerImpl<NoLogger>;
+
+} // namespace power_grid_model::common::logging

power_grid_model_c/power_grid_model/include/power_grid_model/component/asym_line.hpp

@@ -15,7 +15,6 @@
 #include "../common/matrix_utils.hpp"
 #include "../common/three_phase_tensor.hpp"
 
-#include <iostream>
 #include <numeric>
 
 namespace power_grid_model {

power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -10,7 +10,6 @@
 #include "job_interface.hpp"
 #include "main_model_fwd.hpp"
 
-#include "main_core/calculation_info.hpp"
 #include "main_core/update.hpp"
 
 namespace power_grid_model {
@@ -23,15 +22,19 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
   public:
     JobAdapter(std::reference_wrapper<MainModel> model_reference,
                std::reference_wrapper<MainModelOptions const> options)
-        : model_reference_{model_reference}, options_{options} {}
+        : model_reference_{model_reference}, options_{options} {
+        reset_logger_impl();
+    }
     JobAdapter(JobAdapter const& other)
         : 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_} {}
+          all_scenarios_sequence_{other.all_scenarios_sequence_} {
+        reset_logger_impl();
+    }
     JobAdapter& operator=(JobAdapter const& other) {
         if (this != &other) {
             model_copy_ = std::make_unique<MainModel>(other.model_reference_.get());
@@ -41,6 +44,8 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
             update_independence_ = other.update_independence_;
             independence_flags_ = other.independence_flags_;
             all_scenarios_sequence_ = other.all_scenarios_sequence_;
+
+            reset_logger_impl();
         }
         return *this;
     }
@@ -51,7 +56,9 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
           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_)} {}
+          all_scenarios_sequence_{std::move(other.all_scenarios_sequence_)} {
+        reset_logger_impl();
+    }
     JobAdapter& operator=(JobAdapter&& other) noexcept {
         if (this != &other) {
             model_copy_ = std::move(other.model_copy_);
@@ -61,10 +68,15 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
             update_independence_ = std::move(other.update_independence_);
             independence_flags_ = std::move(other.independence_flags_);
             all_scenarios_sequence_ = std::move(other.all_scenarios_sequence_);
+
+            reset_logger_impl();
         }
         return *this;
     }
-    ~JobAdapter() { model_copy_.reset(); }
+    ~JobAdapter() {
+        reset_logger_impl();
+        model_copy_.reset();
+    }
 
   private:
     // Grant the CRTP base (JobInterface<JobAdapter>) access to
@@ -83,7 +95,7 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
     // current_scenario_sequence_cache_ is calculated per scenario, so it is excluded from the constructors.
     main_core::utils::SequenceIdx<ComponentType...> current_scenario_sequence_cache_{};
 
-    std::mutex calculation_info_mutex_;
+    Logger* log_{nullptr};
 
     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),
@@ -135,14 +147,6 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
         std::ranges::for_each(current_scenario_sequence_cache_, [](auto& comp_seq_idx) { comp_seq_idx.clear(); });
     }
 
-    CalculationInfo get_calculation_info_impl() const { return model_reference_.get().calculation_info(); }
-    void reset_calculation_info_impl() { model_reference_.get().reset_calculation_info(); }
-
-    void thread_safe_add_calculation_info_impl(CalculationInfo const& info) {
-        std::lock_guard const lock{calculation_info_mutex_};
-        model_reference_.get().merge_calculation_info(info);
-    }
-
     auto get_current_scenario_sequence_view_() const {
         return main_core::utils::run_functor_with_all_types_return_array<ComponentType...>([this]<typename CT>() {
             constexpr auto comp_idx = main_core::utils::index_of_component<CT, ComponentType...>;
@@ -152,5 +156,14 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
             return std::span<Idx2D const>{std::get<comp_idx>(current_scenario_sequence_cache_)};
         });
     }
+
+    void reset_logger_impl() {
+        log_ = nullptr;
+        model_reference_.get().reset_logger();
+    }
+    void set_logger_impl(Logger& log) {
+        log_ = &log;
+        model_reference_.get().set_logger(*log_);
+    }
 };
 } // namespace power_grid_model