Use nullptr in HydroForces and remove using namespace from added_mass header

Author: dav-og

include/hydroc/coupling/added_mass.h

@@ -21,8 +21,6 @@
 #include <chrono/physics/ChLoad.h>
 #include <chrono/physics/ChSystem.h>
 
-using namespace chrono;
-
 // =============================================================================
 class ChLoadAddedMass : public chrono::ChLoadCustomMultiple {
   public:
@@ -39,8 +37,8 @@ class ChLoadAddedMass : public chrono::ChLoadCustomMultiple {
      * @param system pointer to system containing the bodies, used for getting system mass matrix size at any time.
      */
     ChLoadAddedMass(const std::vector<HydroData::BodyInfo>& body_info_struct,
-                    std::vector<std::shared_ptr<ChLoadable>>& bodies,
-                    ChSystem* system);
+                    std::vector<std::shared_ptr<chrono::ChLoadable>>& bodies,
+                    chrono::ChSystem* system);
 
     /**
      * @brief "Virtual" copy constructor (covariant return type). Required from chrono inheritance.
@@ -56,8 +54,8 @@ class ChLoadAddedMass : public chrono::ChLoadCustomMultiple {
      * Called automatically at each Update().
      * The M*a term is not added: to this end one could use LoadIntLoadResidual_Mv afterward.
      */
-    virtual void ComputeQ(ChState* state_x,      ///< state position to evaluate Q
-                          ChStateDelta* state_w  ///< state speed to evaluate Q
+    virtual void ComputeQ(chrono::ChState* state_x,      ///< state position to evaluate Q
+                          chrono::ChStateDelta* state_w  ///< state speed to evaluate Q
                           ) override {}
 
     /**
@@ -71,7 +69,7 @@ class ChLoadAddedMass : public chrono::ChLoadCustomMultiple {
      * @param state_x state position to evaluate jacobians
      * @param state_w state speed to evaluate jacobians
      */
-    virtual void ComputeJacobian(ChState* state_x, ChStateDelta* state_w) override;
+    virtual void ComputeJacobian(chrono::ChState* state_x, chrono::ChStateDelta* state_w) override;
 
     /**
      * @brief Computes LoadIntLoadResidual_Mv for vector w, const c, and vector R. Also carried over from chrono
@@ -84,12 +82,14 @@ class ChLoadAddedMass : public chrono::ChLoadCustomMultiple {
      * @param w the w vector
      * @param c a scaling factor
      */
-    virtual void LoadIntLoadResidual_Mv(ChVectorDynamic<>& R, const ChVectorDynamic<>& w, const double c) override;
+    virtual void LoadIntLoadResidual_Mv(chrono::ChVectorDynamic<>& R,
+                                        const chrono::ChVectorDynamic<>& w,
+                                        const double c) override;
 
   private:
-    ChSystem* system;
-    ChMatrixDynamic<double> infinite_added_mass;  ///< added mass at infinite frequency in global coordinates
-    ChMatrixDynamic<double>
+    chrono::ChSystem* system;
+    chrono::ChMatrixDynamic<double> infinite_added_mass;  ///< added mass at infinite frequency in global coordinates
+    chrono::ChMatrixDynamic<double>
         infinite_added_mass_system;  ///< added mass at infinite frequency in global coordinates (system matrix)
     virtual bool IsStiff() override { return true; }  // this to force the use of the inertial M, R and K matrices
 };

src/hydro/chrono/added_mass.cpp

@@ -12,6 +12,8 @@
 
 #include "chrono/physics/ChBody.h"
 
+using namespace chrono;
+
 ChLoadAddedMass::ChLoadAddedMass(const std::vector<HydroData::BodyInfo>& user_h5_body_data,
                                  std::vector<std::shared_ptr<ChLoadable>>& bodies,
                                  ChSystem* system)

src/hydro/hydro_forces.cpp

@@ -27,6 +27,7 @@
 
 // Chrono includes needed for implementation (not exposed in public header)
 #include <chrono/physics/ChLoad.h>
+#include <chrono/physics/ChLoadable.h>
 #include <chrono/physics/ChBodyEasy.h>
 #include <chrono/physics/ChLoadsBody.h>
 #include <chrono/physics/ChSystemNSC.h>
@@ -62,6 +63,7 @@ using chrono::ChBody;
 using chrono::ChBodyEasyMesh;
 using chrono::ChForce;
 using chrono::ChFunction;
+using chrono::ChLoadable;
 using chrono::ChLoadContainer;
 using chrono::ChSolver;
 using chrono::ChSystem;
@@ -106,7 +108,7 @@ std::vector<double> Linspace(double start, double end, int num_points) {
 
 // TODO reorder ComponentFunc implementation functions to match the header order of functions
 ComponentFunc::ComponentFunc() {
-    base_  = NULL;
+    base_  = nullptr;
     index_ = kDofPerBody;
 }
 
@@ -122,7 +124,7 @@ ComponentFunc::ComponentFunc(const ComponentFunc& old) {
 }
 
 double ComponentFunc::GetVal(double x) const {
-    if (base_ == NULL) {
+    if (base_ == nullptr) {
         std::cout << "base == Null!" << std::endl;
         return 0;
     }
@@ -156,7 +158,7 @@ ForceFunc6d::ForceFunc6d(std::shared_ptr<ChBody> object, HydroForces* user_all_f
     b_num_            = stoi(temp.erase(0, 4));  // 1-indexed body number
 
     all_hydro_forces_ = user_all_forces;
-    if (all_hydro_forces_ == NULL) {
+    if (all_hydro_forces_ == nullptr) {
         std::cout << "all hydro forces null " << std::endl;
     }
     SetForce();
@@ -194,7 +196,7 @@ double ForceFunc6d::CoordinateFunc(int i) {
 }
 
 void ForceFunc6d::SetForce() {
-    if (chrono_force_ == NULL || body_ == NULL) {
+    if (chrono_force_ == nullptr || body_ == nullptr) {
         std::cout << "set force null issue" << std::endl;
     }
     chrono_force_->SetF_x(force_ptrs_[0]);
@@ -203,7 +205,7 @@ void ForceFunc6d::SetForce() {
 }
 
 void ForceFunc6d::SetTorque() {
-    if (chrono_torque_ == NULL || body_ == NULL) {
+    if (chrono_torque_ == nullptr || body_ == nullptr) {
         std::cout << "set torque null issue" << std::endl;
     }
     chrono_torque_->SetF_x(force_ptrs_[3]);