FEAT: start timing at end of initialization

Author: aaronjridley

include/times.h

@@ -82,6 +82,11 @@ class Times {
    **/
   double get_current();
 
+  /**************************************************************
+     \brief Sets the start time at the start of the time loop
+   **/
+  void set_start_time_loop();
+
   /**************************************************************
      \brief Returns the end time in seconds since ref date
    **/
@@ -237,6 +242,9 @@ class Times {
   /// This is the system time at the start of the simulation
   time_t sys_time_start;
 
+  /// This is the system time at the start of time loop
+  time_t sys_time_start_time_loop;
+
   /// This is the current system time of the simulation
   time_t sys_time_current;
 

src/main/main.cpp

@@ -24,63 +24,70 @@ int main() {
   try {
     // Create inputs (reading the input file):
     input = Inputs(time);
+
     if (!input.is_ok())
       throw std::string("input initialization failed!");
 
     if (input.get_is_student())
       report.print(-1, "Hello " +
-		   input.get_student_name() + " - welcome to Aether!");
+                   input.get_student_name() + " - welcome to Aether!");
 
     Quadtree quadtree;
+
     if (!quadtree.is_ok())
       throw std::string("quadtree initialization failed!");
-    
+
     // Initialize MPI and parallel aspects of the code:
     didWork = init_parallel(quadtree);
+
     if (!didWork)
       throw std::string("init_parallel failed!");
 
     // Everything should be set for the inputs now, so write a restart file:
     didWork = input.write_restart();
+
     if (!didWork)
       throw std::string("input.write_restart failed!");
 
     // Initialize the EUV system:
     Euv euv;
+
     if (!euv.is_ok())
       throw std::string("EUV initialization failed!");
 
     // Initialize the planet:
     Planets planet;
     MPI_Barrier(aether_comm);
+
     if (!planet.is_ok())
       throw std::string("planet initialization failed!");
 
     // Initialize the indices, read the files, and perturb:
     Indices indices;
     didWork = read_and_store_indices(indices);
     MPI_Barrier(aether_comm);
+
     if (!didWork)
       throw std::string("read_and_store_indices failed!");
-    
+
     // Perturb the inputs if user has asked for this
     indices.perturb();
     MPI_Barrier(aether_comm);
-    
+
     // Initialize Geographic grid:
     Grid gGrid(input.get_nLonsGeo(),
-	       input.get_nLatsGeo(),
-	       input.get_nAltsGeo(),
-	       nGeoGhosts);
+               input.get_nLatsGeo(),
+               input.get_nAltsGeo(),
+               nGeoGhosts);
     didWork = gGrid.init_geo_grid(quadtree, planet);
     MPI_Barrier(aether_comm);
+
     if (!didWork)
-      throw std::string("init_geo_grid failed!");  
+      throw std::string("init_geo_grid failed!");
 
     // Find interpolation coefs for the ghostcells if cubesphere grid
     didWork = find_ghostcell_interpolation_coefs(gGrid);
 
-    
     // Calculate centripetal acceleration, since this is a constant
     // vector on the grid:
     if (input.get_cent_acc())
@@ -100,7 +107,7 @@ int main() {
     // Is simply adds nans and infinities in a few places, then
     // checks for them to make sure the checking is working
     // -----------------------------------------------------------------
-    
+
     if (input.get_nan_test()) {
       neutrals.nan_test(input.get_nan_test_variable());
       ions.nan_test(input.get_nan_test_variable());
@@ -128,22 +135,25 @@ int main() {
     // Initialize electrodynamics and check if electrodynamics times
     // works with input time
     Electrodynamics electrodynamics(time);
+
     if (!electrodynamics.is_ok())
       throw std::string("electrodynamics initialization failed!");
 
     // If the user wants to restart, then get the time of the restart
     if (input.get_do_restart()) {
       report.print(1, "Restarting! Reading time file!");
       didWork = time.restart_file(input.get_restartin_dir(), DoRead);
+
       if (!didWork)
-	throw std::string("Reading Restart for time Failed!!!\n");
+        throw std::string("Reading Restart for time Failed!!!\n");
     }
 
     // This is for the initial output.  If it is not a restart, this will go:
     if (time.check_time_gate(input.get_dt_output(0)))
       didWork = output(neutrals, ions, gGrid, time, planet);
+
     if (!didWork)
-      throw std::string("output failed!");  
+      throw std::string("output failed!");
 
     // This is advancing now... We are not coupling, so set dt_couple to the
     // end of the simulation
@@ -158,26 +168,30 @@ int main() {
     // be made into a library and run externally.
 
     Logfile logfile(indices);
+
+    time.set_start_time_loop();
+
     while (time.get_current() < time.get_end()) {
 
       time.increment_intermediate(dt_couple);
 
       // Increment until the intermediate time:
       while (time.get_current() < time.get_intermediate()) {
-	didWork = advance(planet,
-			  gGrid,
-			  time,
-			  euv,
-			  neutrals,
-			  ions,
-			  chemistry,
-			  electrodynamics,
-			  indices,
-			  logfile);
-	if (!didWork)
-	  throw std::string("Error in advance!");  
+        didWork = advance(planet,
+                          gGrid,
+                          time,
+                          euv,
+                          neutrals,
+                          ions,
+                          chemistry,
+                          electrodynamics,
+                          indices,
+                          logfile);
+
+        if (!didWork)
+          throw std::string("Error in advance!");
       }
-      
+
       // Should write out some restart files every time we are done with
       // intermediate times.  Just so when we restart, we know that we can
       // couple first thing and everything should be good. (Not sure if
@@ -189,19 +203,22 @@ int main() {
       // wrote out restart files, so we only need to do this if we
       // didn't just do it.  So, check the negative here:
       if (!time.check_time_gate(input.get_dt_write_restarts())) {
-	report.print(3, "Writing restart files");
+        report.print(3, "Writing restart files");
 
-	didWork = neutrals.restart_file(input.get_restartout_dir(), DoWrite);
-	if (!didWork)
-	  throw std::string("Writing Restart for Neutrals Failed!!!\n");	
+        didWork = neutrals.restart_file(input.get_restartout_dir(), DoWrite);
 
-	didWork = ions.restart_file(input.get_restartout_dir(), DoWrite);
-	if (!didWork)
-	  throw std::string("Writing Restart for Ions Failed!!!\n");	
+        if (!didWork)
+          throw std::string("Writing Restart for Neutrals Failed!!!\n");
 
-	didWork = time.restart_file(input.get_restartout_dir(), DoWrite);
-	if (!didWork)
-	  throw std::string("Writing Restart for time Failed!!!\n");	
+        didWork = ions.restart_file(input.get_restartout_dir(), DoWrite);
+
+        if (!didWork)
+          throw std::string("Writing Restart for Ions Failed!!!\n");
+
+        didWork = time.restart_file(input.get_restartout_dir(), DoWrite);
+
+        if (!didWork)
+          throw std::string("Writing Restart for time Failed!!!\n");
       }
 
       // Do some coupling here. But we have no coupling to do. Sad.
@@ -213,13 +230,14 @@ int main() {
 
   } catch (std::string error) {
     report.report_errors();
+
     if (iProc == 0) {
       std::cout << error << "\n";
       std::cout << "---- Must Exit! ----\n";
     }
   }
 
-    
+
   // End parallel tasks:
   iErr = MPI_Finalize();
 

src/time.cpp

@@ -30,6 +30,14 @@ Times::Times() {
   time(&sys_time_start);
 }
 
+// -----------------------------------------------------------------------------
+// This sets the end of the initialization time
+// -----------------------------------------------------------------------------
+
+void Times::set_start_time_loop() {
+  time(&sys_time_start_time_loop);
+}
+
 // -----------------------------------------------------------------------------
 // This is for restarting the code. Either write or read the time.
 // -----------------------------------------------------------------------------
@@ -279,7 +287,7 @@ void Times::display() {
   time(&sys_time_current);
   walltime =
     static_cast<double>(sys_time_current) -
-    static_cast<double>(sys_time_start);
+    static_cast<double>(sys_time_start_time_loop);
 
   double elapsed_simulation_time = current - restart;
   double total_simulation_time = end - restart;