tidy and formatted (2nd try)

Author: salva24

src/cart_cell.cc

@@ -20,6 +20,7 @@
  */
 
 #include <algorithm>
+#include <cmath>
 #include <cstdint>
 #include <stdexcept>
 #include <string>
@@ -35,7 +36,6 @@
 #include "core/real_t.h"
 #include "core/resource_manager.h"
 #include "core/util/log.h"
-#include "core/util/root.h"
 
 #include "cart_cell.h"
 #include "hyperparams.h"
@@ -44,25 +44,7 @@
 
 namespace bdm {
 
-CartCell::CartCell(const Real3& position)
-    : state_(CartCellState::kAlive),
-      timer_state_(0),
-      oxygen_dgrid_(nullptr),
-      immunostimulatory_factor_dgrid_(nullptr),
-      attached_to_tumor_cell_(false),
-      current_live_time_(kAverageMaximumTimeUntillApoptosisCart),
-      fluid_fraction_(kDefaultFractionFluidCartCell),
-      nuclear_volume_(kDefaultVolumeNucleusCartCell),
-      target_cytoplasm_solid_(0.0),
-      target_nucleus_solid_(0.0),
-      target_fraction_fluid_(0.0),
-      target_relation_cytoplasm_nucleus_(0.0),
-      older_velocity_({0, 0, 0}),
-      oxygen_consumption_rate_(kDefaultOxygenConsumption),
-      immunostimulatory_factor_secretion_rate_(0.0),
-      constant1_oxygen_(0.0),
-      constant2_oxygen_(0.0),
-      attached_cell_(nullptr) {
+CartCell::CartCell(const Real3& position) {
   SetPosition(position);
   SetVolume(kDefaultVolumeNewCartCell);
   const ResourceManager& rm = *Simulation::GetActive()->GetResourceManager();
@@ -89,7 +71,7 @@ real_t CartCell::GetTargetTotalVolume() const {
 // convergence
 // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
 void CartCell::ChangeVolumeExponentialRelaxationEquation(
-    real_t relaxation_rate_cytoplasm, real_t relaxation_rate_nucleus,
+    real_t relaxation_rate_cytoplasm, real_t relaxation_rate_nucleus,  // NOLINT
     real_t relaxation_rate_fluid) {
   // Exponential relaxation towards the target volume
   const real_t current_total_volume = GetVolume();
@@ -144,7 +126,7 @@ void CartCell::ChangeVolumeExponentialRelaxationEquation(
   const real_t new_volume = new_total_solid + new_fluid;
 
   // Avoid division by zero
-  real_t new_fraction_fluid = new_fluid / (kEpsilon + new_volume);
+  const real_t new_fraction_fluid = new_fluid / (kEpsilon + new_volume);
 
   // Update the cell's properties
   // if the volume has changed
@@ -174,7 +156,7 @@ Real3 CartCell::CalculateDisplacement(const InteractionForce* force,
   // We check for every neighbor object if they touch us, i.e. push us
   // away and agreagate the velocities
 
-  uint64_t non_zero_neighbor_forces = 0;
+  uint64_t non_zero_neighbor_forces = 0;  // NOLINT
   if (!IsStatic()) {
     auto* ctxt = Simulation::GetActive()->GetExecutionContext();
     auto calculate_neighbor_forces =
@@ -212,7 +194,7 @@ Real3 CartCell::CalculateDisplacement(const InteractionForce* force,
 // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
 real_t CartCell::ConsumeSecreteSubstance(int substance_id,
                                          real_t old_concentration) {
-  real_t res = NAN;
+  real_t res = NAN;  // NOLINT
   if (substance_id == oxygen_dgrid_->GetContinuumId()) {
     // consuming oxygen
     res = (old_concentration + constant1_oxygen_) / constant2_oxygen_;

src/cart_cell.h

@@ -23,14 +23,11 @@
 #define CART_CELL_H_
 
 #include "core/agent/agent.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/root.h"
 
 #include "tumor_cell.h"
 
@@ -62,8 +59,7 @@ class CartCell : public Cell {
   CartCell() = default;
   explicit CartCell(const Real3& position);
 
-  // Copy and move constructors/destructors (assignment operators are deleted by
-  // base class)
+  // Copy and move constructors/destructors/assignment operators
   CartCell(const CartCell&) = default;
   CartCell(CartCell&&) = default;
   ~CartCell() override = default;
@@ -153,7 +149,8 @@ class CartCell : public Cell {
   /// @param relaxation_rate_fluid Relaxation rate for fluid volume changes
   void ChangeVolumeExponentialRelaxationEquation(
       real_t relaxation_rate_cytoplasm, real_t relaxation_rate_nucleus,
-      real_t relaxation_rate_fluid);
+      real_t
+          relaxation_rate_fluid);  // NOLINT(bugprone-easily-swappable-parameters)
 
   /// Calculate displacement of the cell
   ///
@@ -272,10 +269,11 @@ struct StateControlCart : public Behavior {
 
   StateControlCart() { AlwaysCopyToNew(); }
 
-  // Copy and move constructors/destructors (assignment operators handled by
-  // base class)
+  // Special member functions
   StateControlCart(const StateControlCart&) = default;
   StateControlCart(StateControlCart&&) = default;
+  StateControlCart& operator=(const StateControlCart&) = default;
+  StateControlCart& operator=(StateControlCart&&) = default;
   ~StateControlCart() override = default;
 
   /// Execute the state control behavior

src/diffusion_thomas_algorithm.cc

@@ -27,7 +27,6 @@
 #include "core/agent/agent.h"
 #include "core/diffusion/diffusion_grid.h"
 #include "core/real_t.h"
-#include "core/util/root.h"
 
 #include "cart_cell.h"
 #include "diffusion_thomas_algorithm.h"
@@ -36,15 +35,15 @@
 
 namespace bdm {
 
-// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
-DiffusionThomasAlgorithm::DiffusionThomasAlgorithm(int substance_id,
+DiffusionThomasAlgorithm::DiffusionThomasAlgorithm(int substance_id,  // NOLINT
                                                    std::string substance_name,
                                                    real_t dc, real_t mu,
-                                                   int resolution, real_t dt,
+                                                   real_t resolution, real_t dt,
                                                    bool dirichlet_border)
     : DiffusionGrid(substance_id, std::move(substance_name), dc, mu,
-                    resolution),
-      resolution_(static_cast<size_t>(GetResolution())),
+                    static_cast<int>(
+                        resolution)),  // Added cast for consistency with parent
+      resolution_(GetResolution()),
       d_space_(static_cast<real_t>(kBoundedSpaceLength) /
                static_cast<real_t>(resolution_)),
       dirichlet_border_(dirichlet_border),
@@ -88,7 +87,8 @@ void DiffusionThomasAlgorithm::InitializeThomasAlgorithmVectors(
 
 // Apply Dirichlet boundary conditions to the grid
 void DiffusionThomasAlgorithm::ApplyDirichletBoundaryConditions() {
-  const real_t origin = GetDimensionsPtr()
+  const auto* dimensions_ptr = GetDimensionsPtr();
+  const real_t origin = dimensions_ptr
       [0];  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
   const real_t simulated_time = GetSimulatedTime();
 #pragma omp parallel
@@ -165,14 +165,10 @@ void DiffusionThomasAlgorithm::ApplyDirichletBoundaryConditions() {
 
 // Sets the concentration at a specific voxel
 void DiffusionThomasAlgorithm::SetConcentration(size_t idx, real_t amount) {
-  const auto* all_concentrations =
-      GetAllConcentrations();  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-  ChangeConcentrationBy(
-      idx,
-      amount -
-          all_concentrations
-              [idx],  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-      InteractionMode::kAdditive, false);
+  const auto* all_concentrations = GetAllConcentrations();
+  const real_t current_concentration = all_concentrations[idx];
+  ChangeConcentrationBy(idx, amount - current_concentration,
+                        InteractionMode::kAdditive, false);
 }
 
 // Flattens the 3D coordinates (x, y, z) into a 1D index
@@ -223,16 +219,29 @@ void DiffusionThomasAlgorithm::ApplyBoundaryConditionsIfNeeded() {
 }
 
 void DiffusionThomasAlgorithm::SolveDirectionThomas(unsigned int direction) {
-  const auto& thomas_denom = (direction == 0)   ? thomas_denom_x_
-                             : (direction == 1) ? thomas_denom_y_
-                                                : thomas_denom_z_;
-  const auto& thomas_c = (direction == 0)   ? thomas_c_x_
-                         : (direction == 1) ? thomas_c_y_
-                                            : thomas_c_z_;
-  const unsigned int jump =
-      (direction == 0)   ? static_cast<unsigned int>(jump_i_)
-      : (direction == 1) ? static_cast<unsigned int>(jump_j_)
-                         : static_cast<unsigned int>(jump_k_);
+  const auto& thomas_denom = [this, direction]() -> const std::vector<real_t>& {
+    if (direction == 0)
+      return thomas_denom_x_;
+    if (direction == 1)
+      return thomas_denom_y_;
+    return thomas_denom_z_;
+  }();
+
+  const auto& thomas_c = [this, direction]() -> const std::vector<real_t>& {
+    if (direction == 0)
+      return thomas_c_x_;
+    if (direction == 1)
+      return thomas_c_y_;
+    return thomas_c_z_;
+  }();
+
+  const unsigned int jump = [this, direction]() -> unsigned int {
+    if (direction == 0)
+      return static_cast<unsigned int>(jump_i_);
+    if (direction == 1)
+      return static_cast<unsigned int>(jump_j_);
+    return static_cast<unsigned int>(jump_k_);
+  }();
 
 #pragma omp parallel for collapse(2)
   for (unsigned int outer = 0; outer < resolution_; outer++) {
@@ -246,55 +255,46 @@ void DiffusionThomasAlgorithm::SolveDirectionThomas(unsigned int direction) {
   }
 }
 
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
 void DiffusionThomasAlgorithm::ForwardElimination(
     unsigned int direction, unsigned int outer, unsigned int middle,
     const std::vector<real_t>& thomas_denom, unsigned int jump) {
   // Get initial index based on direction
   size_t ind = GetLoopIndex(direction, outer, middle, 0);
-  const auto* all_concentrations =
-      GetAllConcentrations();  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-  SetConcentration(
-      ind,
-      all_concentrations[ind] /
-          thomas_denom
-              [0]);  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+  const auto* all_concentrations = GetAllConcentrations();
+  const real_t initial_concentration = all_concentrations[ind];
+  SetConcentration(ind, initial_concentration / thomas_denom[0]);
 
   // Forward elimination loop
   for (unsigned int inner = 1; inner < resolution_; inner++) {
     ind = GetLoopIndex(direction, outer, middle, inner);
-    SetConcentration(
-        ind,
-        (all_concentrations
-             [ind] +  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-         constant1_ *
-             all_concentrations
-                 [ind -
-                  jump]) /  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-            thomas_denom[inner]);
+    const real_t current_concentration = all_concentrations[ind];
+    const real_t prev_concentration = all_concentrations[ind - jump];
+    SetConcentration(ind,
+                     (current_concentration + constant1_ * prev_concentration) /
+                         thomas_denom[inner]);
   }
 }
 
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
 void DiffusionThomasAlgorithm::BackSubstitution(
     unsigned int direction, unsigned int outer, unsigned int middle,
     const std::vector<real_t>& thomas_c, unsigned int jump) {
-  const auto* all_concentrations =
-      GetAllConcentrations();  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+  const auto* all_concentrations = GetAllConcentrations();
 
   // Back substitution loop
   for (int inner = static_cast<int>(resolution_) - 2; inner >= 0; inner--) {
-    size_t ind = GetLoopIndex(direction, outer, middle,
-                              static_cast<unsigned int>(inner));
+    const size_t ind = GetLoopIndex(direction, outer, middle,
+                                    static_cast<unsigned int>(inner));
+    const real_t current_concentration = all_concentrations[ind];
+    const real_t next_concentration = all_concentrations[ind + jump];
     SetConcentration(
-        ind,
-        all_concentrations
-                [ind] -  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-            thomas_c[static_cast<size_t>(inner)] *
-                all_concentrations
-                    [ind +
-                     jump]);  // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+        ind, current_concentration -
+                 thomas_c[static_cast<size_t>(inner)] * next_concentration);
   }
 }
 
+// NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
 size_t DiffusionThomasAlgorithm::GetLoopIndex(unsigned int direction,
                                               unsigned int outer,
                                               unsigned int middle,

src/diffusion_thomas_algorithm.h

@@ -49,16 +49,10 @@ class DiffusionThomasAlgorithm : public DiffusionGrid {
         constant1a_(0.0),
         constant2_(0.0),
         constant3_(0.0),
-        constant3a_(0.0),
-        thomas_c_x_(),
-        thomas_denom_x_(),
-        thomas_c_y_(),
-        thomas_denom_y_(),
-        thomas_c_z_(),
-        thomas_denom_z_() {}
+        constant3a_(0.0) {}
 
   DiffusionThomasAlgorithm(int substance_id, std::string substance_name,
-                           real_t dc, real_t mu, int resolution, real_t dt,
+                           real_t dc, real_t mu, real_t resolution, real_t dt,
                            bool dirichlet_border);
 
   /// Concentration setters

src/forces_tumor_cart.cc

@@ -22,7 +22,10 @@
 #include <algorithm>
 #include <cmath>
 
+#include "core/agent/agent.h"
+#include "core/agent/cell.h"
 #include "core/container/math_array.h"
+#include "core/interaction_force.h"
 #include "core/real_t.h"
 
 #include "forces_tumor_cart.h"
@@ -112,10 +115,11 @@ Real4 InteractionVelocity::Calculate(const Agent* lhs, const Agent* rhs) const {
 
     // std::cout << "temp_a = " << temp_a << std::endl;// Debug output
 
-    real_t adhesion;
-    if (a_tumor && b_tumor) {  // two tumor cells
+    real_t adhesion = NAN;                               // Initialize to NAN
+    if ((a_tumor != nullptr) && (b_tumor != nullptr)) {  // two tumor cells
       adhesion = kAdhesionTumorTumor;
-    } else if (!a_tumor && !b_tumor) {  // two CAR-T cells
+    } else if ((a_tumor == nullptr) &&
+               (b_tumor == nullptr)) {  // two CAR-T cells
       adhesion = kAdhesionCartCart;
     } else {  // one tumor cell and one CAR-T
       adhesion = std::sqrt(kAdhesionCartTumor * kAdhesionTumorCart);
@@ -133,7 +137,7 @@ Real4 InteractionVelocity::Calculate(const Agent* lhs, const Agent* rhs) const {
   if (std::abs(temp_r) < kEpsilon) {
     return {0.0, 0.0, 0.0, 0.0};
   }
-  real_t force_magnitude = temp_r / distance;
+  const real_t force_magnitude = temp_r / distance;
 
   // Debug Output volcities
   // std::ofstream file("output/intercation_velocities.csv", std::ios::app);