Linter (#96)

* clang-format

* Update linter action

* Apply clang-format to all files and only trigger workflow on PR

* Add .clang-tidy and apply it

* Fix typo

* disable tidy checks

* Use .clang-tidy file

* Disable clang-tidy

.clang-tidy

@@ -0,0 +1,46 @@
+---
+Checks:          'clang-diagnostic-*,clang-analyzer-*,readability-braces-around-statements'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+AnalyzeTemporaryDtors: false
+FormatStyle:     none
+User:            user
+CheckOptions:
+  - key:             llvm-else-after-return.WarnOnConditionVariables
+    value:           'false'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             cert-str34-c.DiagnoseSignedUnsignedCharComparisons
+    value:           'false'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             cert-err33-c.CheckedFunctions
+    value:           '::aligned_alloc;::asctime_s;::at_quick_exit;::atexit;::bsearch;::bsearch_s;::btowc;::c16rtomb;::c32rtomb;::calloc;::clock;::cnd_broadcast;::cnd_init;::cnd_signal;::cnd_timedwait;::cnd_wait;::ctime_s;::fclose;::fflush;::fgetc;::fgetpos;::fgets;::fgetwc;::fopen;::fopen_s;::fprintf;::fprintf_s;::fputc;::fputs;::fputwc;::fputws;::fread;::freopen;::freopen_s;::fscanf;::fscanf_s;::fseek;::fsetpos;::ftell;::fwprintf;::fwprintf_s;::fwrite;::fwscanf;::fwscanf_s;::getc;::getchar;::getenv;::getenv_s;::gets_s;::getwc;::getwchar;::gmtime;::gmtime_s;::localtime;::localtime_s;::malloc;::mbrtoc16;::mbrtoc32;::mbsrtowcs;::mbsrtowcs_s;::mbstowcs;::mbstowcs_s;::memchr;::mktime;::mtx_init;::mtx_lock;::mtx_timedlock;::mtx_trylock;::mtx_unlock;::printf_s;::putc;::putwc;::raise;::realloc;::remove;::rename;::scanf;::scanf_s;::setlocale;::setvbuf;::signal;::snprintf;::snprintf_s;::sprintf;::sprintf_s;::sscanf;::sscanf_s;::strchr;::strerror_s;::strftime;::strpbrk;::strrchr;::strstr;::strtod;::strtof;::strtoimax;::strtok;::strtok_s;::strtol;::strtold;::strtoll;::strtoul;::strtoull;::strtoumax;::strxfrm;::swprintf;::swprintf_s;::swscanf;::swscanf_s;::thrd_create;::thrd_detach;::thrd_join;::thrd_sleep;::time;::timespec_get;::tmpfile;::tmpfile_s;::tmpnam;::tmpnam_s;::tss_create;::tss_get;::tss_set;::ungetc;::ungetwc;::vfprintf;::vfprintf_s;::vfscanf;::vfscanf_s;::vfwprintf;::vfwprintf_s;::vfwscanf;::vfwscanf_s;::vprintf_s;::vscanf;::vscanf_s;::vsnprintf;::vsnprintf_s;::vsprintf;::vsprintf_s;::vsscanf;::vsscanf_s;::vswprintf;::vswprintf_s;::vswscanf;::vswscanf_s;::vwprintf_s;::vwscanf;::vwscanf_s;::wcrtomb;::wcschr;::wcsftime;::wcspbrk;::wcsrchr;::wcsrtombs;::wcsrtombs_s;::wcsstr;::wcstod;::wcstof;::wcstoimax;::wcstok;::wcstok_s;::wcstol;::wcstold;::wcstoll;::wcstombs;::wcstombs_s;::wcstoul;::wcstoull;::wcstoumax;::wcsxfrm;::wctob;::wctrans;::wctype;::wmemchr;::wprintf_s;::wscanf;::wscanf_s;'
+  - key:             cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value:           'false'
+  - key:             cert-dcl16-c.NewSuffixes
+    value:           'L;LL;LU;LLU'
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           'true'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+  - key:             llvm-qualified-auto.AddConstToQualified
+    value:           'false'
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             llvm-else-after-return.WarnOnUnfixable
+    value:           'false'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+...
+

.github/workflows/cpp-linter.yml

@@ -1,28 +1,24 @@
-# Workflow syntax:
-# https://help.github.com/en/articles/workflow-syntax-for-github-actions
 name: cpp-linter
 
 on:
-  push:
-    paths-ignore: "docs/**"
   pull_request:
-    paths-ignore: "docs/**"
+    branches: [master]
 
 jobs:
   cpp-linter:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: shenxianpeng/cpp-linter-action@master
+      - uses: cpp-linter/cpp-linter-action@v2
         id: linter
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           style: file
+          tidy-checks: '-*'
 
       - name: Fail fast?!
         if: steps.linter.outputs.checks-failed > 0
         run: |
           echo "Some files failed the linting checks!"
-        # for actual deployment
-        # run: exit 1
+          exit 1

src/WallThickness/WallThicknessLib.cpp

@@ -78,36 +78,39 @@ double calculate_wall_thickness_plane(
          const std::vector<double> &a_vcritical,
          std::shared_ptr<Class_Potential_Origin> a_modelPointer,
          const double &a_Temp,
-         const int &a_WhichMinimizer) {
-        while (mDataIndex < a_BasePoints.size())
-        {
-          const auto data         = a_BasePoints.at(mDataIndex++);
-          auto MinimumPlaneResult = Minimizer::MinimizePlane(data.second,
-                                                             a_vevsymmetric,
-                                                             a_vcritical,
-                                                             a_modelPointer,
-                                                             a_Temp,
-                                                             a_WhichMinimizer);
-          {
-            std::unique_lock<std::mutex> lock(mWriteResultLock);
-            Data_min.at(data.first) = -MinimumPlaneResult.PotVal;
-          }
-        }
-      };
+         const int &a_WhichMinimizer)
+  {
+    while (mDataIndex < a_BasePoints.size())
+    {
+      const auto data         = a_BasePoints.at(mDataIndex++);
+      auto MinimumPlaneResult = Minimizer::MinimizePlane(data.second,
+                                                         a_vevsymmetric,
+                                                         a_vcritical,
+                                                         a_modelPointer,
+                                                         a_Temp,
+                                                         a_WhichMinimizer);
+      {
+        std::unique_lock<std::mutex> lock(mWriteResultLock);
+        Data_min.at(data.first) = -MinimumPlaneResult.PotVal;
+      }
+    }
+  };
 
   for (auto &thr : Data_min_threads)
   {
-    thr = std::thread([&]() {
-      thread_Job(DataIndex,
-                 BasePoints,
-                 Data_min_negative,
-                 WriteLock,
-                 vevsymmetric,
-                 vcritical,
-                 modelPointer,
-                 Temp,
-                 WhichMinimizer);
-    });
+    thr = std::thread(
+        [&]()
+        {
+          thread_Job(DataIndex,
+                     BasePoints,
+                     Data_min_negative,
+                     WriteLock,
+                     vevsymmetric,
+                     vcritical,
+                     modelPointer,
+                     Temp,
+                     WhichMinimizer);
+        });
   }
 
   for (auto &thr : Data_min_threads)

src/baryo_calculation/Fluid_Type/gen_calc.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2020  Philipp Basler, Margarete Mühlleitner and Jonas Müller
-// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller
+// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas
+// Müller
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 

src/baryo_calculation/Fluid_Type/top_source.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2020  Philipp Basler, Margarete Mühlleitner and Jonas Müller
-// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller
+// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas
+// Müller
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -68,14 +69,14 @@ void top_source::operator()(const state_type &omega,
       theta_vec[1]; // derivative of the phase factor of the top quark
   // Calculation of kappa_t
   Calc_kappa_obj.set_class(Temp, mt);
-  double num_int = NIntegrate_kappa(Calc_kappa_obj);
-  double kappa_q = kappa_QL_0 * num_int;  // left-handed kappa
+  double num_int  = NIntegrate_kappa(Calc_kappa_obj);
+  double kappa_q  = kappa_QL_0 * num_int; // left-handed kappa
   double kappa_tR = kappa_QR_0 * num_int; // right-handed kappa
 
   // Rescaled chemical potential like in 1811.11104
   double mu_M = (omega[1] / kappa_tR - omega[0] / kappa_q);
   double bR   = -(omega[1] + omega[0]); // local baryon conservation used to
-                                      // expresse the right-handed b density
+                                        // expresse the right-handed b density
   double mu_SS = 2 * omega[0] / kappa_q - omega[1] / kappa_tR - bR / kappa_QR_0;
   double mu_Y  = omega[1] / kappa_tR - omega[0] / kappa_q -
                 omega[2] / kappa_H_0 - omega[3] / kappa_H_0;

src/minimizer/LibCMAES/MinimizeLibCMAES.cpp

@@ -54,7 +54,8 @@ LibCMAESReturn min_cmaes_gen_all(const Class_Potential_Origin &model,
   // cmaparams.set_noisy();
   cmaparams.set_ftolerance(ftol);
 
-  FitFunc cmafunc = [&](const double *v, const int &N) {
+  FitFunc cmafunc = [&](const double *v, const int &N)
+  {
     (void)N;
     std::vector<double> vev;
     for (std::size_t i{0}; i < dim; ++i)
@@ -109,7 +110,8 @@ CMAES_Minimize_Plane_gen_all(const struct PointerContainerMinPlane &params,
   cmaparams.set_algo(aCMAES);
   cmaparams.set_ftolerance(ftol);
 
-  FitFunc CMAES_VEFF_Minimize_Plane = [=](const double *v, const int &N) {
+  FitFunc CMAES_VEFF_Minimize_Plane = [=](const double *v, const int &N)
+  {
     (void)N;
     std::size_t nVEVs = params.modelPointer->get_nVEV();
 

src/minimizer/Minfunc_gen.cpp

@@ -1,5 +1,6 @@
 // Copyright (C) 2018  Philipp Basler and Margarete Mühlleitner
-// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas Müller
+// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas
+// Müller
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 

src/minimizer/MinimizeGSL.cpp

@@ -200,7 +200,8 @@ GSL_Minimize_gen_all(const Class_Potential_Origin &model,
                        GSL_params &mparams,
                        std::mutex &mWriteResultLock,
                        std::queue<std::vector<double>> &mResults,
-                       bool UseLock = true) {
+                       bool UseLock = true)
+  {
     while (mFoundSolutions < mMaxSol and not mStartingPoints.empty())
     {
       std::vector<double> start;
@@ -234,14 +235,16 @@ GSL_Minimize_gen_all(const Class_Potential_Origin &model,
 
     for (std::size_t i = 0; i < Num_threads; ++i)
     {
-      MinThreads.push_back(std::thread([&]() {
-        thread_Job(FoundSolutions,
-                   MaxSol,
-                   StartingPoints,
-                   params,
-                   WriteResultLock,
-                   Results);
-      }));
+      MinThreads.push_back(std::thread(
+          [&]()
+          {
+            thread_Job(FoundSolutions,
+                       MaxSol,
+                       StartingPoints,
+                       params,
+                       WriteResultLock,
+                       Results);
+          }));
     }
 
     for (auto &thr : MinThreads)

src/minimizer/Minimizer.cpp

@@ -125,8 +125,9 @@ Minimize_gen_all(const std::shared_ptr<Class_Potential_Origin> &modelPointer,
     {
       if (UseMultithreading)
       {
-        thread_GSL =
-            std::thread([&solGSLMin, &gslMinSuc, &modelPointer, &Temp]() {
+        thread_GSL = std::thread(
+            [&solGSLMin, &gslMinSuc, &modelPointer, &Temp]()
+            {
               std::tie(solGSLMin, gslMinSuc) = GSL_Minimize_gen_all(
                   *modelPointer,
                   Temp,
@@ -146,7 +147,8 @@ Minimize_gen_all(const std::shared_ptr<Class_Potential_Origin> &modelPointer,
       if (UseMultithreading)
       {
         thread_GSL = std::thread(
-            [&solGSLMin, &gslMinSuc, &modelPointer, &Temp, &MaxSol]() {
+            [&solGSLMin, &gslMinSuc, &modelPointer, &Temp, &MaxSol]()
+            {
               std::tie(solGSLMin, gslMinSuc) =
                   GSL_Minimize_gen_all(*modelPointer, Temp, 5, MaxSol);
             });
@@ -165,9 +167,10 @@ Minimize_gen_all(const std::shared_ptr<Class_Potential_Origin> &modelPointer,
   {
     if (UseMultithreading)
     {
-      thread_CMAES = std::thread([&modelPointer, &Temp, &start, &LibCMAES]() {
-        LibCMAES = LibCMAES::min_cmaes_gen_all(*modelPointer, Temp, start);
-      });
+      thread_CMAES = std::thread(
+          [&modelPointer, &Temp, &start, &LibCMAES]() {
+            LibCMAES = LibCMAES::min_cmaes_gen_all(*modelPointer, Temp, start);
+          });
     }
     else
     {
@@ -185,9 +188,9 @@ Minimize_gen_all(const std::shared_ptr<Class_Potential_Origin> &modelPointer,
   {
     if (UseMultithreading)
     {
-      thread_NLopt = std::thread([&NLOPTResult, &modelPointer, &Temp]() {
-        NLOPTResult = LibNLOPT::MinimizeUsingNLOPT(*modelPointer, Temp);
-      });
+      thread_NLopt = std::thread(
+          [&NLOPTResult, &modelPointer, &Temp]()
+          { NLOPTResult = LibNLOPT::MinimizeUsingNLOPT(*modelPointer, Temp); });
     }
     else
     {
@@ -514,7 +517,8 @@ MinimaDevelopmentWithTemperature(
     }
   }
 
-  auto StoppingCriteria = [&](const double &Temp) {
+  auto StoppingCriteria = [&](const double &Temp)
+  {
     double epsilon = std::abs((FinalTemperature - StartingTemperature) /
                               StepsizeTemperature) *
                      1e-2; // because 1+1 = 2.0000000000000001

src/models/ClassPotentialC2HDM.cpp

@@ -2421,9 +2421,9 @@ void Class_Potential_C2HDM::TripleHiggsCouplings()
   }
   MatrixXd HiggsRotSort(NHiggs, NHiggs);
   int posMHCS1 = 0, posMHCS2 = 0;
-  int posN[3];
-  int countposN = 0;
-  int posG1 = 0, posG2 = 0, posG0 = 0;
+  std::vector<std::size_t> posN(3);
+  std::size_t countposN = 0;
+  std::size_t posG1 = 0, posG2 = 0, posG0 = 0;
   double testsum             = 0;
   const double ZeroThreshold = 1e-5;
   for (int i = 0; i < 3; i++)
@@ -2446,7 +2446,7 @@ void Class_Potential_C2HDM::TripleHiggsCouplings()
       testsum += std::abs(HiggsRot(i, k));
     if (testsum > ZeroThreshold)
     {
-      posN[countposN] = i;
+      posN.at(countposN) = i;
       countposN++;
     }
   }
@@ -2460,7 +2460,7 @@ void Class_Potential_C2HDM::TripleHiggsCouplings()
     double NeutralHiggs[3];
     for (int i = 0; i < 3; i++)
     {
-      NeutralHiggs[i] = HiggsMasses[posN[i]];
+      NeutralHiggs[i] = HiggsMasses[posN.at(i)];
     }
     for (int i = 0; i < 3; i++)
     {

src/models/ClassPotentialCPintheDark.cpp

@@ -2081,7 +2081,6 @@ void Class_Potential_CPintheDark::SetCurvatureArrays()
   V32 = C_Vts;
   V33 = C_Vtb;
 
-
   Curvature_Quark_F2H1[0][1][4]   = 0.1e1 / v1 * C_MassUp;
   Curvature_Quark_F2H1[0][1][5]   = -II / v1 * C_MassUp;
   Curvature_Quark_F2H1[0][3][0]   = 0.1e1 / v1 * C_MassDown * V11;

src/models/ClassPotentialCxSM.cpp

@@ -1091,7 +1091,6 @@ void Class_CxSM::SetCurvatureArrays()
   VC32 = std::conj(C_Vts);
   VC33 = std::conj(C_Vtb);
 
-
   Curvature_Lepton_F2H1[0][1][2] = II / vh * C_MassElectron;
   Curvature_Lepton_F2H1[0][1][3] = 0.1e1 / vh * C_MassElectron;
   Curvature_Lepton_F2H1[1][0][2] = II / vh * C_MassElectron;

src/models/ClassPotentialOrigin.cpp

@@ -304,19 +304,16 @@ double Class_Potential_Origin::fbaseTri(double MassSquaredA,
   else if (mas != 0 and mbs == 0 and mcs == 0)
   {
     C   = 2;
-    res = 1.0 / mas * (std::log(mas) - 1);
     res = 1.0 / mas * (LogA - 1);
   }
   else if (mas == 0 and mbs != 0 and mcs == 0)
   {
     C   = 3;
-    res = 1.0 / mbs * (std::log(mbs) - 1);
     res = (LogB - 1) / mbs;
   }
   else if (mas == 0 and mbs == 0 and mcs != 0)
   {
     C   = 4;
-    res = 1.0 / mcs * (std::log(mcs) - 1);
     res = (LogC - 1) / mcs;
   }
   else if (mas == mbs and mas != 0 and mas != mcs and mcs != 0)
@@ -3890,18 +3887,19 @@ double Class_Potential_Origin::CalculateRatioAlpha(
     const std::vector<double> &vev_broken,
     const double &Temp) const
 {
-  double res                          = 0;
-  double PotentialSymmetricPhaseValue = VEff(vev_symmetric, Temp, 0);
-  double PotentialSymmetricPhaseDeriv = VEff(vev_symmetric, Temp, -1);
-  double PotentialBrokenPhaseValue    = VEff(vev_broken, Temp, 0);
-  double PotentialBrokenPhaseDeriv    = VEff(vev_broken, Temp, -1);
-  res = -(PotentialBrokenPhaseValue - PotentialSymmetricPhaseValue) +
-        Temp * (PotentialBrokenPhaseDeriv - PotentialSymmetricPhaseDeriv);
+  (void)vev_symmetric;
+  (void)vev_broken;
+  (void)Temp;
+  //  double res                          = 0;
+  //  double PotentialSymmetricPhaseValue = VEff(vev_symmetric, Temp, 0);
+  //  double PotentialSymmetricPhaseDeriv = VEff(vev_symmetric, Temp, -1);
+  //  double PotentialBrokenPhaseValue    = VEff(vev_broken, Temp, 0);
+  //  double PotentialBrokenPhaseDeriv    = VEff(vev_broken, Temp, -1);
+  //  res = -(PotentialBrokenPhaseValue - PotentialSymmetricPhaseValue) +
+  //        Temp * (PotentialBrokenPhaseDeriv - PotentialSymmetricPhaseDeriv);
   // TODO:: Unfinished!
   throw std::runtime_error("The CalculateRatioAlpha function is not finished "
                            "and you should not be using it!");
-
-  return res;
 }
 
 std::vector<double> Class_Potential_Origin::MinimizeOrderVEV(