fix some clang-tidy issues in nse_net / hybrj (AMReX-Astro#1624)

zingale · web-flow · commit ed95f6edb305 · 2024-07-20T15:19:22.000-04:00
diff --git a/nse_solver/nse_solver.H b/nse_solver/nse_solver.H
@@ -123,7 +123,7 @@ void compute_coulomb_contribution(amrex::Array1D<amrex::Real, 1, NumSpec>& u_c,
         // see appendix of Calder 2007, doi:10.1086/510709 for more detail
 
         // reuse existing implementation from screening routine
-        amrex::Real f = chabrier1998_helmholtz_F<amrex::Real>(gamma);
+        auto f = chabrier1998_helmholtz_F<amrex::Real>(gamma);
 
         //
         // Here u_c is a dimensionless quantity.
diff --git a/unit_test/test_nse_net/burn_cell.H b/unit_test/test_nse_net/burn_cell.H
@@ -87,7 +87,6 @@ void burn_cell_c()
     eos(eos_input_rt, eos_state);
 
     amrex::Real abar_start = eos_state.abar;
-    amrex::Real e_start = eos_state.e;
 
     // now perturb e and find the T/abar that are consistent with it
     // and NSE
diff --git a/util/hybrj/hybrj.H b/util/hybrj/hybrj.H
@@ -108,7 +108,7 @@ void hybrj(hybrj_t<neqs>& hj,
 
         if (iter == 1) {
             if (hj.mode != 2) {
-                for (int j = 1; j <= hj.n; ++j) {
+                for (int j = 1; j <= neqs; ++j) {
                     hj.diag(j) = hj.wa2(j);
                     if (hj.wa2(j) == 0.0_rt) {
                         hj.diag(j) = 1.0_rt;
@@ -122,7 +122,7 @@ void hybrj(hybrj_t<neqs>& hj,
             for (int j = 1; j <= neqs; ++j) {
                 hj.wa3(j) = hj.diag(j) * hj.x(j);
             }
-            xnorm = enorm(hj.n, hj.wa3);
+            xnorm = enorm(neqs, hj.wa3);
             delta =  factor * xnorm;
             if (delta == 0.0_rt) {
                 delta = factor;
@@ -131,17 +131,17 @@ void hybrj(hybrj_t<neqs>& hj,
 
         // form (q transpose)*fvec and store in qtf.
 
-        for (int i = 1; i <= hj.n; ++i) {
+        for (int i = 1; i <= neqs; ++i) {
             hj.qtf(i) = hj.fvec(i);
         }
         for (int j = 1; j <= neqs; ++j) {
             if (hj.fjac(j,j) != 0.0_rt) {
                 amrex::Real sum = 0.0_rt;
-                for (int i = j; i <= hj.n; ++i) {
+                for (int i = j; i <= neqs; ++i) {
                     sum += hj.fjac(i,j) * hj.qtf(i);
                 }
                 amrex::Real temp = -sum / hj.fjac(j,j);
-                for (int i = j; i <= hj.n; ++i) {
+                for (int i = j; i <= neqs; ++i) {
                     hj.qtf(i) += hj.fjac(i,j) * temp;
                 }
             }
@@ -151,7 +151,7 @@ void hybrj(hybrj_t<neqs>& hj,
 
         bool sing = false;
 
-        for (int j = 1; j <= hj.n; ++j) {
+        for (int j = 1; j <= neqs; ++j) {
             int l = j;
             int jm1 = j - 1;
             if (jm1 >= 1) {
@@ -173,7 +173,7 @@ void hybrj(hybrj_t<neqs>& hj,
         // rescale if necessary.
 
         if (hj.mode != 2) {
-            for (int j = 1; j <= hj.n; ++j) {
+            for (int j = 1; j <= neqs; ++j) {
                 hj.diag(j) = amrex::max(hj.diag(j), hj.wa2(j));
             }
         }
@@ -207,7 +207,7 @@ void hybrj(hybrj_t<neqs>& hj,
                 hj.wa3(j) = hj.diag(j) * hj.wa1(j);
             }
 
-            amrex::Real pnorm = enorm(hj.n, hj.wa3);
+            amrex::Real pnorm = enorm(neqs, hj.wa3);
 
             // on the first iteration, adjust the initial step bound.
 
@@ -225,7 +225,7 @@ void hybrj(hybrj_t<neqs>& hj,
                 break;
             }
 
-            amrex::Real fnorm1 = enorm(hj.n, hj.wa4);
+            amrex::Real fnorm1 = enorm(neqs, hj.wa4);
 
             // compute the scaled actual reduction.
 
@@ -237,15 +237,15 @@ void hybrj(hybrj_t<neqs>& hj,
             // compute the scaled predicted reduction.
 
             int l = 1;
-            for (int i = 1; i <= hj.n; ++i) {
+            for (int i = 1; i <= neqs; ++i) {
                 amrex::Real sum = 0.0_rt;
                 for (int j = i; j <= neqs; ++j) {
                     sum += hj.r(l) * hj.wa1(j);
                     l += 1;
                 }
                 hj.wa3(i) = hj.qtf(i) + sum;
             }
-            amrex::Real temp = enorm(hj.n, hj.wa3);
+            amrex::Real temp = enorm(neqs, hj.wa3);
             amrex::Real prered = 0.0_rt;
             if (temp < fnorm) {
                 prered = 1.0_rt - amrex::Math::powi<2>(temp/fnorm);
@@ -282,13 +282,13 @@ void hybrj(hybrj_t<neqs>& hj,
 
                 // successful iteration. update x, fvec, and their norms.
 
-                for (int j = 1; j <= hj.n; ++j) {
+                for (int j = 1; j <= neqs; ++j) {
                     hj.x(j) = hj.wa2(j);
                     hj.wa2(j) = hj.diag(j) * hj.x(j);
                     hj.fvec(j) = hj.wa4(j);
                 }
 
-                xnorm = enorm(hj.n, hj.wa2);
+                xnorm = enorm(neqs, hj.wa2);
                 fnorm = fnorm1;
                 iter++;
             }
@@ -348,9 +348,9 @@ void hybrj(hybrj_t<neqs>& hj,
               break;
             }
 
-            for (int j = 1; j <= hj.n; ++j) {
+            for (int j = 1; j <= neqs; ++j) {
                 amrex::Real sum = 0.0_rt;
-                for (int i = 1; i <= hj.n; ++i) {
+                for (int i = 1; i <= neqs; ++i) {
                     sum += hj.fjac(i,j) * hj.wa4(i);
                 }
                 hj.wa2(j) = (sum - hj.wa3(j)) / pnorm;
diff --git a/util/hybrj/hybrj_dogleg.H b/util/hybrj/hybrj_dogleg.H
@@ -43,9 +43,9 @@
 
 template<int neqs>
 AMREX_GPU_HOST_DEVICE AMREX_INLINE
-void dogleg(amrex::Array1D<amrex::Real, 1, neqs * (neqs + 1) / 2>& r,
-            amrex::Array1D<amrex::Real, 1, neqs>& diag,
-            amrex::Array1D<amrex::Real, 1, neqs>& qtb,
+void dogleg(const amrex::Array1D<amrex::Real, 1, neqs * (neqs + 1) / 2>& r,
+            const amrex::Array1D<amrex::Real, 1, neqs>& diag,
+            const amrex::Array1D<amrex::Real, 1, neqs>& qtb,
             amrex::Real delta,
             amrex::Array1D<amrex::Real, 1, neqs>& x,
             amrex::Array1D<amrex::Real, 1, neqs>& wa1,
diff --git a/util/hybrj/hybrj_enorm.H b/util/hybrj/hybrj_enorm.H
@@ -24,12 +24,12 @@
 
 template<int neqs>
 AMREX_GPU_HOST_DEVICE AMREX_INLINE
-amrex::Real enorm(const int n, amrex::Array1D<amrex::Real, 1, neqs>& x) {
+amrex::Real enorm(const int n, const amrex::Array1D<amrex::Real, 1, neqs>& x) {
 
     // note: n <= neqs
 
-    const amrex::Real rdwarf = 3.834e-20_rt;
-    const amrex::Real rgiant = 1.304e19_rt;
+    constexpr amrex::Real rdwarf = 3.834e-20_rt;
+    constexpr amrex::Real rgiant = 1.304e19_rt;
 
     amrex::Real s1 = 0.0_rt;
     amrex::Real s2 = 0.0_rt;
diff --git a/util/hybrj/hybrj_type.H b/util/hybrj/hybrj_type.H
@@ -16,24 +16,20 @@ using namespace amrex::literals;
 // maxfev is a positive integer input variable. termination
 // occurs when the number of calls to fcn with iflag = 1
 // has reached maxfev.
-const int maxfev = 1000;
+constexpr int maxfev = 1000;
 
 // factor is a positive input variable used in determining the
 // initial step bound. this bound is set to the product of
 // factor and the euclidean norm of diag*x if nonzero, or else
 // to factor itself. in most cases factor should lie in the
 // interval (.1,100.). 100. is a generally recommended value.
-const amrex::Real factor = 100.0_rt;
+constexpr amrex::Real factor = 100.0_rt;
 
 template<int neqs>
 struct hybrj_t {
 
     static_assert(neqs > 0);
 
-    // n is a positive integer input variable set to the number
-    // of functions and variables.
-    const int n = neqs;
-
     // x is an array of length n. on input x must contain
     // an initial estimate of the solution vector. on output x
     // contains the final estimate of the solution vector.
diff --git a/util/microphysics_sort.H b/util/microphysics_sort.H
@@ -19,7 +19,7 @@ bool compare(const T& a, const T& b, const bool ascending=true) {
 
 template <typename T>
 AMREX_GPU_HOST_DEVICE AMREX_INLINE
-void swap(T& a, T& b) {
+void swap(T& a, T& b) noexcept {
     // Helper function for sorting functions
     // Swaps the position of the two input
 
