clang tidy issues solved

Author: salva24

.gitignore

@@ -121,4 +121,7 @@ doc/latex
 *.dat
 
 # Draft code for comparing models
-draft_code_my_own_analysis/
+draft_code_my_own_analysis/
+
+# Temporary files
+cout.txt

src/cart_cell.cc

@@ -24,6 +24,7 @@
 #include "tumor_cell.h"
 #include "utils_aux.h"
 #include "core/agent/agent.h"
+#include "core/agent/agent_pointer.h"
 #include "core/agent/new_agent_event.h"
 #include "core/container/math_array.h"
 #include "core/diffusion/diffusion_grid.h"
@@ -143,7 +144,7 @@ void CarTCell::ChangeVolumeExponentialRelaxationEquation(
 
 // compute Displacement
 Real3 CarTCell::CalculateDisplacement(const InteractionForce* force,
-                                      real_t squared_radius, real_t dt) {
+                                      real_t squared_radius, real_t /*dt*/) {
   auto* sim = Simulation::GetActive();
 
   // real_t h = dt;
@@ -167,7 +168,7 @@ Real3 CarTCell::CalculateDisplacement(const InteractionForce* force,
     // compute motility
     if (rng->Uniform(0.0, 1.0) < kMotilityProbability) {
       // random direction as unitary vector
-      Real3 random_direction = GenerateRandomDirection();
+      const Real3 random_direction = GenerateRandomDirection();
       Real3 direction_to_immunostimulatory_factor;
       // returns normalized gradient towards the immunostimulatory factor source
       immunostimulatory_factor_dgrid_->GetGradient(
@@ -179,8 +180,9 @@ Real3 CarTCell::CalculateDisplacement(const InteractionForce* force,
       // Convert to unit direction
       if (motility[0] * motility[0] + motility[1] * motility[1] +
               motility[2] * motility[2] >
-          0)
+          0) {
         motility.Normalize();
+      }
       // Scale by migration speed and add to the velocity
       translation_velocity_on_point_mass += motility * kMigrationSpeedCart;
     }
@@ -189,9 +191,10 @@ Real3 CarTCell::CalculateDisplacement(const InteractionForce* force,
   //--------------------------------------------
   // CAR-T killing or victim cell escaping
   //--------------------------------------------
-  if (state_ == CarTCellState::kAlive) {  // If cell is not apoptotic
-
-    if (attached_to_tumor_cell_) {  // attached to tumor cell
+  // If cell is not apoptotic
+  if (state_ == CarTCellState::kAlive) {
+    // if it is attached to tumor cell
+    if (attached_to_tumor_cell_) {
       // try to kill the cancer cell and in case of failure see if it manages to
       // scape the order needs to be this one because it should try to kill
       // before seeing if it scapes
@@ -210,7 +213,7 @@ Real3 CarTCell::CalculateDisplacement(const InteractionForce* force,
     //--------------------------------------------
     // Compute forces between the cells and check for a new attachment
     auto calculate_forces_and_elastic_displacement =
-        L2F([&](Agent* neighbor, real_t squared_distance) {
+        L2F([&](Agent* neighbor, real_t /*squared_distance*/) {
           // Adhesion repulsion forces between cells
           //  We check for every neighbor object if they touch us, i.e. push us
           //  away and aggregate the velocities
@@ -222,21 +225,21 @@ Real3 CarTCell::CalculateDisplacement(const InteractionForce* force,
           // CAR-T adhesion to new victim cell
           Real3 displac = neighbor->GetPosition() - current_position;
 
-          if (TumorCell* cancer_cell = dynamic_cast<TumorCell*>(neighbor)) {
+          if (auto* cancer_cell = dynamic_cast<TumorCell*>(neighbor)) {
             // movement towards the tumor cells
-            real_t sq_norm_displac = displac[0] * displac[0] +
-                                     displac[1] * displac[1] +
-                                     displac[2] * displac[2];
+            const real_t sq_norm_displac = displac[0] * displac[0] +
+                                           displac[1] * displac[1] +
+                                           displac[2] * displac[2];
 
             // The cart moves towards the tumor cell only if they are not
             // touching already If they are too close the only force affecting
             // is the adhesion force to avoid CAR-T non-stop pushing tumor
             // cells. In case of being closer than
-            // kMaxSquaredDistanceCartMovingTowardsTumorCell there is a
+            // gKMaxSquaredDistanceCartMovingTowardsTumorCell there is a
             // probability kProbabilityPushing for the CAR-T to keep pushing the
             // tumor cell
             if (sq_norm_displac >
-                kMaxSquaredDistanceCartMovingTowardsTumorCell) {
+                gKMaxSquaredDistanceCartMovingTowardsTumorCell) {
               translation_velocity_on_point_mass[0] +=
                   displac[0] * kElasticConstantCart;
               translation_velocity_on_point_mass[1] +=
@@ -247,8 +250,9 @@ Real3 CarTCell::CalculateDisplacement(const InteractionForce* force,
 
             // If the CAR-T has not succeeded in attaching to a tumor cell yet,
             // it tries again
-            if (!attached_to_tumor_cell_)
+            if (!attached_to_tumor_cell_) {
               TryToGetAttachedTo(cancer_cell, sq_norm_displac, rng);
+            }
           }
         });
     ctxt->ForEachNeighbor(calculate_forces_and_elastic_displacement, *this,
@@ -281,14 +285,14 @@ void CarTCell::TryToGetAttachedTo(TumorCell* victim, real_t squared_distance,
         (victim->GetOncoproteinLevel() - kOncoproteinLimit) /
         kOncoproteinDifference;
     // Clamp scale_factor to be in [0,1]
-    if (oncoprotein_scale_factor > 1.0)
+    if (oncoprotein_scale_factor > 1.0) {
       oncoprotein_scale_factor = 1.0;
+    }
     // If oncoprotein level is lower than the limit the cancer cell does not get
     // detected
     if (oncoprotein_scale_factor <= 0.0) {
-      oncoprotein_scale_factor = 0.0;
-      // the probability is going to be 0 so return the function is the most
-      // efficient
+      // oncoprotein_scale_factor = 0.0; the probability is going to be 0 so
+      // return the function is the most efficient
       return;
     }
 
@@ -298,8 +302,9 @@ void CarTCell::TryToGetAttachedTo(TumorCell* victim, real_t squared_distance,
         kDifferenceCartAdhesionDistances;
     // Clamp scale_factor to be in [0,1]. We already checked that it is > 0
     // because squared_distance < kSquaredMaxAdhesionDistanceCart
-    if (distance_scale_factor > 1.0)
+    if (distance_scale_factor > 1.0) {
       distance_scale_factor = 1.0;
+    }
 
     // It tries to attach the CAR-T cell to the tumor cell with probability
     // kAdhesionRateCart * oncoprotein_scale_factor * distance_scale_factor *
@@ -320,41 +325,41 @@ void CarTCell::TryToGetAttachedTo(TumorCell* victim, real_t squared_distance,
       }
     }
   }
-
-  return;
 }
 
 // Try to induce apoptosis
 bool CarTCell::TryToInduceApoptosis(bdm::AgentPointer<TumorCell> attached_cell,
-                                    Random* rng) {
+                                    Random* rng) const {
   // If there is no attached cell (this should not happen)
 
-  if (!attached_to_tumor_cell_)
+  if (!attached_to_tumor_cell_) {
     return false;
+  }
 
   // factor of how high is the oncoprotein levelof the cancer cell
   real_t scale_factor =
       (attached_cell->GetOncoproteinLevel() - kOncoproteinLimit) /
       kOncoproteinDifference;
   // Clamp scale_factor to be in [0,1]
-  if (scale_factor > 1.0)
+  if (scale_factor > 1.0) {
     scale_factor = 1.0;
+  }
   // If oncoprotein level is lower than the limit the cancer cell does not
   // become apoptotic
   if (scale_factor < 0.0) {
-    scale_factor = 0.0;
-    // the probability is going to be 0 so return the function is the most
-    // efficient
+    // scale_factor = 0.0; the probability is going to be 0 so return the
+    // function is the most efficient
     return false;
   }
   // CAR-T success of killing probability: aggressive cancer cells (high
   // oncoprotein level) are more likely to be killed
-  bool succeeded =
+  const bool succeeded =
       rng->Uniform(0.0, 1.0) < kKillRateCart * scale_factor * kDtMechanics;
 
   // The CAR-T has succeeded to induce apoptosis on the Cancer Cell
-  if (succeeded)
+  if (succeeded) {
     attached_cell->StartApoptosis();
+  }
 
   return succeeded;
 }

src/cart_cell.h

@@ -24,13 +24,15 @@
 
 #include "tumor_cell.h"
 #include "core/agent/agent.h"
+#include "core/agent/agent_pointer.h"
 #include "core/agent/cell.h"
 #include "core/agent/new_agent_event.h"
 #include "core/behavior/behavior.h"
 #include "core/container/math_array.h"
 #include "core/diffusion/diffusion_grid.h"
 #include "core/interaction_force.h"
 #include "core/real_t.h"
+#include "core/util/random.h"
 
 namespace bdm {
 
@@ -207,7 +209,7 @@ class CarTCell : public Cell {
   ///  @param rng Pointer to the random number generator
   ///  @return true if apoptosis was induced, false otherwise
   bool TryToInduceApoptosis(bdm::AgentPointer<TumorCell> attached_cell,
-                            Random* rng);
+                            Random* rng) const;
 
  private:
   /// Current state of the CAR-T cell

src/hyperparams.h

@@ -26,6 +26,7 @@
 #include "core/util/math.h"
 #include <cmath>
 #include <cstddef>
+#include <map>
 
 namespace bdm {
 
@@ -276,7 +277,12 @@ constexpr real_t kElasticConstantCart = 0.01;
 ///   - The value represents the number of CAR-T cells administered on that day.
 /// Example: On day 0 and day 8, 3957 CAR-T cells are introduced (matching the
 /// initial tumor cell count).
-inline std::map<size_t, size_t> kTreatment = {{0, 3957}, {8, 3957}};
+// FIXME: add this parameters in an external no recompiled file which will also
+// avoid cppcoreguidelines-avoid-magic-numbers warning
+inline const std::map<size_t, size_t> gKTreatment = {
+    {0, 3957},
+    {8,
+     3957}};  // NOLINT(cppcoreguidelines-avoid-magic-numbers,readability-magic-numbers)
 
 /// Do not modify this line:  1-kMigrationBiasCart
 constexpr real_t kMigrationOneMinusBiasCart = 1.0 - kMigrationBiasCart;
@@ -296,19 +302,19 @@ constexpr real_t kDifferenceCartAdhesionDistances =
     kMaxAdhesionDistanceCart - kMinAdhesionDistanceCart;
 
 /// Do not change this line: radius tumor cell
-const real_t kRadiusTumorCell =
+const real_t gKRadiusTumorCell =
     std::cbrt(kDefaultVolumeNewTumorCell * 3. / (4. * Math::kPi));
 
 /// Do not change this line: radius cart cell
-const real_t kRadiusCarTCell =
+const real_t gKRadiusCarTCell =
     std::cbrt(kDefaultVolumeNewCarTCell * 3. / (4. * Math::kPi));
 
 // Do not change this line: maximum squared distance to avoid CAR-T pushing
 // tumor cells If a CAR-T and a Tumor Cell are closer than this distance, the
 // CAR-T cell will only move to the tumor cell with the adhesion forces
 //(radiusCART + radiusTumorCell + 0.1 to avoid numerical errors)**2
-const real_t kMaxSquaredDistanceCartMovingTowardsTumorCell =
-    std::pow(kRadiusCarTCell + kRadiusTumorCell + 1, 2);
+const real_t gKMaxSquaredDistanceCartMovingTowardsTumorCell =
+    std::pow(gKRadiusCarTCell + gKRadiusTumorCell + 1, 2);
 
 }  // namespace bdm