Remove more root() (#1184)

* Remove more root()

* Delete some more debug indirections

* Style

include/LinearSolver.h

@@ -182,7 +182,6 @@ class LinearSolver
    */
   virtual void destroyLinearSolver() = 0;
 
-  Simulation* root();
   LinearSolvers* parent();
   LinearSolvers* linearSolvers_;
 

include/NaluEnv.h

@@ -30,7 +30,6 @@ class NaluEnv
   ~NaluEnv();
 
   static NaluEnv& self();
-
   MPI_Comm parallelCommunicator_;
   int pSize_;
   int pRank_;
@@ -42,13 +41,15 @@ class NaluEnv
   NaluEmptyStreamBuffer naluEmptyStreamBuffer_;
   std::filebuf naluStreamBuffer_;
   std::filebuf naluParallelStreamBuffer_;
+  bool debug_;
 
   std::ostream& naluOutputP0();
   std::ostream& naluOutput();
 
   MPI_Comm parallel_comm();
   int parallel_size();
   int parallel_rank();
+  bool debug() { return debug_; }
 
   /** Redirect output to a log file
    *

include/Realm.h

@@ -120,7 +120,6 @@ class Realm
   Realms* parent() const;
   Realms* parent();
 
-  bool debug() const;
   bool get_activate_memory_diagnostic();
   void provide_memory_summary();
   std::string convert_bytes(double bytes);

include/Simulation.h

@@ -43,8 +43,6 @@ class Simulation
   void high_level_banner();
   Simulation* root() { return this; }
   Simulation* parent() { return 0; }
-  bool debug() { return debug_; }
-  bool debug() const { return debug_; }
   void setSerializedIOGroupSize(int siogs);
   static stk::diag::TimerSet& rootTimerSet();
   static stk::diag::Timer& rootTimer();
@@ -56,7 +54,6 @@ class Simulation
   Transfers* transfers_;
   LinearSolvers* linearSolvers_;
 
-  static bool debug_;
   int serializedIOGroupSize_;
 
 private:

nalu.C

@@ -188,7 +188,7 @@ main(int argc, char** argv)
         << std::endl;
       sim.setSerializedIOGroupSize(serializedIOGroupSize);
     }
-    sim.debug_ = debug;
+    naluEnv.debug_ = debug;
     sim.load(doc);
     sim.breadboard();
     sim.initialize();

src/EquationSystems.C

@@ -115,7 +115,7 @@ EquationSystems::load(const YAML::Node& y_node)
 
         if (expect_map(y_system, "LowMachEOM", true)) {
           y_eqsys = expect_map(y_system, "LowMachEOM", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0()
               << "eqSys = LowMachEOM " << std::endl;
           bool elemCont = (realm_.realmUsesEdges_) ? false : true;
@@ -132,34 +132,34 @@ EquationSystems::load(const YAML::Node& y_node)
         } else if (expect_map(y_system, "VolumeOfFluid", true)) {
 
           y_eqsys = expect_map(y_system, "VolumeOfFluid", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0()
               << "eqSys = VolumeOfFluid" << std::endl;
           eqSys = new VolumeOfFluidEquationSystem(*this);
 
         } else if (expect_map(y_system, "ShearStressTransport", true)) {
           y_eqsys = expect_map(y_system, "ShearStressTransport", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0() << "eqSys = tke/sdr " << std::endl;
           eqSys = new ShearStressTransportEquationSystem(*this);
         } else if (expect_map(y_system, "ChienKEpsilon", true)) {
           y_eqsys = expect_map(y_system, "ChienKEpsilon", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0() << "eqSys = tke/tdr " << std::endl;
           eqSys = new ChienKEpsilonEquationSystem(*this);
         } else if (expect_map(y_system, "WilcoxKOmega", true)) {
           y_eqsys = expect_map(y_system, "WilcoxKOmega", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0() << "eqSys = tke/sdr " << std::endl;
           eqSys = new WilcoxKOmegaEquationSystem(*this);
         } else if (expect_map(y_system, "TurbKineticEnergy", true)) {
           y_eqsys = expect_map(y_system, "TurbKineticEnergy", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0() << "eqSys = tke " << std::endl;
           eqSys = new TurbKineticEnergyEquationSystem(*this);
         } else if (expect_map(y_system, "Enthalpy", true)) {
           y_eqsys = expect_map(y_system, "Enthalpy", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0() << "eqSys = enthalpy " << std::endl;
           double minT = 250.0;
           double maxT = 3000.0;
@@ -171,7 +171,7 @@ EquationSystems::load(const YAML::Node& y_node)
           eqSys = new EnthalpyEquationSystem(*this, minT, maxT, ouputClipDiag);
         } else if (expect_map(y_system, "HeatConduction", true)) {
           y_eqsys = expect_map(y_system, "HeatConduction", true);
-          if (root()->debug())
+          if (NaluEnv::self().debug())
             NaluEnv::self().naluOutputP0()
               << "eqSys = HeatConduction " << std::endl;
 #ifdef NALU_HAS_MATRIXFREE

src/LinearSolver.C

@@ -50,17 +50,6 @@
 namespace sierra {
 namespace nalu {
 
-Simulation*
-LinearSolver::root()
-{
-  return linearSolvers_->root();
-}
-LinearSolvers*
-LinearSolver::parent()
-{
-  return linearSolvers_;
-}
-
 #ifdef NALU_USES_TRILINOS_SOLVERS
 
 TpetraLinearSolver::TpetraLinearSolver(

src/LinearSolvers.C

@@ -44,17 +44,6 @@ LinearSolvers::~LinearSolvers()
 #endif
 }
 
-Simulation*
-LinearSolvers::root()
-{
-  return &sim_;
-}
-Simulation*
-LinearSolvers::parent()
-{
-  return root();
-}
-
 void
 LinearSolvers::load(const YAML::Node& node)
 {

src/LinearSystem.C

@@ -93,7 +93,7 @@ LinearSystem::get_timer_precond()
 bool
 LinearSystem::debug()
 {
-  if (linearSolver_ && linearSolver_->root() && linearSolver_->root()->debug())
+  if (NaluEnv::self().debug())
     return true;
   return false;
 }

src/NaluEnv.C

@@ -37,7 +37,8 @@ NaluEnv::NaluEnv()
     stdoutStream_(std::cout.rdbuf()),
     naluLogStream_(new std::ostream(std::cout.rdbuf())),
     naluParallelStream_(new std::ostream(&naluParallelStreamBuffer_)),
-    parallelLog_(false)
+    parallelLog_(false),
+    debug_(false)
 {
   // initialize
   MPI_Comm_size(parallelCommunicator_, &pSize_);

src/Realm.C

@@ -331,12 +331,6 @@ Realm::breadboard()
   equationSystems_.breadboard();
 }
 
-bool
-Realm::debug() const
-{
-  return root()->debug_;
-}
-
 //--------------------------------------------------------------------------
 //-------- get_activate_memory_diagnostic ----------------------------------
 //--------------------------------------------------------------------------
@@ -847,7 +841,7 @@ Realm::load(const YAML::Node& node)
     NaluEnv::self().naluOutputP0()
       << "===========================" << std::endl;
     initialConditions_ =
-      InitialConditionCreator(debug()).create_ic_vector(node);
+      InitialConditionCreator(NaluEnv::self().debug()).create_ic_vector(node);
     NaluEnv::self().naluOutputP0() << std::endl;
     NaluEnv::self().naluOutputP0()
       << "Material Prop Review:      " << std::endl;
@@ -2345,7 +2339,7 @@ Realm::provide_entity_count()
 void
 Realm::delete_edges()
 {
-  if (debug()) {
+  if (NaluEnv::self().debug()) {
     std::vector<size_t> counts;
     stk::mesh::comm_mesh_counts(*bulkData_, counts);
 
@@ -2360,7 +2354,7 @@ Realm::delete_edges()
   std::vector<stk::mesh::Entity> edges;
   stk::mesh::get_selected_entities(*edgesPart_, edge_buckets, edges);
 
-  if (debug()) {
+  if (NaluEnv::self().debug()) {
     size_t sz = edges.size(), g_sz = 0;
     stk::all_reduce_sum(NaluEnv::self().parallel_comm(), &sz, &g_sz, 1);
     NaluEnv::self().naluOutputP0()
@@ -2448,7 +2442,7 @@ Realm::delete_edges()
   }
   bulkData_->modification_end();
 
-  if (debug()) {
+  if (NaluEnv::self().debug()) {
     std::vector<size_t> counts;
     stk::mesh::comm_mesh_counts(*bulkData_, counts);
 

src/Simulation.C

@@ -37,7 +37,6 @@ namespace nalu {
 //--------------------------------------------------------------------------
 //-------- destructor ------------------------------------------------------
 //--------------------------------------------------------------------------
-bool Simulation::debug_ = false;
 
 Simulation::Simulation(const YAML::Node& root_node)
   : m_root_node(root_node),

src/TpetraLinearSystem.C

@@ -1812,7 +1812,7 @@ TpetraLinearSystem::solve(stk::mesh::FieldBase* linearSolutionField)
   TpetraLinearSolver* linearSolver =
     reinterpret_cast<TpetraLinearSolver*>(linearSolver_);
 
-  if (realm_.debug()) {
+  if (NaluEnv::self().debug()) {
     checkForNaN(true);
     if (checkForZeroRow(true, false, true)) {
       throw std::runtime_error("ERROR checkForZeroRow in solve()");

src/TpetraSegregatedLinearSystem.C

@@ -1589,7 +1589,7 @@ TpetraSegregatedLinearSystem::solve(stk::mesh::FieldBase* linearSolutionField)
   TpetraLinearSolver* linearSolver =
     reinterpret_cast<TpetraLinearSolver*>(linearSolver_);
 
-  if (realm_.debug()) {
+  if (NaluEnv::self().debug()) {
     checkForNaN(true);
     if (checkForZeroRow(true, false, true)) {
       throw std::runtime_error("ERROR checkForZeroRow in solve()");

src/TurbKineticEnergyEquationSystem.C

@@ -919,7 +919,7 @@ TurbKineticEnergyEquationSystem::update_and_clip()
   ngpTke.modify_on_device();
 
   // parallel assemble clipped value
-  if (realm_.debug()) {
+  if (NaluEnv::self().debug()) {
     size_t g_numClip = 0;
     stk::ParallelMachine comm = NaluEnv::self().parallel_comm();
     stk::all_reduce_sum(comm, &numClip, &g_numClip, 1);