Clean up plots logging messages

Refs: NOAA-EMC#1

Author: malloryprow

ush/global_det/global_det_atmos_plots.py

@@ -202,8 +202,8 @@
             for v in range(len(fcst_var_prod)):
                 var_info.append((fcst_var_prod[v], obs_var_prod[v]))
         else:
-            logger.error("FORECAST AND OBSERVATION VARIABLE INFORMATION NOT THE "
-                         +"SAME LENGTH")
+            logger.error("Forecast and observation variable information not "
+                         +"the same length")
             sys.exit(1)
 
 
@@ -334,7 +334,7 @@
                                        DATAjob_filter_stats_model_file)
                 else:
                     all_model_df = gda_util.build_df(
-                        logger, DATAjob, DATAjob,
+                        JOB_GROUP, logger, DATAjob, DATAjob,
                         model_info_dict, met_info_dict,
                         plot_info_dict['fcst_var_name'],
                         plot_info_dict['fcst_var_level'],
@@ -360,7 +360,7 @@
                                            COMOUTjob_filter_stats_model_file)
 elif JOB_GROUP == 'make_plots':
     if len(model_list) > 10:
-        logger.error("TOO MANY MODELS LISTED ("+str(len(model_list))
+        logger.error("Too many models requested ("+str(len(model_list))
                      +", ["+', '.join(model_list)+"]), maximum is 10")
         sys.exit(1)
     plot_specs = PlotSpecs(logger, plot)
@@ -813,7 +813,8 @@
                         gda_util.copy_file(DATAjob_image_name,
                                            COMOUTjob_image_name)
     else:
-        logger.warning(plot+" not recongized")
+        logger.error(plot+" not recongized")
+        sys.exit(1)
 elif JOB_GROUP == 'tar_images':
     cwd = os.getcwd()
     tar_file = os.path.join(
@@ -833,7 +834,8 @@
             gda_util.run_shell_command(['tar', '-cvf', tar_file, '*'])
             os.chdir(cwd)
         else:
-            logger.warning(f"No images generated in {DATAjob}")
+            logger.warning(f"No images generated in {DATAjob}, "
+                           +"cannot make tar file")
     if KEEPDATA != 'YES':
         if os.path.exists(DATAjob):
             logger.info(f"Removing {DATAjob}")

ush/global_det/global_det_atmos_plots_lead_average.py

@@ -25,7 +25,7 @@
 
 class LeadAverage:
     """
-    Create a lead average graphic
+    Make a lead average graphic
     """
 
     def __init__(self, logger, input_dir, output_dir, model_info_dict,
@@ -54,13 +54,13 @@ def __init__(self, logger, input_dir, output_dir, model_info_dict,
         self.logo_dir = logo_dir
 
     def make_lead_average(self):
-        """! Create the lead average graphic
+        """! Make the lead average graphic
 
              Args:
 
              Returns:
         """
-        self.logger.info(f"Creating lead average...")
+        self.logger.info("Plot Type: Lead Average")
         self.logger.debug(f"Input directory: {self.input_dir}")
         self.logger.debug(f"Output directory: {self.output_dir}")
         self.logger.debug(f"Model information dictionary: "
@@ -74,13 +74,14 @@ def make_lead_average(self):
             self.logger.error("Cannot make lead_average for stat "
                               +f"{self.plot_info_dict['stat']}")
             sys.exit(1)
-        # Create dataframe for all forecast hours
+        # Make dataframe for all forecast hours
         self.logger.info("Building dataframe for all forecast hours")
+        self.logger.info(f"Reading in model stat files from {self.input_dir}")
         fcst_units = []
         for forecast_hour in self.date_info_dict['forecast_hours']:
-            self.logger.debug(f"Building data for forecast hour {forecast_hour}")
+            self.logger.info(f"Building data for forecast hour {forecast_hour}")
             # Get dates to plot
-            self.logger.info("Creating valid and init date arrays")
+            self.logger.debug("Making valid and init date arrays")
             valid_dates, init_dates = gda_util.get_plot_dates(
                 self.logger,
                 self.date_info_dict['date_type'],
@@ -114,9 +115,8 @@ def make_lead_average(self):
                                   +', '.join(format_valid_dates))
                 plot_dates = init_dates
             # Read in data
-            self.logger.info(f"Reading in model stat files from {self.input_dir}")
             all_model_df = gda_util.build_df(
-                self.logger, self.input_dir, self.output_dir,
+                'make_plots', self.logger, self.input_dir, self.output_dir,
                 self.model_info_dict, self.met_info_dict,
                 self.plot_info_dict['fcst_var_name'],
                 self.plot_info_dict['fcst_var_level'],
@@ -148,7 +148,7 @@ def make_lead_average(self):
                 stat_df.index.get_level_values(0).unique().tolist()
             )
             if self.plot_info_dict['event_equalization'] == 'YES':
-                self.logger.debug("Doing event equalization")
+                self.logger.info("Doing event equalization")
                 masked_stat_array = np.ma.masked_invalid(stat_array)
                 stat_array = np.ma.mask_cols(masked_stat_array)
                 stat_array = stat_array.filled(fill_value=np.nan)
@@ -226,7 +226,7 @@ def make_lead_average(self):
                     #    scale=stats.sem(np.ma.compressed(model_idx_model1_diff))
                     #)
         # Set up plot
-        self.logger.info(f"Doing plot set up")
+        self.logger.info(f"Setting up plot")
         plot_specs_la = PlotSpecs(self.logger, 'lead_average')
         plot_specs_la.set_up_plot()
         n_xticks = 17
@@ -261,7 +261,6 @@ def make_lead_average(self):
             self.plot_info_dict, self.date_info_dict,
             fcst_units[0]
         )
-        plot_left_logo = False
         plot_left_logo_path = os.path.join(self.logo_dir, 'noaa.png')
         if os.path.exists(plot_left_logo_path):
             plot_left_logo = True
@@ -274,7 +273,9 @@ def make_lead_average(self):
                     plot_specs_la.fig_size[1], plt.rcParams['figure.dpi']
                 )
             )
-        plot_right_logo = False
+        else:
+            plot_left_logo = False
+            self.logger.debug(f"{plot_left_logo_path} does not exist")
         plot_right_logo_path = os.path.join(self.logo_dir, 'nws.png')
         if os.path.exists(plot_right_logo_path):
             plot_right_logo = True
@@ -287,11 +288,14 @@ def make_lead_average(self):
                     plot_specs_la.fig_size[1], plt.rcParams['figure.dpi']
                 )
             )
+        else:
+            plot_right_logo = False
+            self.logger.debug(f"{plot_right_logo_path} does not exist")
         image_name = plot_specs_la.get_savefig_name(
             self.output_dir, self.plot_info_dict, self.date_info_dict
         )
-        # Create plot
-        self.logger.info(f"Creating plot for {self.plot_info_dict['stat']} ")
+        # Make plot
+        self.logger.info(f"Making plot")
         fig, (ax1, ax2) = plt.subplots(2,1,
                                        figsize=(plot_specs_la.fig_size[0],
                                                 plot_specs_la.fig_size[1]),
@@ -360,11 +364,11 @@ def make_lead_average(self):
                 model_num_plot_settings_dict = (
                     model_plot_settings_dict[model_num]
                 )
-            self.logger.debug(f"Plotting {model_num} - {model_num_name} "
-                              +f"- {model_num_plot_name}")
             masked_model_num_data = np.ma.masked_invalid(model_num_data)
             if model_num == 'model1':
                  model1_masked_model_num_data = masked_model_num_data
+                 model1_name = model_num_name
+                 model1_plot_name = model_num_plot_name
             model_num_npts = (
                 len(masked_model_num_data)
                 - np.ma.count_masked(masked_model_num_data)
@@ -373,9 +377,9 @@ def make_lead_average(self):
                 np.ma.getmask(masked_model_num_data),
                 forecast_hours_avg_df.columns.values.tolist()
             )
+            self.logger.debug(f"Plotting {model_num} [{model_num_name},"
+                              +f"{model_num_plot_name}]")
             if model_num_npts != 0:
-                self.logger.debug(f"Plotting {model_num} - {model_num_name} "
-                                  +f"- {model_num_plot_name}")
                 ax1.plot(
                     np.ma.compressed(masked_forecast_hours),
                     np.ma.compressed(masked_model_num_data),
@@ -400,6 +404,9 @@ def make_lead_average(self):
                     stat_min_max_dict['ax1_stat_max'] = (
                         masked_model_num_data.max()
                     )
+            else:
+                self.logger.debug(f"{model_num} [{model_num_name},"
+                                  +f"{model_num_plot_name}] has no points")
             masked_model_num_model1_diff_data = np.ma.masked_invalid(
                 model_num_data - model1_masked_model_num_data
             )
@@ -411,10 +418,11 @@ def make_lead_average(self):
                 np.ma.getmask(masked_model_num_model1_diff_data),
                 forecast_hours_avg_df.columns.values.tolist()
             )
+            self.logger.debug(f"Plotting {model_num} [{model_num_name},"
+                              +f"{model_num_plot_name}] difference from "
+                              +f"model1 [{model1_name},"
+                              +f"{model1_plot_name}]")
             if model_num_diff_npts != 0:
-                self.logger.debug(f"Plotting {model_num} - {model_num_name} "
-                                  +f"- {model_num_plot_name} difference from "
-                                  +self.model_info_dict['model1']['plot_name'])
                 ax2.plot(
                     np.ma.compressed(masked_diff_forecast_hours),
                     np.ma.compressed(masked_model_num_model1_diff_data),
@@ -438,6 +446,12 @@ def make_lead_average(self):
                     stat_min_max_dict['ax2_stat_max'] = (
                         masked_model_num_model1_diff_data.max()
                     )
+            else:
+                self.logger.debug(f"{model_num} [{model_num_name},"
+                                  +f"{model_num_plot_name}] difference from "
+                                  +f"model1 [{model1_name},{model1_plot_name}] "
+                                  +"has no points")
+                                  
             if model_num == 'model1':
                 ax2.plot(
                     forecast_hours_avg_df.columns.values.tolist(),
@@ -462,13 +476,13 @@ def make_lead_average(self):
                     np.ma.getmask(masked_model_num_model1_diff_ci_data),
                     forecast_hours_ci_df.columns.values.tolist()
                 )
+                self.logger.debug(f"Plotting {model_num} ["
+                                  +f"{model_num_name},"
+                                  +f"{model_num_plot_name}] difference "
+                                  +f"from model1 [{model1_name},"
+                                  +f"{model1_plot_name}] "
+                                  +"confidence intervals")
                 if model_num_ci_npts != 0:
-                    self.logger.debug(f"Plotting {model_num} - "
-                                      +f"{model_num_name}"
-                                      +f"- {model_num_plot_name} "
-                                      +"difference from "
-                                      +self.model_info_dict['model1']['plot_name']
-                                      +" confidence intervals")
                     ci_min = masked_model_num_model1_diff_ci_data.min()
                     ci_max = masked_model_num_model1_diff_ci_data.max()
                     if ci_min < stat_min_max_dict['ax2_stat_min'] \
@@ -510,6 +524,13 @@ def make_lead_average(self):
                                 color = 'None',
                                 edgecolor=model_num_plot_settings_dict['color'],
                                 linewidth=1)
+                else:
+                    self.logger.debug(f"{model_num}: ["
+                                      +f"{model_num_name},"
+                                      +f"{model_num_plot_name}] difference "
+                                      +f"from model1 [{model1_name},"
+                                      +f"{model1_plot_name}] "
+                                      +"confidence intervals has no points")
         subplot_num = 1
         for ax in fig.get_axes():
             stat_min = stat_min_max_dict['ax'+str(subplot_num)+'_stat_min']
@@ -649,7 +670,7 @@ def main():
         'root': '/PATH/TO/MET',
         'version': '11.0.2'
     }
-    # Create OUTPUT_DIR
+    # Make OUTPUT_DIR
     gda_util.make_dir(OUTPUT_DIR)
     # Set up logging
     logging_dir = os.path.join(OUTPUT_DIR, 'logs')