Clang tidy CI test: add misc-definitions-in-headers check (#4253)

* Clang-tidy: add misc-definitions-in-headers check

* address issues found with clang-tidy

* remove std::cout added for debug purposes

* add back newline

10 files changed, 190 insertions, 127 deletions

diff --git a/.clang-tidy b/.clang-tidy
index 2d495081c..5a3deadf3 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -18,6 +18,7 @@ Checks: '-*,
     google-build-namespaces,
     google-global-names-in-headers,
     misc-const-correctness,
+    misc-definitions-in-headers,
     misc-misleading-bidirectional,
     misc-misleading-identifier,
     misc-misplaced-const,
@@ -25,7 +26,6 @@ Checks: '-*,
     misc-unused-alias-decls,
     misc-unused-parameters,
     misc-unused-using-decls,
-        -misc-definitions-in-headers,
     modernize-avoid-bind,
     modernize-concat-nested-namespaces,
     modernize-deprecated-headers,
@@ -82,5 +82,7 @@ Checks: '-*,
 CheckOptions:
 - key:          modernize-pass-by-value.ValuesOnly
   value:        'true'
+- key:          misc-definitions-in-headers.HeaderFileExtensions
+  value:        "H,"
 
 HeaderFilterRegex: 'Source[a-z_A-Z0-9\/]+\.H$'
diff --git a/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/BesselRoots.H b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/BesselRoots.H
index 64ffc80ac..2285ab056 100644
--- a/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/BesselRoots.H
+++ b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/BesselRoots.H
@@ -32,14 +32,11 @@
 !                                          (www.jpmoreau.fr)
 ! ------------------------------------------------------------------------ */
 
-#include "Utils/WarpXConst.H"
+#ifndef WARPX_BESSEL_ROOTS_H_
+#define WARPX_BESSEL_ROOTS_H_
 
 #include <AMReX_REAL.H>
-
-#include <cmath>
-
-
-void SecantRootFinder(int n, int nitmx, amrex::Real tol, amrex::Real *zeroj, int *ier);
+#include <AMReX_Vector.H>
 
 /*----------------------------------------------------------------------
  *    calculate the first nk zeroes of bessel function j(n, x)
@@ -56,112 +53,6 @@ void SecantRootFinder(int n, int nitmx, amrex::Real tol, amrex::Real *zeroj, int
  *    abramowitz m. & stegun irene a.
  *    handbook of mathematical functions
  */
-void GetBesselRoots(int n, int nk, amrex::Vector<amrex::Real>& roots, amrex::Vector<int> &ier)  {
-    using namespace amrex::literals;
-
-    amrex::Real zeroj;
-    int ierror, ik, k;
-
-    const amrex::Real tol = 1e-14_rt;
-    const amrex::Real nitmx = 10;
-
-    const amrex::Real c1 = 1.8557571_rt;
-    const amrex::Real c2 = 1.033150_rt;
-    const amrex::Real c3 = 0.00397_rt;
-    const amrex::Real c4 = 0.0908_rt;
-    const amrex::Real c5 = 0.043_rt;
-
-    const amrex::Real t0 = 4.0_rt*n*n;
-    const amrex::Real t1 = t0 - 1.0_rt;
-    const amrex::Real t3 = 4.0_rt*t1*(7.0_rt*t0 - 31.0_rt);
-    const amrex::Real t5 = 32.0_rt*t1*((83.0_rt*t0 - 982.0_rt)*t0 + 3779.0_rt);
-    const amrex::Real t7 = 64.0_rt*t1*(((6949.0_rt*t0 - 153855.0_rt)*t0 + 1585743.0_rt)*t0 - 6277237.0_rt);
-
-    roots.resize(nk);
-    ier.resize(nk);
-
-    // first zero
-    if (n == 0) {
-        zeroj = c1 + c2 - c3 - c4 + c5;
-        SecantRootFinder(n, nitmx, tol, &zeroj, &ierror);
-        ier[0] = ierror;
-        roots[0] = zeroj;
-        ik = 1;
-    }
-    else {
-        // Include the trivial root
-        ier[0] = 0;
-        roots[0] = 0.;
-        const amrex::Real f1 = std::pow(n, (1.0_rt/3.0_rt));
-        const amrex::Real f2 = f1*f1*n;
-        const amrex::Real f3 = f1*n*n;
-        zeroj = n + c1*f1 + (c2/f1) - (c3/n) - (c4/f2) + (c5/f3);
-        SecantRootFinder(n, nitmx, tol, &zeroj, &ierror);
-        ier[1] = ierror;
-        roots[1] = zeroj;
-        ik = 2;
-    }
-
-    // other zeroes
-    // k counts the nontrivial roots
-    // ik counts all roots
-    k = 2;
-    while (ik < nk) {
-
-        // mac mahon's series for k >> n
-        const amrex::Real b0 = (k + 0.5_rt*n - 0.25_rt)*MathConst::pi;
-        const amrex::Real b1 = 8.0_rt*b0;
-        const amrex::Real b2 = b1*b1;
-        const amrex::Real b3 = 3.0_rt*b1*b2;
-        const amrex::Real b5 = 5.0_rt*b3*b2;
-        const amrex::Real b7 = 7.0_rt*b5*b2;
-
-        zeroj = b0 - (t1/b1) - (t3/b3) - (t5/b5) - (t7/b7);
-
-        const amrex::Real errj = std::abs(jn(n, zeroj));
-
-        // improve solution using procedure SecantRootFinder
-        if (errj > tol) SecantRootFinder(n, nitmx, tol, &zeroj, &ierror);
-
-        roots[ik] = zeroj;
-        ier[ik] = ierror;
-
-        k++;
-        ik++;
-    }
-}
-
-void SecantRootFinder(int n, int nitmx, amrex::Real tol, amrex::Real *zeroj, int *ier) {
-    using namespace amrex::literals;
-
-    amrex::Real p0, p1, q0, q1, dp, p;
-    amrex::Real c[2];
-
-    c[0] = 0.95_rt;
-    c[1] = 0.999_rt;
-    *ier = 0;
-
-    p = *zeroj;
-    for (int ntry=0 ; ntry <= 1 ; ntry++) {
-        p0 = c[ntry]*(*zeroj);
+void GetBesselRoots(int n, int nk, amrex::Vector<amrex::Real>& roots, amrex::Vector<int> &ier);
 
-        p1 = *zeroj;
-        q0 = jn(n, p0);
-        q1 = jn(n, p1);
-        for (int it=1; it <= nitmx; it++) {
-            if (q1 == q0) break;
-            p = p1 - q1*(p1 - p0)/(q1 - q0);
-            dp = p - p1;
-            if (it > 1 && std::abs(dp) < tol) {
-                *zeroj = p;
-                return;
-            }
-            p0 = p1;
-            q0 = q1;
-            p1 = p;
-            q1 = jn(n, p1);
-        }
-    }
-    *ier = 3;
-    *zeroj = p;
-}
+#endif // WARPX_BESSEL_ROOTS_H_
diff --git a/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/BesselRoots.cpp b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/BesselRoots.cpp
new file mode 100644
index 000000000..210a4baff
--- /dev/null
+++ b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/BesselRoots.cpp
@@ -0,0 +1,153 @@
+/* Copyright 2019 David Grote
+ *
+ * This file is part of WarpX.
+ *
+ * License: BSD-3-Clause-LBNL
+ */
+/* -------------------------------------------------------------------------
+! program to calculate the first zeroes (root abscissas) of the first
+! kind bessel function of integer order n using the subroutine rootj.
+! --------------------------------------------------------------------------
+! sample run:
+!
+! (calculate the first 10 zeroes of 1st kind bessel function of order 2).
+!
+! zeroes of bessel function of order: 2
+!
+! number of calculated zeroes: 10
+!
+! table of root abcissas (5 items per line)
+!    5.135622    8.417244   11.619841   14.795952   17.959819
+    21.116997   24.270112   27.420574   30.569204   33.716520
+!
+! table of error codes (5 items per line)
+!   0   0   0   0   0
+!   0   0   0   0   0
+!
+! --------------------------------------------------------------------------
+! reference: from numath library by tuan dang trong in fortran 77
+!            [bibli 18].
+!
+!                               c++ release 1.0 by j-p moreau, paris
+!                                          (www.jpmoreau.fr)
+! ------------------------------------------------------------------------ */
+
+#include "BesselRoots.H"
+
+#include "Utils/WarpXConst.H"
+
+#include <cmath>
+
+namespace{
+
+    void SecantRootFinder(int n, int nitmx, amrex::Real tol, amrex::Real *zeroj, int *ier) {
+        using namespace amrex::literals;
+
+        amrex::Real p0, p1, q0, q1, dp, p;
+        amrex::Real c[2];
+
+        c[0] = 0.95_rt;
+        c[1] = 0.999_rt;
+        *ier = 0;
+
+        p = *zeroj;
+        for (int ntry=0 ; ntry <= 1 ; ntry++) {
+            p0 = c[ntry]*(*zeroj);
+
+            p1 = *zeroj;
+            q0 = jn(n, p0);
+            q1 = jn(n, p1);
+            for (int it=1; it <= nitmx; it++) {
+                if (q1 == q0) break;
+                p = p1 - q1*(p1 - p0)/(q1 - q0);
+                dp = p - p1;
+                if (it > 1 && std::abs(dp) < tol) {
+                    *zeroj = p;
+                    return;
+                }
+                p0 = p1;
+                q0 = q1;
+                p1 = p;
+                q1 = jn(n, p1);
+            }
+        }
+        *ier = 3;
+        *zeroj = p;
+    }
+
+}
+
+void GetBesselRoots(int n, int nk, amrex::Vector<amrex::Real>& roots, amrex::Vector<int> &ier)  {
+    using namespace amrex::literals;
+
+    amrex::Real zeroj;
+    int ierror, ik, k;
+
+    const amrex::Real tol = 1e-14_rt;
+    const amrex::Real nitmx = 10;
+
+    const amrex::Real c1 = 1.8557571_rt;
+    const amrex::Real c2 = 1.033150_rt;
+    const amrex::Real c3 = 0.00397_rt;
+    const amrex::Real c4 = 0.0908_rt;
+    const amrex::Real c5 = 0.043_rt;
+
+    const amrex::Real t0 = 4.0_rt*n*n;
+    const amrex::Real t1 = t0 - 1.0_rt;
+    const amrex::Real t3 = 4.0_rt*t1*(7.0_rt*t0 - 31.0_rt);
+    const amrex::Real t5 = 32.0_rt*t1*((83.0_rt*t0 - 982.0_rt)*t0 + 3779.0_rt);
+    const amrex::Real t7 = 64.0_rt*t1*(((6949.0_rt*t0 - 153855.0_rt)*t0 + 1585743.0_rt)*t0 - 6277237.0_rt);
+
+    roots.resize(nk);
+    ier.resize(nk);
+
+    // first zero
+    if (n == 0) {
+        zeroj = c1 + c2 - c3 - c4 + c5;
+        ::SecantRootFinder(n, nitmx, tol, &zeroj, &ierror);
+        ier[0] = ierror;
+        roots[0] = zeroj;
+        ik = 1;
+    }
+    else {
+        // Include the trivial root
+        ier[0] = 0;
+        roots[0] = 0.;
+        const amrex::Real f1 = std::pow(n, (1.0_rt/3.0_rt));
+        const amrex::Real f2 = f1*f1*n;
+        const amrex::Real f3 = f1*n*n;
+        zeroj = n + c1*f1 + (c2/f1) - (c3/n) - (c4/f2) + (c5/f3);
+        ::SecantRootFinder(n, nitmx, tol, &zeroj, &ierror);
+        ier[1] = ierror;
+        roots[1] = zeroj;
+        ik = 2;
+    }
+
+    // other zeroes
+    // k counts the nontrivial roots
+    // ik counts all roots
+    k = 2;
+    while (ik < nk) {
+
+        // mac mahon's series for k >> n
+        const amrex::Real b0 = (k + 0.5_rt*n - 0.25_rt)*MathConst::pi;
+        const amrex::Real b1 = 8.0_rt*b0;
+        const amrex::Real b2 = b1*b1;
+        const amrex::Real b3 = 3.0_rt*b1*b2;
+        const amrex::Real b5 = 5.0_rt*b3*b2;
+        const amrex::Real b7 = 7.0_rt*b5*b2;
+
+        zeroj = b0 - (t1/b1) - (t3/b3) - (t5/b5) - (t7/b7);
+
+        const amrex::Real errj = std::abs(jn(n, zeroj));
+
+        // improve solution using procedure SecantRootFinder
+        if (errj > tol) ::SecantRootFinder(n, nitmx, tol, &zeroj, &ierror);
+
+        roots[ik] = zeroj;
+        ier[ik] = ierror;
+
+        k++;
+        ik++;
+    }
+}
diff --git a/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/CMakeLists.txt b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/CMakeLists.txt
index a3d2b60bc..70c974036 100644
--- a/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/CMakeLists.txt
+++ b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/CMakeLists.txt
@@ -1,5 +1,6 @@
 target_sources(lib_rz
   PRIVATE
+    BesselRoots.cpp
     SpectralHankelTransformer.cpp
     HankelTransform.cpp
 )
diff --git a/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/Make.package b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/Make.package
index 8bb1d7ef7..37ca9a931 100644
--- a/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/Make.package
+++ b/Source/FieldSolver/SpectralSolver/SpectralHankelTransform/Make.package
@@ -1,3 +1,4 @@
+CEXE_sources += BesselRoots.cpp
 CEXE_sources += SpectralHankelTransformer.cpp
 CEXE_sources += HankelTransform.cpp
 
diff --git a/Source/Initialization/InjectorMomentum.H b/Source/Initialization/InjectorMomentum.H
index 87b81381c..b0afafa73 100644
--- a/Source/Initialization/InjectorMomentum.H
+++ b/Source/Initialization/InjectorMomentum.H
@@ -94,6 +94,7 @@ namespace {
       * @param u_th Momentum spread
       * @param engine Object used to generate random numbers
       */
+    AMREX_FORCE_INLINE
     AMREX_GPU_HOST_DEVICE
     amrex::Real
     generateGaussianFluxDist( amrex::Real u_m, amrex::Real u_th, amrex::RandomEngine const& engine ) {
diff --git a/Source/Particles/Sorting/CMakeLists.txt b/Source/Particles/Sorting/CMakeLists.txt
index d3c378e43..60a156f46 100644
--- a/Source/Particles/Sorting/CMakeLists.txt
+++ b/Source/Particles/Sorting/CMakeLists.txt
@@ -3,5 +3,6 @@ foreach(D IN LISTS WarpX_DIMS)
     target_sources(lib_${SD}
       PRIVATE
         Partition.cpp
+        SortingUtils.cpp
     )
 endforeach()
diff --git a/Source/Particles/Sorting/Make.package b/Source/Particles/Sorting/Make.package
index 16efc02b8..e6ad1604d 100644
--- a/Source/Particles/Sorting/Make.package
+++ b/Source/Particles/Sorting/Make.package
@@ -1,2 +1,4 @@
 CEXE_sources += Partition.cpp
+CEXE_sources += SortingUtils.cpp
+
 VPATH_LOCATIONS   += $(WARPX_HOME)/Source/Particles/Sorting
diff --git a/Source/Particles/Sorting/SortingUtils.H b/Source/Particles/Sorting/SortingUtils.H
index 0bec92d6e..dd53ad6f6 100644
--- a/Source/Particles/Sorting/SortingUtils.H
+++ b/Source/Particles/Sorting/SortingUtils.H
@@ -19,18 +19,7 @@
  *
  * \param[inout] v Vector of integers, to be filled by this routine
  */
-void fillWithConsecutiveIntegers( amrex::Gpu::DeviceVector<long>& v )
-{
-#ifdef AMREX_USE_GPU
-    // On GPU: Use amrex
-    auto data = v.data();
-    auto N = v.size();
-    AMREX_FOR_1D( N, i, {data[i] = i;});
-#else
-    // On CPU: Use std library
-    std::iota( v.begin(), v.end(), 0L );
-#endif
-}
+void fillWithConsecutiveIntegers( amrex::Gpu::DeviceVector<long>& v );
 
 /** \brief Find the indices that would reorder the elements of `predicate`
  * so that the elements with non-zero value precede the other elements
diff --git a/Source/Particles/Sorting/SortingUtils.cpp b/Source/Particles/Sorting/SortingUtils.cpp
new file mode 100644
index 000000000..699119e8e
--- /dev/null
+++ b/Source/Particles/Sorting/SortingUtils.cpp
@@ -0,0 +1,22 @@
+/* Copyright 2019-2020 Andrew Myers, Maxence Thevenet, Remi Lehe
+ * Weiqun Zhang
+ *
+ * This file is part of WarpX.
+ *
+ * License: BSD-3-Clause-LBNL
+ */
+
+#include "SortingUtils.H"
+
+void fillWithConsecutiveIntegers( amrex::Gpu::DeviceVector<long>& v )
+{
+#ifdef AMREX_USE_GPU
+    // On GPU: Use amrex
+    auto data = v.data();
+    auto N = v.size();
+    AMREX_FOR_1D( N, i, {data[i] = i;});
+#else
+    // On CPU: Use std library
+    std::iota( v.begin(), v.end(), 0L );
+#endif
+}