diff --git a/docs/advanced_documentation/build-guide.md b/docs/advanced_documentation/build-guide.md
index 0cd7d55ad..32f697e5a 100644
--- a/docs/advanced_documentation/build-guide.md
+++ b/docs/advanced_documentation/build-guide.md
@@ -41,8 +41,9 @@ You need a C++ compiler with C++20 support. Below is a list of tested compilers:
 
 **Linux**
 
-* gcc >= 10.0
-  * Version 10.0 tested using the version in the `manylinux2014` container.
+* gcc >= 11.0
+  * Version 12.x tested using the version in the `manylinux_2_28` container.
+  * Version 12.x tested using the musllinux build with custom compiler
   * Version 11.x tested in CI
 * Clang >= 14.0
   * Version 14.x tested in CI
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp
index 21606f4c3..771862082 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp
@@ -107,7 +107,7 @@ class DataPointer {
 
     // conversion to const iterator
     template <class UX = DataPointer<true>>
-    operator std::enable_if_t<!is_const, UX>() const {
+    requires(!is_const) operator UX() const {
         return DataPointer<true>{ptr_, indptr_, batch_size_, elements_per_scenario_};
     }
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp
index 8a5ea8cac..bb70bc785 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data.hpp
@@ -136,9 +136,8 @@ struct DataAttribute {
 };
 
 template <class BaseType, auto member_ptr>
-inline std::enable_if_t<std::is_same_v<BaseType, typename trait_pointer_to_member<decltype(member_ptr)>::struct_type>,
-                        size_t>
-get_offset() {
+requires std::same_as<BaseType, typename trait_pointer_to_member<decltype(member_ptr)>::struct_type>
+inline size_t get_offset() {
     using struct_type = typename trait_pointer_to_member<decltype(member_ptr)>::struct_type;
     struct_type const obj{};
     return (size_t)(&(obj.*member_ptr)) - (size_t)&obj;
@@ -149,9 +148,8 @@ constexpr bool is_little_endian() {
 }
 
 template <class BaseType, auto member_ptr>
-inline std::enable_if_t<std::is_same_v<BaseType, typename trait_pointer_to_member<decltype(member_ptr)>::struct_type>,
-                        DataAttribute>
-get_data_attribute(std::string const& name) {
+requires std::same_as<BaseType, typename trait_pointer_to_member<decltype(member_ptr)>::struct_type>
+inline DataAttribute get_data_attribute(std::string_view const& name) {
     using value_type = typename trait_pointer_to_member<decltype(member_ptr)>::value_type;
     using single_data_type = data_type<value_type>;
     DataAttribute attr{};
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data_gen.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data_gen.hpp
index 32b325714..a144d51da 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data_gen.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_data_gen.hpp
@@ -23,11 +23,8 @@ namespace meta_data {
 // template function to add meta data
 template <class CT>
 void add_meta_data(AllPowerGridMetaData& meta) {
-    // TODO, remove this separate definition for UpdateType after migrating to gcc-11
-    // this is due to a wired bug in gcc-10
-    using UpdateType = typename CT::UpdateType;
     meta["input"][CT::name] = get_meta<typename CT::InputType>{}();
-    meta["update"][CT::name] = get_meta<UpdateType>{}();
+    meta["update"][CT::name] = get_meta<typename CT::UpdateType>{}();
     meta["sym_output"][CT::name] = get_meta<typename CT::template OutputType<true>>{}();
     meta["asym_output"][CT::name] = get_meta<typename CT::template OutputType<false>>{}();
     meta["sc_output"][CT::name] = get_meta<typename CT::ShortCircuitOutputType>{}();
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp
index f8bf87829..fd11a7d30 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp
@@ -227,13 +227,11 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
 
     // get item per type
     template <class GettableBaseType, class StorageableSubType>
-    GettableBaseType& get_raw(Idx pos) {
-        static_assert(std::is_base_of_v<GettableBaseType, StorageableSubType>);
+    requires std::derived_from<StorageableSubType, GettableBaseType> GettableBaseType& get_raw(Idx pos) {
         return std::get<std::vector<StorageableSubType>>(vectors_)[pos];
     }
     template <class GettableBaseType, class StorageableSubType>
-    GettableBaseType const& get_raw(Idx pos) const {
-        static_assert(std::is_base_of_v<GettableBaseType, StorageableSubType>);
+    requires std::derived_from<StorageableSubType, GettableBaseType> GettableBaseType const& get_raw(Idx pos) const {
         return std::get<std::vector<StorageableSubType>>(vectors_)[pos];
     }
 
@@ -248,8 +246,8 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
         static constexpr GetItemFuncPtrConst<GettableBaseType> ptr_const = nullptr;
     };
     template <class GettableBaseType, class StorageableSubType>
-    struct select_get_item_func_ptr<GettableBaseType, StorageableSubType,
-                                    std::enable_if_t<std::is_base_of_v<GettableBaseType, StorageableSubType>>> {
+    requires std::derived_from<StorageableSubType, GettableBaseType>
+    struct select_get_item_func_ptr<GettableBaseType, StorageableSubType> {
         static constexpr GetItemFuncPtr<GettableBaseType> ptr =
             &Container::get_raw<GettableBaseType, StorageableSubType>;
         static constexpr GetItemFuncPtrConst<GettableBaseType> ptr_const =
@@ -309,7 +307,7 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
         }
         // conversion to const iterator
         template <class ConstGettable = Gettable>
-        operator std::enable_if_t<!is_const, Iterator<ConstGettable const>>() const {
+        requires(!is_const) explicit operator Iterator<ConstGettable const>() const {
             return Iterator<ConstGettable const>{container_ptr_, idx_};
         }
 
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 5c7d8a043..0bb668190 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
@@ -138,12 +138,9 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     // template to construct components
     // using forward interators
     // different selection based on component type
-    template <class CompType, class ForwardIterator>
-    std::enable_if_t<std::is_base_of_v<Base, CompType>> add_component(ForwardIterator begin, ForwardIterator end) {
+    template <std::derived_from<Base> CompType, std::forward_iterator ForwardIterator>
+    void add_component(ForwardIterator begin, ForwardIterator end) {
         assert(!construction_complete_);
-        // check forward iterator
-        static_assert(std::is_base_of_v<std::forward_iterator_tag,
-                                        typename std::iterator_traits<ForwardIterator>::iterator_category>);
         size_t size = std::distance(begin, end);
         components_.template reserve<CompType>(size);
         // loop to add component
@@ -158,7 +155,7 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
                 double const u1 = components_.template get_item<Node>(input.from_node).u_rated();
                 double const u2 = components_.template get_item<Node>(input.to_node).u_rated();
                 // set system frequency for line
-                if constexpr (std::is_same_v<CompType, Line>) {
+                if constexpr (std::same_as<CompType, Line>) {
                     components_.template emplace<CompType>(id, input, system_frequency_, u1, u2);
                 }
                 else {
@@ -226,12 +223,9 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     // using forward interators
     // different selection based on component type
     // if sequence_idx is given, it will be used to load the object instead of using IDs via hash map.
-    template <class CompType, class CacheType, class ForwardIterator>
+    template <class CompType, class CacheType, std::forward_iterator ForwardIterator>
     void update_component(ForwardIterator begin, ForwardIterator end, std::vector<Idx2D> const& sequence_idx = {}) {
         assert(construction_complete_);
-        // check forward iterator
-        static_assert(std::is_base_of_v<std::forward_iterator_tag,
-                                        typename std::iterator_traits<ForwardIterator>::iterator_category>);
         bool const has_sequence_id = !sequence_idx.empty();
         Idx seq = 0;
         // loop to to update component
@@ -719,12 +713,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output node
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_same_v<Node, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::same_as<Node> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(components_.template citer<Component>().begin(),
                               components_.template citer<Component>().end(), comp_coup_->node.cbegin(), res_it,
@@ -738,12 +728,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output branch
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_base_of_v<Branch, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::derived_from<Branch> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(components_.template citer<Component>().begin(),
                               components_.template citer<Component>().end(),
@@ -757,12 +743,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output branch3
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_base_of_v<Branch3, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::derived_from<Branch3> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(components_.template citer<Component>().begin(),
                               components_.template citer<Component>().end(),
@@ -779,12 +761,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output source, load_gen, shunt individually
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_same_v<Appliance, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::same_as<Appliance> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         res_it = output_result<sym, Source>(math_output, res_it);
         res_it = output_result<sym, GenericLoadGen>(math_output, res_it);
@@ -793,12 +771,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output source
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_same_v<Source, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::same_as<Source> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(components_.template citer<Component>().begin(),
                               components_.template citer<Component>().end(), comp_coup_->source.cbegin(), res_it,
@@ -811,12 +785,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output load gen
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_base_of_v<GenericLoadGen, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::derived_from<GenericLoadGen> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(
             components_.template citer<Component>().begin(), components_.template citer<Component>().end(),
@@ -830,12 +800,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output shunt
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_same_v<Shunt, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::same_as<Shunt> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(components_.template citer<Component>().begin(),
                               components_.template citer<Component>().end(), comp_coup_->shunt.cbegin(), res_it,
@@ -848,12 +814,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output voltage sensor
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_base_of_v<GenericVoltageSensor, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::derived_from<GenericVoltageSensor> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(
             components_.template citer<Component>().begin(), components_.template citer<Component>().end(),
@@ -869,12 +831,8 @@ class MainModelImpl<ExtraRetrievableTypes<ExtraRetrievableType...>, ComponentLis
     }
 
     // output power sensor
-    template <bool sym, class Component, class ResIt>
-    std::enable_if_t<
-        std::is_base_of_v<std::forward_iterator_tag, typename std::iterator_traits<ResIt>::iterator_category> &&
-            std::is_base_of_v<GenericPowerSensor, Component>,
-        ResIt>
-    output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
+    template <bool sym, std::derived_from<GenericPowerSensor> Component, std::forward_iterator ResIt>
+    ResIt output_result(std::vector<MathOutput<sym>> const& math_output, ResIt res_it) {
         assert(construction_complete_);
         return std::transform(
             components_.template citer<Component>().begin(), components_.template citer<Component>().end(),
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/block_matrix.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/block_matrix.hpp
index 9f9bb9f69..33b461322 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/block_matrix.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/block_matrix.hpp
@@ -17,7 +17,7 @@ namespace power_grid_model {
 // hide implementation in inside namespace
 namespace math_model_impl {
 
-template <class T, bool sym, bool is_tensor, int n_sub_block, class = std::enable_if_t<check_scalar_v<T>>>
+template <scalar_value T, bool sym, bool is_tensor, int n_sub_block>
 struct block_trait {
     static constexpr int n_row = sym ? n_sub_block : n_sub_block * 3;
     static constexpr int n_col = is_tensor ? (sym ? n_sub_block : n_sub_block * 3) : 1;
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 5309fda4e..0b6858bb5 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
@@ -21,30 +21,30 @@ template <class Tensor, class RHSVector, class XVector, class = void>
 struct sparse_lu_entry_trait;
 
 template <class Tensor, class RHSVector, class XVector>
-using enable_scalar_lu_t =
-    std::enable_if_t<std::is_same_v<Tensor, RHSVector> && std::is_same_v<Tensor, XVector> && check_scalar_v<Tensor>>;
+concept scalar_value_lu = scalar_value<Tensor> && std::same_as<Tensor, RHSVector> && std::same_as<Tensor, XVector>;
 
+// TODO(mgovers) improve this concept
 template <class Derived>
 int check_array_base(Eigen::ArrayBase<Derived> const&) {
     return 0;
 }
+template <class ArrayLike>
+concept eigen_array = std::same_as<decltype(check_array_base(ArrayLike{})), int>;  // should be an eigen array
+
+template <class LHSArrayLike, class RHSArrayLike>
+concept matrix_multiplicable = eigen_array<LHSArrayLike> && eigen_array<RHSArrayLike> &&
+    (static_cast<Idx>(LHSArrayLike::ColsAtCompileTime) == static_cast<Idx>(RHSArrayLike::RowsAtCompileTime));
 
 template <class Tensor, class RHSVector, class XVector>
-using enable_tensor_lu_t = std::enable_if_t<
-    std::is_same_v<decltype(check_array_base(Tensor{})), int> &&            // tensor should be an eigen array
-    std::is_same_v<decltype(check_array_base(RHSVector{})), int> &&         // rhs vector should be an eigen array
-    std::is_same_v<decltype(check_array_base(XVector{})), int> &&           // x vector should be an eigen array
-    (Idx)Tensor::RowsAtCompileTime == (Idx)Tensor::ColsAtCompileTime &&     // tensor should be square
-    RHSVector::ColsAtCompileTime == 1 &&                                    // rhs vector should be column vector
-    (Idx)RHSVector::RowsAtCompileTime == (Idx)Tensor::RowsAtCompileTime &&  // rhs vector should be column vector
-    XVector::ColsAtCompileTime == 1 &&                                      // x vector should be column vector
-    (Idx)XVector::RowsAtCompileTime == (Idx)Tensor::RowsAtCompileTime &&    // x vector should be column vector
-    std::is_same_v<typename Tensor::Scalar, typename RHSVector::Scalar> &&  // all entries should have same scalar type
-    std::is_same_v<typename Tensor::Scalar, typename XVector::Scalar> &&    // all entries should have same scalar type
-    check_scalar_v<typename Tensor::Scalar>>;  // scalar can only be double or complex double
+concept tensor_lu = rk2_tensor<Tensor> && column_vector<RHSVector> && column_vector<XVector> &&
+    matrix_multiplicable<Tensor, RHSVector> && matrix_multiplicable<Tensor, XVector> &&
+    std::same_as<typename Tensor::Scalar, typename RHSVector::Scalar> &&  // all entries should have same scalar type
+    std::same_as<typename Tensor::Scalar, typename XVector::Scalar> &&    // all entries should have same scalar type
+    scalar_value<typename Tensor::Scalar>;                                // scalar can only be double or complex double
 
 template <class Tensor, class RHSVector, class XVector>
-struct sparse_lu_entry_trait<Tensor, RHSVector, XVector, enable_scalar_lu_t<Tensor, RHSVector, XVector>> {
+requires scalar_value_lu<Tensor, RHSVector, XVector>
+struct sparse_lu_entry_trait<Tensor, RHSVector, XVector> {
     static constexpr bool is_block = false;
     static constexpr Idx block_size = 1;
     using Scalar = Tensor;
@@ -55,7 +55,8 @@ struct sparse_lu_entry_trait<Tensor, RHSVector, XVector, enable_scalar_lu_t<Tens
 };
 
 template <class Tensor, class RHSVector, class XVector>
-struct sparse_lu_entry_trait<Tensor, RHSVector, XVector, enable_tensor_lu_t<Tensor, RHSVector, XVector>> {
+requires tensor_lu<Tensor, RHSVector, XVector>
+struct sparse_lu_entry_trait<Tensor, RHSVector, XVector> {
     static constexpr bool is_block = true;
     static constexpr Idx block_size = Tensor::RowsAtCompileTime;
     using Scalar = typename Tensor::Scalar;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/three_phase_tensor.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/three_phase_tensor.hpp
index ccc646080..d2a12307e 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/three_phase_tensor.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/three_phase_tensor.hpp
@@ -19,9 +19,7 @@ namespace power_grid_model {
 
 // enable scalar
 template <class T>
-constexpr bool check_scalar_v = std::is_same_v<T, double> || std::is_same_v<T, DoubleComplex>;
-template <class T>
-using enable_scalar_t = std::enable_if_t<check_scalar_v<T>>;
+concept scalar_value = std::same_as<T, double> || std::same_as<T, DoubleComplex>;
 
 namespace three_phase_tensor {
 
@@ -30,7 +28,7 @@ using Eigen3Vector = Eigen::Array<T, 3, 1>;
 template <class T>
 using Eigen3Tensor = Eigen::Array<T, 3, 3, Eigen::ColMajor>;
 
-template <class T, class = enable_scalar_t<T>>
+template <scalar_value T>
 class Vector : public Eigen3Vector<T> {
    public:
     Vector() {
@@ -49,7 +47,7 @@ class Vector : public Eigen3Vector<T> {
     // for complex number, rotate the single value by 120 and 240 degrees for 1st and 2nd entry
     // this will create a symmetric phasor based on one phasor
     explicit Vector(T const& x) {
-        if constexpr (std::is_same_v<T, double>) {
+        if constexpr (std::same_as<T, double>) {
             (*this) << x, x, x;
         }
         else {
@@ -67,7 +65,7 @@ class Vector : public Eigen3Vector<T> {
     }
 };
 
-template <class T, class = enable_scalar_t<T>>
+template <scalar_value T>
 class Tensor : public Eigen3Tensor<T> {
    public:
     Tensor() {
@@ -125,17 +123,12 @@ static_assert(std::is_trivially_destructible_v<ComplexValue<false>>);
 
 // enabler
 template <class T>
-constexpr bool check_vector_v = T::ColsAtCompileTime == 1;
-template <class T>
-constexpr bool check_tensor_v = (Idx)T::RowsAtCompileTime == (Idx)T::ColsAtCompileTime;
-template <class T>
-constexpr bool check_all_v = check_tensor_v<T> || check_vector_v<T>;
-template <class T>
-using enable_vector_t = std::enable_if_t<check_vector_v<T>>;
+concept column_vector = (T::ColsAtCompileTime == 1);
 template <class T>
-using enable_tensor_t = std::enable_if_t<check_tensor_v<T>>;
+concept rk2_tensor = (static_cast<Idx>(T::RowsAtCompileTime) ==
+                      static_cast<Idx>(T::ColsAtCompileTime));  // rank 2 tensor
 template <class T>
-using enable_all_t = std::enable_if_t<check_all_v<T>>;
+concept column_vector_or_tensor = column_vector<T> || rk2_tensor<T>;
 
 // piecewise factory construction for complex vector
 template <bool sym = false>
@@ -148,7 +141,7 @@ inline ComplexValue<sym> piecewise_complex_value(DoubleComplex const& x) {
     }
 }
 
-template <class DerivedA, class = enable_vector_t<DerivedA>>
+template <column_vector DerivedA>
 inline ComplexValue<false> piecewise_complex_value(Eigen::ArrayBase<DerivedA> const& val) {
     return val;
 }
@@ -163,7 +156,7 @@ inline double cabs(DoubleComplex const& x) {
 inline double abs2(DoubleComplex const& x) {
     return std::norm(x);
 }
-template <class DerivedA, class = enable_all_t<DerivedA>>
+template <column_vector_or_tensor DerivedA>
 inline auto cabs(Eigen::ArrayBase<DerivedA> const& m) {
     return sqrt(abs2(m));
 }
@@ -172,7 +165,7 @@ inline auto cabs(Eigen::ArrayBase<DerivedA> const& m) {
 inline double vector_outer_product(double x, double y) {
     return x * y;
 }
-template <class DerivedA, class DerivedB, class = enable_vector_t<DerivedA>, class = enable_vector_t<DerivedB>>
+template <column_vector DerivedA, column_vector DerivedB>
 inline auto vector_outer_product(Eigen::ArrayBase<DerivedA> const& x, Eigen::ArrayBase<DerivedB> const& y) {
     return (x.matrix() * y.matrix().transpose()).array();
 }
@@ -185,12 +178,12 @@ inline DoubleComplex dot(DoubleComplex const& x, DoubleComplex const& y) {
     return x * y;
 }
 
-template <class... T, class = std::enable_if_t<(check_scalar_v<T> && ...)>>
+template <scalar_value... T>
 inline auto dot(T const&... x) {
     return (... * x);
 }
 
-template <class... Derived, class = std::enable_if_t<(check_all_v<Derived> && ...)>>
+template <column_vector_or_tensor... Derived>
 inline auto dot(Eigen::ArrayBase<Derived> const&... x) {
     auto res_mat = (... * x.matrix());
     return res_mat.array();
@@ -200,13 +193,13 @@ inline auto dot(Eigen::ArrayBase<Derived> const&... x) {
 inline double max_val(double val) {
     return val;
 }
-template <class DerivedA, class = enable_vector_t<DerivedA>>
+template <column_vector DerivedA>
 inline double max_val(Eigen::ArrayBase<DerivedA> const& val) {
     return val.maxCoeff();
 }
 
 // function to sum rows of tensor
-template <class DerivedA, class = enable_tensor_t<DerivedA>>
+template <rk2_tensor DerivedA>
 inline auto sum_row(Eigen::ArrayBase<DerivedA> const& m) {
     return m.rowwise().sum();
 }
@@ -216,7 +209,7 @@ inline double sum_row(double d) {
 }
 
 // function to sum vector
-template <class DerivedA, class = enable_vector_t<DerivedA>>
+template <column_vector DerivedA>
 inline auto sum_val(Eigen::ArrayBase<DerivedA> const& m) {
     return m.sum();
 }
@@ -229,7 +222,7 @@ inline DoubleComplex sum_val(DoubleComplex const& z) {
 }
 
 // function to mean vector
-template <class DerivedA, class = enable_vector_t<DerivedA>>
+template <column_vector DerivedA>
 inline auto mean_val(Eigen::ArrayBase<DerivedA> const& m) {
     return m.mean();
 }
@@ -251,8 +244,7 @@ inline auto process_mean_val(T&& m) {
 }
 
 // diagonal multiply
-template <class DerivedA, class DerivedB, class DerivedC, class = enable_vector_t<DerivedA>,
-          class = enable_tensor_t<DerivedB>, class = enable_vector_t<DerivedC>>
+template <column_vector DerivedA, rk2_tensor DerivedB, column_vector DerivedC>
 inline auto diag_mult(Eigen::ArrayBase<DerivedA> const& x, Eigen::ArrayBase<DerivedB> const& y,
                       Eigen::ArrayBase<DerivedC> const& z) {
     return (x.matrix().asDiagonal() * y.matrix() * z.matrix().asDiagonal()).array();
@@ -263,7 +255,7 @@ inline double diag_mult(double x, double y, double z) {
 }
 
 // calculate positive sequence
-template <class Derived, class = enable_vector_t<Derived>>
+template <column_vector Derived>
 inline DoubleComplex pos_seq(Eigen::ArrayBase<Derived> const& val) {
     return (val(0) + a * val(1) + a2 * val(2)) / 3.0;
 }
@@ -287,11 +279,11 @@ inline void add_diag(double& x, double y) {
 inline void add_diag(DoubleComplex& x, DoubleComplex const& y) {
     x += y;
 }
-template <class DerivedA, class DerivedB, class = enable_tensor_t<DerivedA>, class = enable_vector_t<DerivedB>>
+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();
 }
-template <class DerivedA, class DerivedB, class = enable_tensor_t<DerivedA>, class = enable_vector_t<DerivedB>>
+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();
 }
@@ -368,7 +360,7 @@ inline DoubleComplex hermitian_transpose(DoubleComplex const& z) {
 inline double hermitian_transpose(double x) {
     return x;
 }
-template <class Derived, class = enable_tensor_t<Derived>>
+template <rk2_tensor Derived>
 inline auto hermitian_transpose(Eigen::ArrayBase<Derived> const& x) {
     return x.matrix().adjoint().array();
 }
diff --git a/tests/cpp_unit_tests/test_container.cpp b/tests/cpp_unit_tests/test_container.cpp
index 404017c22..17b05f233 100644
--- a/tests/cpp_unit_tests/test_container.cpp
+++ b/tests/cpp_unit_tests/test_container.cpp
@@ -72,8 +72,8 @@ TEST_CASE("Test component container") {
             CHECK(c.a == i);
             i++;
         }
-        auto it_begin = container.iter<C>().begin();
-        auto it_end = container.iter<C>().end();
+        auto it_begin = container.iter<C const>().begin();
+        auto it_end = container.iter<C const>().end();
         auto const_it_begin = const_container.iter<C>().begin();
         auto const_it_end = const_container.iter<C>().end();
         CHECK(it_begin != const_it_end);
diff --git a/tests/cpp_unit_tests/test_sparse_lu_solver.cpp b/tests/cpp_unit_tests/test_sparse_lu_solver.cpp
index 808cf8370..63b7a0a06 100644
--- a/tests/cpp_unit_tests/test_sparse_lu_solver.cpp
+++ b/tests/cpp_unit_tests/test_sparse_lu_solver.cpp
@@ -23,7 +23,7 @@ template <class T>
 void check_result(std::vector<T> const& x, std::vector<T> const& x_solver) {
     CHECK(x.size() == x_solver.size());
     for (size_t i = 0; i < x.size(); i++) {
-        if constexpr (check_scalar_v<T>) {
+        if constexpr (scalar_value<T>) {
             CHECK(cabs(x[i] - x_solver[i]) < numerical_tolerance);
         }
         else {