su2code · pcarruscag · Mar 30, 2026 · Mar 28, 2026 · Mar 29, 2026 · Mar 29, 2026
diff --git a/Common/include/containers/C2DContainer.hpp b/Common/include/containers/C2DContainer.hpp
@@ -421,7 +421,7 @@ class C2DContainer
   template <class IndexSIMD_t>
   class CInnerIterGather {
    private:
-    static_assert(std::is_integral<typename IndexSIMD_t::Scalar>::value, "");
+    static_assert(std::is_integral<typename IndexSIMD_t::Scalar>::value);
     enum { Size = IndexSIMD_t::Size };
     IndexSIMD_t m_offsets;
     const Index m_increment;

diff --git a/Common/include/containers/CPyWrapperMatrixView.hpp b/Common/include/containers/CPyWrapperMatrixView.hpp
@@ -84,7 +84,7 @@
  */
 class CPyWrapperMatrixView {
  protected:
-  static_assert(su2activematrix::IsRowMajor, "");
+  static_assert(su2activematrix::IsRowMajor);
   su2double* data_ = nullptr;
   unsigned long rows_ = 0, cols_ = 0;
   std::string name_;
@@ -124,7 +124,7 @@ class CPyWrapperMatrixView {
  */
 class CPyWrapperMarkerMatrixView {
  private:
-  static_assert(su2activematrix::IsRowMajor, "");
+  static_assert(su2activematrix::IsRowMajor);
   su2double* data_ = nullptr;
   const CVertex* const* vertices_ = nullptr;
   unsigned long rows_ = 0, cols_ = 0;
@@ -175,7 +175,7 @@ class CPyWrapperMarkerMatrixView {
  */
 class CPyWrapper3DMatrixView {
  protected:
-  static_assert(su2activematrix::IsRowMajor, "");
+  static_assert(su2activematrix::IsRowMajor);
   su2double* data_ = nullptr;
   unsigned long rows_ = 0, cols_ = 0, dims_ = 0;
   std::string name_;

diff --git a/Common/include/linear_algebra/CSysMatrix.hpp b/Common/include/linear_algebra/CSysMatrix.hpp
@@ -816,10 +816,11 @@ class CSysMatrix {
   }
 
   /*!
-   * \brief Deletes the values of the row i of the sparse matrix.
-   * \param[in] i - Index of the row.
+   * \brief Deletes the values of a row of the sparse matrix.
+   * \param[in] block_i - Index of the block.
+   * \param[in] row - Row within the block.
    */
-  void DeleteValsRowi(unsigned long i);
+  void DeleteValsRowi(unsigned long block_i, unsigned long row);
 
   /*!
    * \brief Modifies this matrix (A) and a rhs vector (b) such that (A^-1 * b)_i = x_i.

diff --git a/Common/include/linear_algebra/CSysVector.hpp b/Common/include/linear_algebra/CSysVector.hpp
@@ -360,11 +360,10 @@ class CSysVector : public VecExpr::CVecExpr<CSysVector<ScalarType>, ScalarType>
     BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS {
       /*--- Reduce over all threads in an ordered way to ensure a deterministic result. ---*/
       for (int i = 1; i < omp_get_num_threads(); ++i) sum += dot_scratch[i];
-#ifdef HAVE_MPI
+
       /*--- Reduce across all mpi ranks, only the master thread communicates. ---*/
       const auto mpi_type = (sizeof(ScalarType) < sizeof(double)) ? MPI_FLOAT : MPI_DOUBLE;
       SelectMPIWrapper<ScalarType>::W::Allreduce(&sum, &dot_scratch[0], 1, mpi_type, MPI_SUM, SU2_MPI::GetComm());
-#endif
     }
     /*--- Make view of result consistent across threads. ---*/
     END_SU2_OMP_SAFE_GLOBAL_ACCESS

diff --git a/Common/include/parallelization/mpi_structure.cpp b/Common/include/parallelization/mpi_structure.cpp
@@ -28,15 +28,20 @@
 #include "mpi_structure.hpp"
 #include <cstring>  // memcpy
 
-/* Initialise the MPI Communicator Rank and Size */
+/* Initialise the MPI Communicator Rank, Size, and default MPI Communicator */
+#ifdef HAVE_MPI
 int CBaseMPIWrapper::Rank = 0;
 int CBaseMPIWrapper::Size = 1;
-
-/* Set the default MPI Communicator */
-#ifdef HAVE_MPI
 CBaseMPIWrapper::Comm CBaseMPIWrapper::currentComm = MPI_COMM_WORLD;
 #else
-CBaseMPIWrapper::Comm CBaseMPIWrapper::currentComm = 0;  // dummy value
+template <typename ScalarType>
+int CBaseMPIWrapper<ScalarType>::Rank = 0;
+
+template <typename ScalarType>
+int CBaseMPIWrapper<ScalarType>::Size = 1;
+
+template <typename ScalarType>
+typename CBaseMPIWrapper<ScalarType>::Comm CBaseMPIWrapper<ScalarType>::currentComm = 0;  // dummy value
 #endif
 
 #ifdef HAVE_MPI
@@ -122,7 +127,8 @@ void CBaseMPIWrapper::CopyData(const void* sendbuf, void* recvbuf, int size, Dat
 }
 #else  // HAVE_MPI
 
-void CBaseMPIWrapper::Error(std::string ErrorMsg, std::string FunctionName) {
+template <typename ScalarType>
+void CBaseMPIWrapper<ScalarType>::Error(const std::string& ErrorMsg, const std::string& FunctionName) {
   if (Rank == 0) {
     std::cout << std::endl << std::endl;
     std::cout << "Error in \"" << FunctionName << "\": " << std::endl;
@@ -134,12 +140,13 @@ void CBaseMPIWrapper::Error(std::string ErrorMsg, std::string FunctionName) {
   Abort(currentComm, 0);
 }
 
-void CBaseMPIWrapper::CopyData(const void* sendbuf, void* recvbuf, int size, Datatype datatype, int recvshift,
-                               int sendshift) {
+template <typename ScalarType>
+void CBaseMPIWrapper<ScalarType>::CopyData(const void* sendbuf, void* recvbuf, int size, Datatype datatype,
+                                           int recvshift, int sendshift) {
   switch (datatype) {
     case MPI_DOUBLE:
       for (int i = 0; i < size; i++) {
-        static_cast<su2double*>(recvbuf)[i + recvshift] = static_cast<const su2double*>(sendbuf)[i + sendshift];
+        static_cast<ScalarType*>(recvbuf)[i + recvshift] = static_cast<const ScalarType*>(sendbuf)[i + sendshift];
       }
       break;
     case MPI_UNSIGNED_LONG:
@@ -178,8 +185,17 @@ void CBaseMPIWrapper::CopyData(const void* sendbuf, void* recvbuf, int size, Dat
       break;
   };
 }
+
+template class CBaseMPIWrapper<su2double>;
+#if defined CODI_REVERSE_TYPE
+template class CBaseMPIWrapper<passivedouble>;
+#endif
+#if defined USE_MIXED_PRECISION
+template class CBaseMPIWrapper<su2mixedfloat>;
 #endif
 
+#endif  // HAVE_MPI
+
 #ifdef HAVE_MPI
 #if defined CODI_REVERSE_TYPE || defined CODI_FORWARD_TYPE
 MediTypes* mediTypes;

diff --git a/Common/include/parallelization/mpi_structure.hpp b/Common/include/parallelization/mpi_structure.hpp
@@ -489,6 +489,7 @@ class CMediMPIWrapper : public CBaseMPIWrapper {
  * \class CMPIWrapper
  * \brief Version for when there is no MPI.
  */
+template <typename ScalarType>
 class CBaseMPIWrapper {
  public:
   typedef int Comm;
@@ -510,7 +511,7 @@ class CBaseMPIWrapper {
   static void CopyData(const void* sendbuf, void* recvbuf, int size, Datatype datatype, int recvshift = 0,
                        int sendshift = 0);
 
-  static void Error(std::string ErrorMsg, std::string FunctionName);
+  static void Error(const std::string& ErrorMsg, const std::string& FunctionName);
 
   static inline int GetRank() { return Rank; }
 
@@ -607,27 +608,37 @@ class CBaseMPIWrapper {
 
   static inline passivedouble Wtime(void) { return omp_get_wtime(); }
 };
-typedef int SU2_Comm;
-typedef CBaseMPIWrapper SU2_MPI;
+using SU2_Comm = int;
+using SU2_MPI = CBaseMPIWrapper<su2double>;
 
 #endif
 
 /*--- Select the appropriate MPI wrapper based on datatype, to use in templated classes. ---*/
 template <class T>
 struct SelectMPIWrapper {
-  typedef SU2_MPI W;
+  using W = SU2_MPI;
 };
 
 /*--- In AD we specialize for the passive wrapper. ---*/
 #if defined CODI_REVERSE_TYPE
 template <>
 struct SelectMPIWrapper<passivedouble> {
-  typedef CBaseMPIWrapper W;
+#if defined HAVE_MPI
+  using W = CBaseMPIWrapper;
+#else
+  using W = CBaseMPIWrapper<passivedouble>;
+#endif
 };
+#endif
+
+/*--- Specialize for the low precision type. ---*/
 #if defined USE_MIXED_PRECISION
 template <>
 struct SelectMPIWrapper<su2mixedfloat> {
-  typedef CBaseMPIWrapper W;
-};
+#if defined HAVE_MPI
+  using W = CBaseMPIWrapper;
+#else
+  using W = CBaseMPIWrapper<su2mixedfloat>;
 #endif
+};
 #endif
diff --git a/Common/include/parallelization/omp_structure.hpp b/Common/include/parallelization/omp_structure.hpp
@@ -39,6 +39,7 @@
 #pragma once
 
 #include <cstddef>
+#include <algorithm>
 
 #include "../code_config.hpp"
 
@@ -274,3 +275,55 @@ inline void atomicAdd(T rhs, T& lhs) {
   SU2_OMP_ATOMIC
   lhs += rhs;
 }
+
+/*--- GCC supported atomic compare (for min/max) before it was fully 5.1 compliant. ---*/
+#define ATOMIC_COMPARE_SINCE 202011
+#ifdef __GNUC__
+#if __GNUC__ > 11
+#undef ATOMIC_COMPARE_SINCE
+#define ATOMIC_COMPARE_SINCE 201511
+#endif
+#endif
+
+/*--- By default the min/max fallback to critical is required for all types. ---*/
+#define ATOMIC_COMPARE_FALLBACK
+
+/*--- Atomic max, shared = max(shared, local). ---*/
+#ifdef _OPENMP
+#if _OPENMP >= ATOMIC_COMPARE_SINCE
+/*--- Atomic min/max are supported for arithmetic types. ---*/
+template <class T, su2enable_if<std::is_arithmetic<T>::value> = 0>
+inline void atomicMax(const T& local, T& shared) {
+#pragma omp atomic compare
+  shared = shared < local ? local : shared;
+}
+
+/*--- Redefine the fallback for non arithmetic types. ---*/
+#undef ATOMIC_COMPARE_FALLBACK
+#define ATOMIC_COMPARE_FALLBACK , su2enable_if<!std::is_arithmetic<T>::value> = 0
+#endif
+#endif
+template <class T ATOMIC_COMPARE_FALLBACK>
+inline void atomicMax(const T& local, T& shared) {
+  SU2_OMP_CRITICAL
+  shared = std::max(local, shared);
+  END_SU2_OMP_CRITICAL
+}
+
+/*--- Atomic min, shared = min(shared, local). ---*/
+#ifdef _OPENMP
+#if _OPENMP >= ATOMIC_COMPARE_SINCE
+template <class T, su2enable_if<std::is_arithmetic<T>::value> = 0>
+inline void atomicMin(const T& local, T& shared) {
+#pragma omp atomic compare
+  shared = shared > local ? local : shared;
+}
+#endif
+#endif
+template <class T ATOMIC_COMPARE_FALLBACK>
+inline void atomicMin(const T& local, T& shared) {
+  SU2_OMP_CRITICAL
+  shared = std::min(local, shared);
+  END_SU2_OMP_CRITICAL
+}
+#undef ATOMIC_COMPARE_FALLBACK
diff --git a/Common/include/toolboxes/graph_toolbox.hpp b/Common/include/toolboxes/graph_toolbox.hpp
@@ -56,7 +56,7 @@ enum class ConnectivityType { FiniteVolume = 0, FiniteElement = 1 };
  */
 template <typename Index_t>
 class CCompressedSparsePattern {
-  static_assert(std::is_integral<Index_t>::value, "");
+  static_assert(std::is_integral<Index_t>::value);
 
  private:
   su2vector<Index_t> m_outerPtr;       /*!< \brief Start positions of the inner indices for each outer index. */
@@ -490,8 +490,8 @@ T createNaturalColoring(Index_t numInnerIndexes) {
 template <typename Color_t = unsigned char, size_t MaxColors = 255, size_t MaxMB = 128, class T>
 T colorSparsePattern(const T& pattern, size_t groupSize = 1, bool includeOuterIdx = false, bool balanceColors = false,
                      std::vector<Color_t>* indexColor = nullptr) {
-  static_assert(std::is_integral<Color_t>::value, "");
-  static_assert(std::numeric_limits<Color_t>::max() >= MaxColors, "");
+  static_assert(std::is_integral<Color_t>::value);
+  static_assert(std::numeric_limits<Color_t>::max() >= MaxColors);
 
   using Index_t = typename T::IndexType;
 
@@ -607,7 +607,7 @@ T colorSparsePattern(const T& pattern, size_t groupSize = 1, bool includeOuterId
  */
 template <typename T = unsigned long>
 struct GridColor {
-  static_assert(std::is_integral<T>::value, "");
+  static_assert(std::is_integral<T>::value);
 
   const T size;
   T groupSize;
@@ -625,7 +625,7 @@ struct GridColor {
  */
 template <typename T = unsigned long>
 struct DummyGridColor {
-  static_assert(std::is_integral<T>::value, "");
+  static_assert(std::is_integral<T>::value);
 
   T size;
   struct {