Auto-format code changes (#562)

Auto-format code using Clang-Format

Co-authored-by: GitHub Actions <actions@github.com>

include/micm/solver/backward_euler.hpp

@@ -5,8 +5,8 @@
 #include <micm/profiler/instrumentation.hpp>
 #include <micm/solver/backward_euler_solver_parameters.hpp>
 #include <micm/solver/linear_solver.hpp>
-#include <micm/solver/state.hpp>
 #include <micm/solver/solver_result.hpp>
+#include <micm/solver/state.hpp>
 #include <micm/system/system.hpp>
 #include <micm/util/jacobian.hpp>
 

include/micm/solver/backward_euler.inl

@@ -152,8 +152,7 @@ namespace micm
  do
  {
  // changes that are much smaller than the tolerance are negligible and we assume can be accepted
- converged = (std::abs(*forcing_iter) <= small) ||
- (std::abs(*forcing_iter) <= *abs_tol_iter) ||
+ converged = (std::abs(*forcing_iter) <= small) || (std::abs(*forcing_iter) <= *abs_tol_iter) ||
  (std::abs(*forcing_iter) <= parameters_.relative_tolerance_ * std::abs(*yn1_iter));
  ++forcing_iter, ++yn1_iter, ++abs_tol_iter;
  } while (converged && forcing_iter != forcing.end());

include/micm/solver/backward_euler_solver_parameters.hpp

@@ -9,7 +9,7 @@
 
 namespace micm
 {
- 
+
  template<class RatesPolicy, class LinearSolverPolicy>
  class BackwardEuler;
 

include/micm/solver/cuda_rosenbrock.hpp

@@ -80,11 +80,7 @@ namespace micm
  LinearSolverPolicy&& linear_solver,
  RatesPolicy&& rates,
  auto& jacobian)
- : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(
- parameters,
- std::move(linear_solver),
- std::move(rates),
- jacobian)
+ : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(parameters, std::move(linear_solver), std::move(rates), jacobian)
  {
  CudaRosenbrockSolverParam hoststruct;
  // jacobian.GroupVectorSize() is the same as the number of grid cells for the CUDA implementation
@@ -107,9 +103,9 @@ namespace micm
  };
 
  /// @brief @brief Computes [alpha * I - jacobian] on the GPU
- /// @tparam SparseMatrixPolicy 
+ /// @tparam SparseMatrixPolicy
  /// @param jacobian Jacobian matrix
- /// @param alpha 
+ /// @param alpha
  template<class SparseMatrixPolicy>
  void AlphaMinusJacobian(SparseMatrixPolicy& jacobian, const double& alpha) const
  requires(CudaMatrix<SparseMatrixPolicy>&& VectorizableSparse<SparseMatrixPolicy>)
@@ -120,9 +116,9 @@ namespace micm
  }
 
  /// @brief @brief Computes [alpha * I - jacobian] on the CPU
- /// @tparam SparseMatrixPolicy 
+ /// @tparam SparseMatrixPolicy
  /// @param jacobian Jacobian matrix
- /// @param alpha 
+ /// @param alpha
  template<class SparseMatrixPolicy>
  void AlphaMinusJacobian(SparseMatrixPolicy& jacobian, const double& alpha) const
  requires(!CudaMatrix<SparseMatrixPolicy>)
@@ -137,11 +133,8 @@ namespace micm
  /// @param errors The computed errors
  /// @return The scaled norm of the errors
  template<class DenseMatrixPolicy>
- double NormalizedError(
- const DenseMatrixPolicy& y_old,
- const DenseMatrixPolicy& y_new,
- const DenseMatrixPolicy& errors) const
- requires(CudaMatrix<DenseMatrixPolicy>&& VectorizableDense<DenseMatrixPolicy>)
+ double NormalizedError(const DenseMatrixPolicy& y_old, const DenseMatrixPolicy& y_new, const DenseMatrixPolicy& errors)
+ const requires(CudaMatrix<DenseMatrixPolicy>&& VectorizableDense<DenseMatrixPolicy>)
  {
  // At this point, it does not matter which handle we use; may revisit it when we have a multi-node-multi-GPU test
  return micm::cuda::NormalizedErrorDriver(
@@ -154,16 +147,14 @@ namespace micm
  }
 
  /// @brief Computes the scaled norm of the vector errors on the CPU
- /// @tparam DenseMatrixPolicy 
+ /// @tparam DenseMatrixPolicy
  /// @param y_old The original vector
  /// @param y_new The new vector
  /// @param errors The computed errors
  /// @return The scaled norm of the errors
  template<class DenseMatrixPolicy>
- double NormalizedError(
- const DenseMatrixPolicy& y_old,
- const DenseMatrixPolicy& y_new,
- const DenseMatrixPolicy& errors) const requires(!CudaMatrix<DenseMatrixPolicy>)
+ double NormalizedError(const DenseMatrixPolicy& y_old, const DenseMatrixPolicy& y_new, const DenseMatrixPolicy& errors)
+ const requires(!CudaMatrix<DenseMatrixPolicy>)
  {
  return NormalizedErrorDriver(y_old, y_new, errors);
  }

include/micm/solver/cuda_solver_builder.hpp

@@ -21,5 +21,10 @@ namespace micm
  ///
  /// GPU solvers only work with vector-ordered matrices
  template<class SolverParametersPolicy, std::size_t L = MICM_DEFAULT_VECTOR_SIZE>
- using CudaSolverBuilder = SolverBuilder<SolverParametersPolicy, CudaDenseMatrix<double, L>, CudaSparseMatrix<double, SparseMatrixVectorOrdering<L>>, CudaProcessSet, CudaLinearSolver<CudaSparseMatrix<double, SparseMatrixVectorOrdering<L>>, CudaLuDecomposition>>;
-} // namespace micm
+ using CudaSolverBuilder = SolverBuilder<
+ SolverParametersPolicy,
+ CudaDenseMatrix<double, L>,
+ CudaSparseMatrix<double, SparseMatrixVectorOrdering<L>>,
+ CudaProcessSet,
+ CudaLinearSolver<CudaSparseMatrix<double, SparseMatrixVectorOrdering<L>>, CudaLuDecomposition>>;
+} // namespace micm

include/micm/solver/cuda_solver_parameters.hpp

@@ -5,22 +5,23 @@
 #pragma once
 
 #include "rosenbrock_solver_parameters.hpp"
-#include <micm/solver/rosenbrock_solver_parameters.hpp>
+
 #include <micm/solver/cuda_rosenbrock.hpp>
+#include <micm/solver/rosenbrock_solver_parameters.hpp>
 
 namespace micm
 {
-  /// @brief Parameters for the CUDA Rosenbrock solver
-  struct CudaRosenbrockSolverParameters : public RosenbrockSolverParameters
-  {
-  template<class RatesPolicy, class LinearSolverPolicy>
-  using SolverType = CudaRosenbrockSolver<RatesPolicy, LinearSolverPolicy>;
+ /// @brief Parameters for the CUDA Rosenbrock solver
+ struct CudaRosenbrockSolverParameters : public RosenbrockSolverParameters
+ {
+ template<class RatesPolicy, class LinearSolverPolicy>
+ using SolverType = CudaRosenbrockSolver<RatesPolicy, LinearSolverPolicy>;
 
-  /// @brief Constructor from base class
-  /// @param base
-  CudaRosenbrockSolverParameters(const RosenbrockSolverParameters& base)
-  : RosenbrockSolverParameters(base)
-  {
-  }
-  };
-}
+ /// @brief Constructor from base class
+ /// @param base
+ CudaRosenbrockSolverParameters(const RosenbrockSolverParameters& base)
+ : RosenbrockSolverParameters(base)
+ {
+ }
+ };
+} // namespace micm

include/micm/solver/jit_rosenbrock.hpp

@@ -37,7 +37,6 @@ namespace micm
  FuncPtr alpha_minus_jacobian_ = nullptr;
 
  public:
-
  /// @brief Solver parameters typename
  using ParametersType = JitRosenbrockSolverParameters;
 
@@ -70,11 +69,7 @@ namespace micm
  LinearSolverPolicy linear_solver,
  RatesPolicy rates,
  auto& jacobian)
- : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(
- parameters,
- std::move(linear_solver),
- std::move(rates),
- jacobian)
+ : RosenbrockSolver<RatesPolicy, LinearSolverPolicy>(parameters, std::move(linear_solver), std::move(rates), jacobian)
  {
  this->GenerateAlphaMinusJacobian(jacobian);
  }

include/micm/solver/jit_solver_builder.hpp

@@ -5,9 +5,10 @@
 #pragma once
 
 #include "solver_builder.hpp"
+
+#include <micm/process/jit_process_set.hpp>
 #include <micm/solver/jit_linear_solver.hpp>
 #include <micm/solver/jit_lu_decomposition.hpp>
-#include <micm/process/jit_process_set.hpp>
 
 namespace micm
 {
@@ -17,11 +18,10 @@ namespace micm
  ///
  /// JIT-compiled solvers only work with vector-ordered matrices
  template<class SolverParametersPolicy, std::size_t L = MICM_DEFAULT_VECTOR_SIZE>
- using JitSolverBuilder = SolverBuilder<SolverParametersPolicy,
- VectorMatrix<double, L>,
- SparseMatrix<double, SparseMatrixVectorOrdering<L>>,
- JitProcessSet<L>,
- JitLinearSolver<L,
- SparseMatrix<double, SparseMatrixVectorOrdering<L>>,
- JitLuDecomposition<L>>>;
-} // namespace micm
+ using JitSolverBuilder = SolverBuilder<
+ SolverParametersPolicy,
+ VectorMatrix<double, L>,
+ SparseMatrix<double, SparseMatrixVectorOrdering<L>>,
+ JitProcessSet<L>,
+ JitLinearSolver<L, SparseMatrix<double, SparseMatrixVectorOrdering<L>>, JitLuDecomposition<L>>>;
+} // namespace micm

include/micm/solver/jit_solver_parameters.hpp

@@ -5,23 +5,23 @@
 #pragma once
 
 #include "rosenbrock_solver_parameters.hpp"
-#include <micm/solver/rosenbrock_solver_parameters.hpp>
+
 #include <micm/solver/jit_rosenbrock.hpp>
+#include <micm/solver/rosenbrock_solver_parameters.hpp>
 
 namespace micm
 {
- /// @brief Parameters for the JIT Rosenbrock solver
- struct JitRosenbrockSolverParameters : public RosenbrockSolverParameters
- {
- template<class RatesPolicy, class LinearSolverPolicy>
- using SolverType = JitRosenbrockSolver<RatesPolicy, LinearSolverPolicy>;
-
- /// @brief Constructor from base class
- /// @param base
- JitRosenbrockSolverParameters(const RosenbrockSolverParameters& base)
- : RosenbrockSolverParameters(base)
- {
- }
+ /// @brief Parameters for the JIT Rosenbrock solver
+ struct JitRosenbrockSolverParameters : public RosenbrockSolverParameters
+ {
+ template<class RatesPolicy, class LinearSolverPolicy>
+ using SolverType = JitRosenbrockSolver<RatesPolicy, LinearSolverPolicy>;
 
- };
-}
+ /// @brief Constructor from base class
+ /// @param base
+ JitRosenbrockSolverParameters(const RosenbrockSolverParameters& base)
+ : RosenbrockSolverParameters(base)
+ {
+ }
+ };
+} // namespace micm

include/micm/solver/lu_decomposition.hpp

@@ -14,7 +14,7 @@ namespace
  t.NumColumns();
  t.NumberOfBlocks();
  };
-}
+} // namespace
 
 namespace micm
 {
@@ -93,21 +93,18 @@ namespace micm
  /// @brief Construct an LU decomposition algorithm for a given sparse matrix
  /// @param matrix Sparse matrix
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- LuDecomposition(const SparseMatrixPolicy& matrix);
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) LuDecomposition(const SparseMatrixPolicy& matrix);
 
  /// @brief Create an LU decomposition algorithm for a given sparse matrix policy
  /// @param matrix Sparse matrix
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- static LuDecomposition Create(const SparseMatrixPolicy& matrix);
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) static LuDecomposition Create(const SparseMatrixPolicy& matrix);
 
  /// @brief Create sparse L and U matrices for a given A matrix
  /// @param A Sparse matrix that will be decomposed
  /// @return L and U Sparse matrices
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- static std::pair<SparseMatrixPolicy, SparseMatrixPolicy> GetLUMatrices(
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) static std::pair<SparseMatrixPolicy, SparseMatrixPolicy> GetLUMatrices(
  const SparseMatrixPolicy& A,
  typename SparseMatrixPolicy::value_type initial_value);
 
@@ -116,8 +113,10 @@ namespace micm
  /// @param L The lower triangular matrix created by decomposition
  /// @param U The upper triangular matrix created by decomposition
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- void Decompose(const SparseMatrixPolicy& A, SparseMatrixPolicy& L, SparseMatrixPolicy& U) const;
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) void Decompose(
+ const SparseMatrixPolicy& A,
+ SparseMatrixPolicy& L,
+ SparseMatrixPolicy& U) const;
 
  /// @brief Perform an LU decomposition on a given A matrix
  /// @param A Sparse matrix to decompose
@@ -141,8 +140,7 @@ namespace micm
  /// @brief Initialize arrays for the LU decomposition
  /// @param A Sparse matrix to decompose
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- void Initialize(const SparseMatrixPolicy& matrix, auto initial_value);
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) void Initialize(const SparseMatrixPolicy& matrix, auto initial_value);
  };
 
 } // namespace micm

include/micm/solver/lu_decomposition.inl

@@ -9,24 +9,24 @@ namespace micm
  }
 
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- inline LuDecomposition::LuDecomposition(const SparseMatrixPolicy& matrix)
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) inline LuDecomposition::LuDecomposition(const SparseMatrixPolicy& matrix)
  {
  Initialize<SparseMatrixPolicy>(matrix, typename SparseMatrixPolicy::value_type());
  }
 
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- inline LuDecomposition LuDecomposition::Create(const SparseMatrixPolicy& matrix)
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) inline LuDecomposition LuDecomposition::Create(
+  const SparseMatrixPolicy& matrix)
  {
  LuDecomposition lu_decomp{};
  lu_decomp.Initialize<SparseMatrixPolicy>(matrix, typename SparseMatrixPolicy::value_type());
  return lu_decomp;
  }
 
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- inline void LuDecomposition::Initialize(const SparseMatrixPolicy& matrix, auto initial_value)
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) inline void LuDecomposition::Initialize(
+ const SparseMatrixPolicy& matrix,
+ auto initial_value)
  {
  MICM_PROFILE_FUNCTION();
 
@@ -102,10 +102,9 @@ namespace micm
  }
 
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- inline std::pair<SparseMatrixPolicy, SparseMatrixPolicy> LuDecomposition::GetLUMatrices(
- const SparseMatrixPolicy& A,
- typename SparseMatrixPolicy::value_type initial_value)
+ requires(
+ SparseMatrixConcept<SparseMatrixPolicy>) inline std::pair<SparseMatrixPolicy, SparseMatrixPolicy> LuDecomposition::
+ GetLUMatrices(const SparseMatrixPolicy& A, typename SparseMatrixPolicy::value_type initial_value)
  {
  MICM_PROFILE_FUNCTION();
 
@@ -165,8 +164,10 @@ namespace micm
  }
 
  template<class SparseMatrixPolicy>
- requires(SparseMatrixConcept<SparseMatrixPolicy>)
- inline void LuDecomposition::Decompose(const SparseMatrixPolicy& A, SparseMatrixPolicy& L, SparseMatrixPolicy& U) const
+ requires(SparseMatrixConcept<SparseMatrixPolicy>) inline void LuDecomposition::Decompose(
+ const SparseMatrixPolicy& A,
+ SparseMatrixPolicy& L,
+ SparseMatrixPolicy& U) const
  {
  bool is_singular = false;
  Decompose<SparseMatrixPolicy>(A, L, U, is_singular);