diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/deserializer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/deserializer.hpp
index 5e7025837..1d3332cd1 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/deserializer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/deserializer.hpp
@@ -44,7 +44,7 @@ using nlohmann::json;
 // visitor for json conversion
 struct JsonMapArrayData {
     size_t size{};
-    msgpack::sbuffer buffer{};
+    msgpack::sbuffer buffer;
 };
 
 struct JsonSAXVisitor {
@@ -130,8 +130,8 @@ struct JsonSAXVisitor {
         throw SerializationError{ss.str()};
     }
 
-    std::stack<JsonMapArrayData> data_buffers{};
-    msgpack::sbuffer root_buffer{};
+    std::stack<JsonMapArrayData> data_buffers;
+    msgpack::sbuffer root_buffer;
 };
 
 // visitors for parsing
@@ -192,8 +192,15 @@ struct MapArrayVisitor : DefaultErrorVisitor<MapArrayVisitor<map_array>> {
         std::same_as<map_array, visit_map_t> || std::same_as<map_array, visit_map_array_t>;
     static constexpr bool enable_array =
         std::same_as<map_array, visit_array_t> || std::same_as<map_array, visit_map_array_t>;
-    static constexpr std::string_view static_err_msg =
-        enable_map ? (enable_array ? "Map or an array expected." : "Map expected.") : "Array expected.";
+    static constexpr std::string_view static_err_msg = [] {
+        if constexpr (enable_map && enable_array) {
+            return "Map or an array expected.";
+        } else if constexpr (enable_map) {
+            return "Map expected.";
+        } else {
+            return "Array expected.";
+        }
+    }();
 
     Idx size{};
     bool is_map{};
@@ -228,7 +235,7 @@ struct MapArrayVisitor : DefaultErrorVisitor<MapArrayVisitor<map_array>> {
 struct StringVisitor : DefaultErrorVisitor<StringVisitor> {
     static constexpr std::string_view static_err_msg = "String expected.";
 
-    std::string_view str{};
+    std::string_view str;
     bool visit_str(const char* v, uint32_t size) {
         str = {v, size};
         return true;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/serializer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/serializer.hpp
index 35f1b3717..b6e09b645 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/serializer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/serialization/serializer.hpp
@@ -76,10 +76,10 @@ struct MapArray {
 struct JsonConverter : msgpack::null_visitor {
     static constexpr char sep_char = ' ';
 
-    Idx indent;
-    Idx max_indent_level;
-    std::stringstream ss{};
-    std::stack<MapArray> map_array{};
+    Idx indent{};
+    Idx max_indent_level{};
+    std::stringstream ss{};           // NOLINT(readability-redundant-member-init)
+    std::stack<MapArray> map_array{}; // NOLINT(readability-redundant-member-init)
 
     void print_indent() {
         if (indent < 0) {
@@ -293,7 +293,7 @@ class Serializer {
     std::vector<ComponentBuffer> component_buffers_; // list of components, then all scenario flatten
 
     // msgpack pakcer
-    msgpack::sbuffer msgpack_buffer_{};
+    msgpack::sbuffer msgpack_buffer_;
     msgpack::packer<msgpack::sbuffer> packer_;
     bool use_compact_list_{};
     std::map<MetaComponent const*, std::vector<MetaAttribute const*>> attributes_;
@@ -606,7 +606,7 @@ class Serializer {
         });
     }
     void pack_attribute(AttributeBuffer<void const> const& attribute_buffer, Idx idx) {
-        return ctype_func_selector(attribute_buffer.meta_attribute->ctype, [&]<class T> {
+        ctype_func_selector(attribute_buffer.meta_attribute->ctype, [this, &attribute_buffer, idx]<class T> {
             packer_.pack(*(reinterpret_cast<T const*>(attribute_buffer.data) + idx));
         });
     }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp
index 8e70e3f11..e28278b65 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/calculation_parameters.hpp
@@ -53,7 +53,7 @@ template <symmetry_tag sym_type> struct BranchShortCircuitSolverOutput {
 
 // fault math calculation parameters and math output
 struct FaultCalcParam {
-    DoubleComplex y_fault{};
+    DoubleComplex y_fault;
     FaultType fault_type{};
     FaultPhase fault_phase{};
 };
@@ -136,7 +136,7 @@ static_assert(sensor_calc_param_type<PowerSensorCalcParam<asymmetric_t>>);
 struct TransformerTapRegulatorCalcParam {
     double u_set{};
     double u_band{};
-    DoubleComplex z_compensation{};
+    DoubleComplex z_compensation;
     IntS status{};
 };
 
@@ -203,7 +203,7 @@ struct SourceCalcParam {
     DoubleComplex y1;
     DoubleComplex y0;
 
-    template <symmetry_tag sym> inline ComplexTensor<sym> y_ref() const {
+    template <symmetry_tag sym> ComplexTensor<sym> y_ref() const {
         if constexpr (is_symmetric_v<sym>) {
             return y1;
         } else {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp
index 740d40531..312ccfd79 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp
@@ -93,7 +93,10 @@ concept is_in_list_c = (std::same_as<std::remove_const_t<T>, Ts> || ...);
 
 // functor to include all
 struct IncludeAll {
-    template <class... T> constexpr bool operator()(T&&... /*ignored*/) const { return true; }
+    template <class... T> constexpr bool operator()(T&&... ignored) const {
+        ((void)std::forward<T>(ignored), ...);
+        return true;
+    }
 };
 constexpr IncludeAll include_all{};
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp
index 9d57af445..b47103833 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp
@@ -161,7 +161,7 @@ class DenseGroupedIdxVector {
 
         IdxVector const* dense_vector_{};
         Idx group_{};
-        std::pair<group_iterator, group_iterator> group_range_{};
+        std::pair<group_iterator, group_iterator> group_range_;
 
         friend class boost::iterator_core_access;
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_like_concepts.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_like_concepts.hpp
index 8732f9390..dda68255d 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_like_concepts.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_like_concepts.hpp
@@ -16,14 +16,14 @@ concept iterator_like = requires(T const t) {
 
 template <typename T, typename ElementType>
 concept forward_iterator_like = std::regular<T> && iterator_like<T, ElementType> && requires(T t) {
-    { t++ } -> std::same_as<T>;
-    { ++t } -> std::same_as<T&>;
+    { t++ } -> std::same_as<T>;  // NOLINT(bugprone-inc-dec-in-conditions)
+    { ++t } -> std::same_as<T&>; // NOLINT(bugprone-inc-dec-in-conditions)
 };
 
 template <typename T, typename ElementType>
 concept bidirectional_iterator_like = forward_iterator_like<T, ElementType> && requires(T t) {
-    { t-- } -> std::same_as<T>;
-    { --t } -> std::same_as<T&>;
+    { t-- } -> std::same_as<T>;  // NOLINT(bugprone-inc-dec-in-conditions)
+    { --t } -> std::same_as<T&>; // NOLINT(bugprone-inc-dec-in-conditions)
 };
 
 template <typename T, typename ElementType>
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp
index afd72324e..e4d09e660 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/common/three_phase_tensor.hpp
@@ -281,7 +281,7 @@ inline void add_diag(Eigen::ArrayBase<DerivedA>& x, Eigen::ArrayBase<DerivedB> c
 }
 template <rk2_tensor DerivedA, column_vector DerivedB>
 inline void add_diag(Eigen::ArrayBase<DerivedA>&& x, Eigen::ArrayBase<DerivedB> const& y) {
-    x.matrix().diagonal() += y.matrix();
+    std::move(x).matrix().diagonal() += y.matrix();
 }
 
 // zero tensor
@@ -351,13 +351,14 @@ template <symmetry_tag sym, class Proxy>
 inline void update_real_value(RealValue<sym> const& new_value, Proxy&& current_value, double scalar) {
     if constexpr (is_symmetric_v<sym>) {
         if (!is_nan(new_value)) {
-            current_value = scalar * new_value;
+            std::forward<Proxy>(current_value) = scalar * new_value;
         }
     } else {
         for (size_t i = 0; i != 3; ++i) {
             if (!is_nan(new_value(i))) {
-                current_value(i) = scalar * new_value(i);
+                current_value(i) = scalar * new_value(i); // can't forward due to runtime element access
             }
+            (void)std::forward<Proxy>(current_value);
         }
     }
 }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp
index b55600a5a..88380e7df 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/fault.hpp
@@ -193,7 +193,7 @@ class Fault final : public Base {
     double r_f_;
     double x_f_;
 
-    void check_sanity() {
+    void check_sanity() const {
         using enum FaultPhase;
 
         auto const check_supported = [&](auto const& iterable) {
@@ -203,15 +203,19 @@ class Fault final : public Base {
         };
         switch (fault_type_) {
         case FaultType::three_phase:
-            return check_supported(std::array{FaultPhase::nan, default_value, abc});
+            check_supported(std::array{FaultPhase::nan, default_value, abc});
+            return;
         case FaultType::single_phase_to_ground:
-            return check_supported(std::array{FaultPhase::nan, default_value, a, b, c});
+            check_supported(std::array{FaultPhase::nan, default_value, a, b, c});
+            return;
         case FaultType::two_phase:
             [[fallthrough]];
         case FaultType::two_phase_to_ground:
-            return check_supported(std::array{FaultPhase::nan, default_value, ab, ac, bc});
+            check_supported(std::array{FaultPhase::nan, default_value, ab, ac, bc});
+            return;
         case FaultType::nan:
-            return check_supported(std::array{FaultPhase::nan, default_value, abc, a, b, c, ab, ac, bc});
+            check_supported(std::array{FaultPhase::nan, default_value, abc, a, b, c, ab, ac, bc});
+            return;
         default:
             throw InvalidShortCircuitType(fault_type_);
         }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp
index ed0e54200..5fb0a3d78 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/source.hpp
@@ -110,8 +110,8 @@ class Source : public Appliance {
     double u_ref_;
     double u_ref_angle_;
     // positive and zero sequence ref
-    DoubleComplex y1_ref_{};
-    DoubleComplex y0_ref_{};
+    DoubleComplex y1_ref_;
+    DoubleComplex y0_ref_;
 
     template <symmetry_tag sym_calc> ApplianceSolverOutput<sym_calc> u2si(ComplexValue<sym_calc> const& u) const {
         ApplianceSolverOutput<sym_calc> appliance_solver_output;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/component/transformer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/component/transformer.hpp
index 10a50fdf0..42d236b81 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/component/transformer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/component/transformer.hpp
@@ -193,7 +193,7 @@ class Transformer : public Branch {
         y_series = (1.0 / z_series) / base_y_to;
         // shunt
         DoubleComplex y_shunt;
-        // Y = I0_2 / (U2/sqrt(3)) = i0 * (S / sqrt(3) / U2) / (U2/sqrt(3)) = i0 * S * / U2 / U2
+        // Y = I0_2 / (U2/sqrt3) = i0 * (S / sqrt3 / U2) / (U2/sqrt3) = i0 * S * / U2 / U2
         double const y_shunt_abs = i0_ * sn_ / u2 / u2;
         // G = P0 / (U2^2)
         y_shunt.real(p0_ / u2 / u2);
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
index 1f76b8eb5..51009acc8 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/output.hpp
@@ -87,7 +87,7 @@ template <typename Component, typename IndexType, class ComponentContainer, type
                                  decltype(*comp_base_sequence_cbegin<Component>(MainModelState<ComponentContainer>{}))>
 constexpr ResIt produce_output(MainModelState<ComponentContainer> const& state, ResIt res_it, ResFunc&& func) {
     return std::transform(get_component_citer<Component>(state).begin(), get_component_citer<Component>(state).end(),
-                          comp_base_sequence_cbegin<Component>(state), res_it, func);
+                          comp_base_sequence_cbegin<Component>(state), res_it, std::forward<ResFunc>(func));
 }
 
 } // namespace detail
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
index b5bc94188..fd88d340a 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/topology.hpp
@@ -23,7 +23,7 @@ constexpr void register_topo_components(MainModelState<ComponentContainer> const
     auto const end = get_component_citer<Component>(state).end();
 
     target.resize(std::distance(begin, end));
-    std::transform(begin, end, target.begin(), func);
+    std::transform(begin, end, target.begin(), std::forward<ResFunc>(func));
 }
 
 } // namespace detail
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp
index 25a304f17..50ea2eaf4 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_core/update.hpp
@@ -29,6 +29,7 @@ inline void iterate_component_sequence(Func&& func, ForwardIterator begin, Forwa
         // get component directly using sequence id
         func(*it, sequence_idx[seq]);
     }
+    (void)std::forward<Func>(func);
 }
 
 template <typename T> bool check_id_na(T const& obj) {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp
index 5f18b35e8..148bbcfb5 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp
@@ -55,34 +55,10 @@ class MainModel {
         impl().get_indexer(component_type, id_begin, size, indexer_begin);
     }
 
-    void set_construction_complete() { impl().set_construction_complete(); }
-
-    template <class CompType> void add_component(std::vector<typename CompType::InputType> const& components) {
-        add_component<CompType>(std::span<typename CompType::InputType const>{components});
-    }
-    template <class CompType> void add_component(std::span<typename CompType::InputType const> components) {
-        impl().add_component<CompType>(components);
-    }
-
     template <cache_type_c CacheType> void update_components(ConstDataset const& update_data) {
         impl().update_components<CacheType>(update_data.get_individual_scenario(0));
     }
 
-    template <typename CompType, typename MathOutputType, typename OutputType>
-    void output_result(MathOutputType const& math_output, std::vector<OutputType>& target) const {
-        output_result<CompType>(math_output, std::span<OutputType>{target});
-    }
-    template <typename CompType, typename MathOutputType, typename OutputType>
-    void output_result(MathOutputType const& math_output, std::span<OutputType> target) const {
-        impl().output_result<CompType>(math_output, target.begin());
-    }
-
-    template <calculation_type_tag calculation_type, symmetry_tag sym> auto calculate(Options const& options) {
-        return impl().calculate<calculation_type, sym>(options);
-    }
-    void calculate(Options const& options, MutableDataset const& result_data) {
-        return impl().calculate(options, result_data);
-    }
     BatchParameter calculate(Options const& options, MutableDataset const& result_data,
                              ConstDataset const& update_data) {
         return impl().calculate(options, result_data, update_data);
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp
index 9113e1844..014951ced 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp
@@ -172,6 +172,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     explicit MainModelImpl(double system_frequency, meta_data::MetaData const& meta_data)
         : system_frequency_{system_frequency}, meta_data_{&meta_data} {}
 
+  private:
     // helper function to get what components are present in the update data
     std::array<bool, main_core::utils::n_types<ComponentType...>>
     get_components_to_update(ConstDataset const& update_data) const {
@@ -255,6 +256,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
             update_component<CompType, CacheType>(components.begin(), components.end(), sequence_idx);
         }
     }
+
     template <class CompType, cache_type_c CacheType>
     void update_component(ConstDataset::RangeObject<typename CompType::UpdateType const> components,
                           std::span<Idx2D const> sequence_idx) {
@@ -290,6 +292,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
                     std::get<main_core::utils::index_of_component<CT, ComponentType...>>(sequence_idx_map));
             });
     }
+
+  public:
     // overload to update all components in the first scenario (e.g. permanent update)
     template <cache_type_c CacheType> void update_components(ConstDataset const& update_data) {
         auto const components_to_update = get_components_to_update(update_data);
@@ -300,6 +304,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         update_components<CacheType>(update_data, 0, sequence_idx_map);
     }
 
+  private:
     // set complete construction
     // initialize internal arrays
     void set_construction_complete() {
@@ -338,6 +343,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         state_.comp_coup = {};
     }
 
+  public:
     /*
     the the sequence indexer given an input array of ID's for a given component type
     */
@@ -352,6 +358,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         main_core::utils::run_functor_with_all_types_return_void<ComponentType...>(get_index_func);
     }
 
+  private:
     // Entry point for main_model.hpp
     main_core::utils::SequenceIdx<ComponentType...> get_all_sequence_idx_map(ConstDataset const& update_data) {
         auto const components_to_update = get_components_to_update(update_data);
@@ -361,7 +368,6 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
             state_, update_data, 0, components_to_update, update_independence, false);
     }
 
-  private:
     void update_state(const UpdateChange& changes) {
         // if topology changed, everything is not up to date
         // if only param changed, set param to not up to date
@@ -412,21 +418,21 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         assert(construction_complete_);
         calculation_info_ = CalculationInfo{};
         // prepare
-        auto const& input = [this, &prepare_input] {
+        auto const& input = [this, prepare_input_ = std::forward<PrepareInputFn>(prepare_input)] {
             Timer const timer(calculation_info_, 2100, "Prepare");
             prepare_solvers<sym>();
             assert(is_topology_up_to_date_ && is_parameter_up_to_date<sym>());
-            return prepare_input(n_math_solvers_);
+            return prepare_input_(n_math_solvers_);
         }();
         // calculate
-        return [this, &input, &solve] {
+        return [this, &input, solve_ = std::forward<SolveFn>(solve)] {
             Timer const timer(calculation_info_, 2200, "Math Calculation");
             auto& solvers = get_solvers<sym>();
             auto& y_bus_vec = get_y_bus<sym>();
             std::vector<SolverOutputType> solver_output;
             solver_output.reserve(n_math_solvers_);
             for (Idx i = 0; i != n_math_solvers_; ++i) {
-                solver_output.emplace_back(solve(solvers[i], y_bus_vec[i], input[i]));
+                solver_output.emplace_back(solve_(solvers[i], y_bus_vec[i], input[i]));
             }
             return solver_output;
         }();
@@ -493,7 +499,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         // if the update dataset is empty without any component
         // execute one power flow in the current instance, no batch calculation is needed
         if (update_data.empty()) {
-            calculation_fn(*this, result_data, 0);
+            std::forward<Calculate>(calculation_fn)(*this, result_data, 0);
             return BatchParameter{};
         }
 
@@ -516,9 +522,9 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
                                *meta_data_,
                            },
                            ignore_output);
-        } catch (const SparseMatrixError&) {
+        } catch (const SparseMatrixError&) { // NOLINT(bugprone-empty-catch)
             // missing entries are provided in the update data
-        } catch (const NotObservableError&) {
+        } catch (const NotObservableError&) { // NOLINT(bugprone-empty-catch)
             // missing entries are provided in the update data
         }
 
@@ -528,8 +534,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
 
         // lambda for sub batch calculation
         main_core::utils::SequenceIdx<ComponentType...> all_scenarios_sequence;
-        auto sub_batch =
-            sub_batch_calculation_(calculation_fn, result_data, update_data, all_scenarios_sequence, exceptions, infos);
+        auto sub_batch = sub_batch_calculation_(std::forward<Calculate>(calculation_fn), result_data, update_data,
+                                                all_scenarios_sequence, exceptions, infos);
 
         batch_dispatch(sub_batch, n_scenarios, threading);
 
@@ -556,9 +562,9 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         all_scenarios_sequence = main_core::update::get_all_sequence_idx_map<ComponentType...>(
             state_, update_data, 0, components_to_update, update_independence, false);
 
-        return [&base_model, &exceptions, &infos, &calculation_fn, &result_data, &update_data,
-                &all_scenarios_sequence_ = std::as_const(all_scenarios_sequence), components_to_update,
-                update_independence](Idx start, Idx stride, Idx n_scenarios) {
+        return [&base_model, &exceptions, &infos, calculation_fn_ = std::forward<Calculate>(calculation_fn),
+                &result_data, &update_data, &all_scenarios_sequence_ = std::as_const(all_scenarios_sequence),
+                components_to_update, update_independence](Idx start, Idx stride, Idx n_scenarios) {
             assert(n_scenarios <= narrow_cast<Idx>(exceptions.size()));
             assert(n_scenarios <= narrow_cast<Idx>(infos.size()));
 
@@ -576,8 +582,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
                                         all_scenarios_sequence_, current_scenario_sequence_cache, infos);
 
             auto calculate_scenario = MainModelImpl::call_with<Idx>(
-                [&model, &calculation_fn, &result_data, &infos](Idx scenario_idx) {
-                    calculation_fn(model, result_data, scenario_idx);
+                [&model, &calculation_fn_, &result_data, &infos](Idx scenario_idx) {
+                    calculation_fn_(model, result_data, scenario_idx);
                     infos[scenario_idx].merge(model.calculation_info_);
                 },
                 std::move(setup), std::move(winddown), scenario_exception_handler(model, exceptions, infos),
@@ -718,7 +724,6 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         }
     }
 
-  public:
     // Calculate with optimization, e.g., automatic tap changer
     template <calculation_type_tag calculation_type, symmetry_tag sym> auto calculate(Options const& options) {
         auto const calculator = [this, &options] {
@@ -771,6 +776,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
             *this, options, result_data, pos);
     }
 
+  public:
     // Batch calculation, propagating the results to result_data
     BatchParameter calculate(Options const& options, MutableDataset const& result_data,
                              ConstDataset const& update_data) {
@@ -785,6 +791,9 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
             result_data, update_data, options.threading);
     }
 
+    CalculationInfo calculation_info() const { return calculation_info_; }
+
+  private:
     template <typename Component, typename MathOutputType, typename ResIt>
         requires solver_output_type<typename MathOutputType::SolverOutputType::value_type>
     ResIt output_result(MathOutputType const& math_output, ResIt res_it) const {
@@ -818,9 +827,6 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
         main_core::utils::run_functor_with_all_types_return_void<ComponentType...>(output_func);
     }
 
-    CalculationInfo calculation_info() const { return calculation_info_; }
-
-  private:
     mutable CalculationInfo calculation_info_; // needs to be first due to padding override
                                                // may be changed in const functions for metrics
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp
index 52ec67f78..0bf080e93 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/common_solver_functions.hpp
@@ -167,6 +167,7 @@ inline void calculate_load_gen_result(IdxRange const& load_gens, Idx bus_number,
         }
         output.load_gen[load_gen].i = conj(output.load_gen[load_gen].s / output.u[bus_number]);
     }
+    (void)std::forward<LoadGenFunc>(load_gen_func);
 }
 
 template <symmetry_tag sym, typename LoadGenFunc>
@@ -191,6 +192,7 @@ inline void calculate_pf_result(YBus<sym> const& y_bus, PowerFlowInput<sym> cons
         calculate_load_gen_result<sym>(load_gens, bus_number, input, output, load_gen_func);
         calculate_source_result<sym>(sources, bus_number, y_bus, input, output, load_gens);
     }
+    (void)std::forward<LoadGenFunc>(load_gen_func);
 }
 
 template <symmetry_tag sym>
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp
index a04065c81..3c256563f 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/newton_raphson_se_solver.hpp
@@ -93,17 +93,17 @@ template <symmetry_tag sym_type> class NewtonRaphsonSESolver {
     static constexpr auto is_iterative = true;
 
   private:
-    enum class Order { row_major = 0, column_major = 1 };
+    enum class Order : IntS { row_major = 0, column_major = 1 };
 
     struct NRSEVoltageState {
-        ComplexTensor<sym> ui_ui_conj{};
-        ComplexTensor<sym> uj_uj_conj{};
-        ComplexTensor<sym> ui_uj_conj{};
-        ComplexTensor<sym> uj_ui_conj{};
-        ComplexValue<sym> ui{};
-        ComplexValue<sym> uj{};
-        RealDiagonalTensor<sym> abs_ui_inv{};
-        RealDiagonalTensor<sym> abs_uj_inv{};
+        ComplexTensor<sym> ui_ui_conj;
+        ComplexTensor<sym> uj_uj_conj;
+        ComplexTensor<sym> ui_uj_conj;
+        ComplexTensor<sym> uj_ui_conj;
+        ComplexValue<sym> ui;
+        ComplexValue<sym> uj;
+        RealDiagonalTensor<sym> abs_ui_inv;
+        RealDiagonalTensor<sym> abs_uj_inv;
 
         auto const& u_chi_u_chi_conj(Order ij_voltage_order) const {
             return ij_voltage_order == Order::row_major ? ui_ui_conj : uj_uj_conj;
@@ -120,10 +120,10 @@ template <symmetry_tag sym_type> class NewtonRaphsonSESolver {
     };
 
     struct NRSEJacobian {
-        RealTensor<sym> dP_dt{};
-        RealTensor<sym> dP_dv{};
-        RealTensor<sym> dQ_dt{};
-        RealTensor<sym> dQ_dv{};
+        RealTensor<sym> dP_dt;
+        RealTensor<sym> dP_dv;
+        RealTensor<sym> dQ_dt;
+        RealTensor<sym> dQ_dv;
 
         NRSEJacobian& operator+=(NRSEJacobian const& other) {
             this->dP_dt += other.dP_dt;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/sparse_lu_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/sparse_lu_solver.hpp
index 5dd74d28f..c2e7e530e 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/sparse_lu_solver.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/sparse_lu_solver.hpp
@@ -138,6 +138,7 @@ template <rk2_tensor Matrix> class DenseLUFactor {
                 throw SparseMatrixError{}; // can not specify error code
             }
         }
+        (void)std::move(matrix);
     }
 };
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
index c465bae4e..3c22cfbae 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/y_bus.hpp
@@ -527,12 +527,12 @@ template <symmetry_tag sym> class YBus {
     std::shared_ptr<MathModelParam<sym> const> math_model_param_;
 
     // cache the branch and shunt parameters in sequence_idx_map
-    IdxVector branch_param_idx_{};
-    IdxVector shunt_param_idx_{};
+    IdxVector branch_param_idx_;
+    IdxVector shunt_param_idx_;
 
     // map index between admittance entries and parameter entries
-    std::vector<IdxVector> map_admittance_param_branch_{};
-    std::vector<IdxVector> map_admittance_param_shunt_{};
+    std::vector<IdxVector> map_admittance_param_branch_;
+    std::vector<IdxVector> map_admittance_param_shunt_;
 
     std::unordered_map<uint64_t, ParamChangedCallback> parameters_changed_callbacks_;
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
index 1da69591c..48ba47441 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
@@ -70,8 +70,8 @@ using TrafoGraphEdges = std::vector<std::pair<TrafoGraphIdx, TrafoGraphIdx>>;
 using TrafoGraphEdgeProperties = std::vector<TrafoGraphEdge>;
 
 struct RegulatedObjects {
-    std::set<Idx> transformers{};
-    std::set<Idx> transformers3w{};
+    std::set<Idx> transformers;
+    std::set<Idx> transformers3w;
 };
 
 using TransformerGraph = boost::compressed_sparse_row_graph<boost::directedS, TrafoGraphVertex, TrafoGraphEdge,
@@ -228,7 +228,7 @@ inline void process_edges_dijkstra(Idx v, std::vector<EdgeWeight>& vertex_distan
     using TrafoGraphElement = std::pair<EdgeWeight, TrafoGraphIdx>;
     std::priority_queue<TrafoGraphElement, std::vector<TrafoGraphElement>, std::greater<>> pq;
     vertex_distances[v] = 0;
-    pq.push({0, v});
+    pq.emplace(0, v);
 
     while (!pq.empty()) {
         auto [dist, u] = pq.top();
@@ -246,10 +246,10 @@ inline void process_edges_dijkstra(Idx v, std::vector<EdgeWeight>& vertex_distan
             // We can not use BGL_FORALL_OUTEDGES here because our grid is undirected
             if (u == s && vertex_distances[s] + weight < vertex_distances[t]) {
                 vertex_distances[t] = vertex_distances[s] + weight;
-                pq.push({vertex_distances[t], t});
+                pq.emplace(vertex_distances[t], t);
             } else if (u == t && vertex_distances[t] + weight < vertex_distances[s]) {
                 vertex_distances[s] = vertex_distances[t] + weight;
-                pq.push({vertex_distances[s], s});
+                pq.emplace(vertex_distances[s], s);
             }
         }
     }
@@ -603,7 +603,7 @@ class TapPositionOptimizerImpl<std::tuple<TransformerTypes...>, StateCalculator,
     using TransformerRanker = TransformerRanker_;
 
   private:
-    std::vector<uint64_t> max_tap_ranges_per_rank{};
+    std::vector<uint64_t> max_tap_ranges_per_rank;
     using ComponentContainer = typename State::ComponentContainer;
     using RegulatedTransformer = TapRegulatorRef<TransformerTypes...>;
     using UpdateBuffer = std::tuple<std::vector<typename TransformerTypes::UpdateType>...>;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/sparse_ordering.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/sparse_ordering.hpp
index 43a59cff6..dd5f941a9 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/sparse_ordering.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/sparse_ordering.hpp
@@ -208,7 +208,8 @@ inline std::pair<IdxVector, std::vector<std::pair<Idx, Idx>>> minimum_degree_ord
             alpha.push_back(alpha.back() == from ? to : from);
             return {alpha, fills};
         }
-        std::ranges::copy(detail::remove_vertices_update_degrees(u, d, dgd, fills), std::back_inserter(alpha));
+        auto result = detail::remove_vertices_update_degrees(u, d, dgd, fills);
+        alpha.insert(alpha.end(), result.begin(), result.end());
         if (d.empty()) {
             return {alpha, fills};
         }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp
index 96f49d225..48ff6fdb4 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/topology.hpp
@@ -329,7 +329,7 @@ class Topology {
             permuted_node_indices[reordered[idx]] = n_non_cyclic_nodes + idx;
         }
 
-        std::ranges::copy(reordered, std::back_inserter(dfs_node));
+        dfs_node.insert(dfs_node.end(), reordered.begin(), reordered.end());
         for (auto [from, to] : fills) {
             auto from_reordered = permuted_node_indices[from];
             auto to_reordered = permuted_node_indices[to];
@@ -530,6 +530,7 @@ class Topology {
                 coupling[topo_comp_i] = Idx2D{topo_idx, new_math_comp_i};
             }
         }
+        (void)std::forward<GetMathTopoComponent>(get_component_topo);
     }
 
     void couple_all_appliance() {
diff --git a/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h b/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h
index 6b769c596..1986f35dd 100644
--- a/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h
+++ b/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h
@@ -141,6 +141,8 @@ typedef struct PGM_DatasetInfo PGM_DatasetInfo;
 
 // NOLINTEND(modernize-use-using)
 
+// NOLINTBEGIN(performance-enum-size)
+
 // enums
 /**
  * @brief Enumeration for calculation type.
@@ -244,6 +246,8 @@ enum PGM_ExperimentalFeatures {
     PGM_experimental_features_enabled = 1,  /**< enable experimental features */
 };
 
+// NOLINTEND(performance-enum-size)
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/tests/cpp_unit_tests/test_fault.cpp b/tests/cpp_unit_tests/test_fault.cpp
index 0e0be35f5..c58ae13d8 100644
--- a/tests/cpp_unit_tests/test_fault.cpp
+++ b/tests/cpp_unit_tests/test_fault.cpp
@@ -42,7 +42,7 @@ TEST_CASE("Test fault") {
 
         // Connected to source
         param = fault.calc_param(u_rated);
-        double const base_y = base_i / (u_rated / sqrt(3));
+        double const base_y = base_i / (u_rated / sqrt3);
         DoubleComplex const y_f = 1.0 / (3.0 + 1.0i * 4.0) / base_y;
         CHECK(cabs(param.y_fault - y_f) < numerical_tolerance);
         CHECK(param.fault_type == FaultType::two_phase_to_ground);
@@ -288,10 +288,12 @@ TEST_CASE("Test fault") {
         }
 
         SUBCASE("Invalid fault type") {
-            CHECK_THROWS_AS((Fault{{1, 1, static_cast<FaultType>(-127), FaultPhase::nan, 4, 3.0, 4.0}}),
-                            InvalidShortCircuitType);
+            constexpr auto bad_value{
+                static_cast<FaultType>(-127)}; // NOLINT(clang-analyzer-optin.core.EnumCastOutOfRange)
 
-            FaultUpdate const fault_update{1, 0, static_cast<FaultType>(-127), FaultPhase::nan, 10, nan, nan};
+            CHECK_THROWS_AS((Fault{{1, 1, bad_value, FaultPhase::nan, 4, 3.0, 4.0}}), InvalidShortCircuitType);
+
+            FaultUpdate const fault_update{1, 0, bad_value, FaultPhase::nan, 10, nan, nan};
             CHECK_THROWS_AS(fault.update(fault_update), InvalidShortCircuitType);
         }
     }
@@ -300,7 +302,7 @@ TEST_CASE("Test fault") {
         FaultUpdate const fault_update_rx{1, na_IntS, FaultType::nan, FaultPhase::nan, na_IntID, 10.0, 20.0};
         fault.update(fault_update_rx);
         FaultCalcParam const param = fault.calc_param(u_rated);
-        double const base_y = base_i / (u_rated / sqrt(3));
+        double const base_y = base_i / (u_rated / sqrt3);
         DoubleComplex const y_f = 1.0 / (10.0 + 20.0i) / base_y;
         CHECK(cabs(param.y_fault - y_f) < numerical_tolerance);
         CHECK(param.fault_type == FaultType::two_phase_to_ground);
diff --git a/tests/cpp_unit_tests/test_grouped_index_vector.cpp b/tests/cpp_unit_tests/test_grouped_index_vector.cpp
index e1ebc7fb7..3b0a7778e 100644
--- a/tests/cpp_unit_tests/test_grouped_index_vector.cpp
+++ b/tests/cpp_unit_tests/test_grouped_index_vector.cpp
@@ -170,7 +170,7 @@ TEST_CASE_TEMPLATE("Enumerated zip iterator for grouped index data structures",
         // Test single zipped iteration
         IdxRanges actual_ranges_a{};
         Idx current_index{};
-        for (auto [index, element_range] : enumerated_zip_sequence(idx_vector_a)) {
+        for (auto const& [index, element_range] : enumerated_zip_sequence(idx_vector_a)) {
             actual_ranges_a.push_back(element_range);
 
             CHECK(index == current_index++);
@@ -184,7 +184,7 @@ TEST_CASE_TEMPLATE("Enumerated zip iterator for grouped index data structures",
         IdxRanges actual_ranges_a{};
         IdxRanges actual_ranges_b{};
         Idx current_index{};
-        for (auto const [index, first_group, second_group] : enumerated_zip_sequence(idx_vector_a, idx_vector_b)) {
+        for (auto const& [index, first_group, second_group] : enumerated_zip_sequence(idx_vector_a, idx_vector_b)) {
             for (auto& element : first_group) {
                 actual_idx_counts_a.push_back(element);
             }
@@ -209,7 +209,7 @@ TEST_CASE_TEMPLATE("Enumerated zip iterator for grouped index data structures",
         IdxRanges actual_ranges_b{};
         IdxRanges actual_ranges_c{};
         Idx current_index{};
-        for (auto [index, element_range_1, element_range_2, element_range_3] :
+        for (auto const& [index, element_range_1, element_range_2, element_range_3] :
              enumerated_zip_sequence(idx_vector_a, idx_vector_b, idx_vector_c)) {
             actual_ranges_a.push_back(element_range_1);
             actual_ranges_b.push_back(element_range_2);
diff --git a/tests/cpp_unit_tests/test_line.cpp b/tests/cpp_unit_tests/test_line.cpp
index b06b3e374..ff0ba3a3b 100644
--- a/tests/cpp_unit_tests/test_line.cpp
+++ b/tests/cpp_unit_tests/test_line.cpp
@@ -57,9 +57,9 @@ TEST_CASE("Test line") {
 
     // Short circuit results
     DoubleComplex const if_sc{1.0, 1.0};
-    DoubleComplex const it_sc{2.0, 2.0 * sqrt(3)};
+    DoubleComplex const it_sc{2.0, 2.0 * sqrt3};
     ComplexValue<asymmetric_t> const if_sc_asym{1.0 + 1.0i};
-    ComplexValue<asymmetric_t> const it_sc_asym{2.0 + (2.0i * sqrt(3))};
+    ComplexValue<asymmetric_t> const it_sc_asym{2.0 + (2.0i * sqrt3)};
 
     CHECK(line.math_model_type() == ComponentType::branch);
 
diff --git a/tests/cpp_unit_tests/test_link.cpp b/tests/cpp_unit_tests/test_link.cpp
index 5ef803fea..cd0a86b58 100644
--- a/tests/cpp_unit_tests/test_link.cpp
+++ b/tests/cpp_unit_tests/test_link.cpp
@@ -27,9 +27,9 @@ TEST_CASE("Test link") {
 
     // Short circuit results
     DoubleComplex const if_sc{1.0, 1.0};
-    DoubleComplex const it_sc{2.0, 2.0 * sqrt(3)};
+    DoubleComplex const it_sc{2.0, 2.0 * sqrt3};
     ComplexValue<asymmetric_t> const if_sc_asym{1.0 + 1.0i};
-    ComplexValue<asymmetric_t> const it_sc_asym{2.0 + (2.0i * sqrt(3))};
+    ComplexValue<asymmetric_t> const it_sc_asym{2.0 + (2.0i * sqrt3)};
 
     CHECK(link.math_model_type() == ComponentType::branch);
 
diff --git a/tests/cpp_unit_tests/test_load_gen.cpp b/tests/cpp_unit_tests/test_load_gen.cpp
index 8e392d68e..cc883894b 100644
--- a/tests/cpp_unit_tests/test_load_gen.cpp
+++ b/tests/cpp_unit_tests/test_load_gen.cpp
@@ -13,6 +13,8 @@ TYPE_TO_STRING_AS("AsymLoad", power_grid_model::AsymLoad);
 
 namespace power_grid_model {
 namespace {
+using std::numbers::sqrt2;
+
 void check_nan_preserving_equality(std::floating_point auto actual, std::floating_point auto expected) {
     if (is_nan(expected)) {
         is_nan(actual);
@@ -48,16 +50,16 @@ TEST_CASE("Test load generator") {
     double const base_i = base_power_1p / (10e3 / sqrt3);
     DoubleComplex const u{1.1 * std::exp(1.0i * 10.0)};
     ComplexValue<asymmetric_t> const ua{1.1 * std::exp(1.0i * 10.0)};
-    double const pf = 1 / sqrt(2.0);
-    double const s_pq = sqrt(2.0) * 3e6;
+    double const pf = 1 / sqrt2;
+    double const s_pq = sqrt2 * 3e6;
     double const p_pq = 3e6;
     double const q_pq = 3e6;
     double const i_pq = s_pq / (1.1 * 10e3) / sqrt3;
-    double const s_y = sqrt(2.0) * 3e6 * 1.1 * 1.1;
+    double const s_y = sqrt2 * 3e6 * 1.1 * 1.1;
     double const p_y = 3e6 * 1.1 * 1.1;
     double const q_y = 3e6 * 1.1 * 1.1;
     double const i_y = s_y / (1.1 * 10e3) / sqrt3;
-    double const s_i = sqrt(2.0) * 3e6 * 1.1;
+    double const s_i = sqrt2 * 3e6 * 1.1;
     double const p_i = 3e6 * 1.1;
     double const q_i = 3e6 * 1.1;
     double const i_i = s_i / (1.1 * 10e3) / sqrt3;
diff --git a/tests/cpp_unit_tests/test_math_solver_common.hpp b/tests/cpp_unit_tests/test_math_solver_common.hpp
index da4f005d8..174783559 100644
--- a/tests/cpp_unit_tests/test_math_solver_common.hpp
+++ b/tests/cpp_unit_tests/test_math_solver_common.hpp
@@ -112,6 +112,7 @@ template <symmetry_tag sym_type> struct SteadyStateSolverTestGrid {
     static constexpr double v1 = 0.97;
     static constexpr double v2 = 0.90;
     static constexpr double deg = deg_30 / 30.0;
+    // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members) // should be constexpr but cant due to std::exp
     DoubleComplex const u0 = v0 * std::exp(-1.0i * deg);
     DoubleComplex const u1 = v1 * std::exp(-4.0i * deg);
     DoubleComplex const u2 = v2 * std::exp(-37.0i * deg);
@@ -136,6 +137,7 @@ template <symmetry_tag sym_type> struct SteadyStateSolverTestGrid {
     // injection of shunt0 at bus2
     DoubleComplex const i2_shunt_inj = branch1_i_t;
     DoubleComplex const ys = -i2_shunt_inj / u2; // output
+    // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
 
     SolverOutput<sym> output_ref() const {
         if constexpr (is_symmetric_v<sym>) {
diff --git a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
index 3b732f838..1dc23b1eb 100644
--- a/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
+++ b/tests/cpp_unit_tests/test_tap_position_optimizer.cpp
@@ -712,8 +712,9 @@ TEST_CASE("Test Tap position optimizer") {
     };
 
     auto const get_optimizer = [&](OptimizerStrategy strategy, SearchMethod tap_search) {
-        return pgm_tap::TapPositionOptimizer<MockStateCalculator, decltype(updater), MockState, MockTransformerRanker>{
-            test::mock_state_calculator, updater, strategy, meta_data, tap_search};
+        return pgm_tap::TapPositionOptimizer<MockStateCalculator, std::remove_const_t<decltype(updater)>, MockState,
+                                             MockTransformerRanker>{test::mock_state_calculator, updater, strategy,
+                                                                    meta_data, tap_search};
     };
 
     SUBCASE("empty state") {
diff --git a/tests/cpp_unit_tests/test_voltage_sensor.cpp b/tests/cpp_unit_tests/test_voltage_sensor.cpp
index e01d9aada..a47345f60 100644
--- a/tests/cpp_unit_tests/test_voltage_sensor.cpp
+++ b/tests/cpp_unit_tests/test_voltage_sensor.cpp
@@ -114,8 +114,8 @@ TEST_CASE("Test voltage sensor") {
         VoltageSensorCalcParam<asymmetric_t> param = voltage_sensor.calc_param<asymmetric_t>();
         CHECK(param.variance == doctest::Approx(6.75));
 
-        ComplexValue<asymmetric_t> expected_param_value{0.5 * sqrt(3) * exp(1i * 2.0), 0.55 * sqrt(3) * exp(1i * 2.1),
-                                                        0.6 * sqrt(3) * exp(1i * 2.2)};
+        ComplexValue<asymmetric_t> expected_param_value{0.5 * sqrt3 * exp(1i * 2.0), 0.55 * sqrt3 * exp(1i * 2.1),
+                                                        0.6 * sqrt3 * exp(1i * 2.2)};
         CHECK(cabs(param.value[0]) == doctest::Approx(cabs(expected_param_value[0])));
         CHECK(cabs(param.value[1]) == doctest::Approx(cabs(expected_param_value[1])));
         CHECK(cabs(param.value[2]) == doctest::Approx(cabs(expected_param_value[2])));
@@ -126,8 +126,7 @@ TEST_CASE("Test voltage sensor") {
 
         update = voltage_sensor.update(vs_update);
         param = voltage_sensor.calc_param<asymmetric_t>();
-        expected_param_value = {1.5 * sqrt(3) * exp(1i * 4.0), 0.55 * sqrt(3) * exp(1i * 4.1),
-                                1.6 * sqrt(3) * exp(1i * 2.2)};
+        expected_param_value = {1.5 * sqrt3 * exp(1i * 4.0), 0.55 * sqrt3 * exp(1i * 4.1), 1.6 * sqrt3 * exp(1i * 2.2)};
 
         CHECK(cabs(param.value[0]) == doctest::Approx(cabs(expected_param_value[0])));
         CHECK(cabs(param.value[1]) == doctest::Approx(cabs(expected_param_value[1])));
diff --git a/tests/native_api_tests/test_api_model_update.cpp b/tests/native_api_tests/test_api_model_update.cpp
index 8dd14f324..619adbeeb 100644
--- a/tests/native_api_tests/test_api_model_update.cpp
+++ b/tests/native_api_tests/test_api_model_update.cpp
@@ -261,25 +261,6 @@ namespace {
 using namespace std::string_literals;
 using std::numbers::sqrt3;
 
-enum class CalculationSymmetry : Idx { symmetric = PGM_symmetric, asymmetric = PGM_asymmetric };
-enum class LoadGenType : IntS {
-    const_pq = 0, // constant power
-    const_y = 1,  // constant element_admittance (impedance)
-    const_i = 2,  // constant current
-};
-enum class MeasuredTerminalType : IntS {
-    branch_from = 0,
-    branch_to = 1,
-    source = 2,
-    shunt = 3,
-    load = 4,
-    generator = 5,
-    branch3_1 = 6,
-    branch3_2 = 7,
-    branch3_3 = 8,
-    node = 9
-};
-
 Options get_default_options(PGM_SymmetryType calculation_symmetry, PGM_CalculationMethod calculation_method) {
     Options opt;
     opt.set_calculation_type(PGM_power_flow);