add methods to allow bar plot of mean RMSE vs. order to be plotted.

solventmapcreator/polynomialanalysis/polynomialanalysisplotting.py

@@ -18,6 +18,29 @@ LOGGER.setLevel(logging.WARN)
 COLOUR_LIST = ["orangered", "mediumblue", "green", "red", "darkturquoise", "darkmagenta",
                "darkorange", "olive", "navy", "forestgreen"]
 
+def create_and_write_bar_plot_rmse(input_data, filename_stem, **kwargs):
+    """This creates and writes bar plot.
+    """
+    bar_plot, bar_plot_axis = create_bar_plot_rmse(input_data, **kwargs)
+    fileformat = kwargs.get("fileformat", "eps")
+    output_filename = filename_stem + '.' + fileformat
+    plt.savefig(output_filename, format=fileformat)
+    plt.close(bar_plot)
+    return 0
+
+def create_bar_plot_rmse(input_data, **kwargs):
+    """This creates a bar plot where the mean RMSE by order is plotted.
+    """
+    bar_plot, bar_plot_axis = create_plot_with_axis(kwargs.get("figsize",
+                                                               plottinginput.FIGURE_SIZES['vertical bar chart']))
+    index = np.arange(len(input_data[0]))
+    bar_plot_axis.bar(index, input_data[1])
+    bar_plot_axis.set_ylabel("Average RMSE/$kJmol^{-1}$")
+    bar_plot_axis.set_xlabel("polynomial order")
+    bar_plot_axis.set_xticks(index)
+    bar_plot_axis.set_xticklabels(input_data[0])
+    return bar_plot, bar_plot_axis
+
 def create_bar_plot_write_to_file(input_data, filename_stem, **kwargs):
     """This creates the bar plot and saves it to file.
     """

solventmapcreator/polynomialanalysis/polynomialdataanalysis.py

@@ -15,6 +15,32 @@ logging.basicConfig()
 LOGGER = logging.getLogger(__name__)
 LOGGER.setLevel(logging.WARN)
 
+def get_mean_rmse_by_order_asarray(polynomial_dict_by_solvent_id, order_list):
+    """This gets the mean RMSE by order and returns it as an (2,n) array.
+    """
+    mean_rmse_dict = get_mean_rmse_by_order(polynomial_dict_by_solvent_id, order_list)
+    mean_rmse_array = np.empty((2, len(order_list)))
+    for i in range(len(order_list)):
+        order = order_list[i]
+        mean_rmse_array[0][i] = order
+        mean_rmse_array[1][i] = mean_rmse_dict[order]
+    return mean_rmse_array
+
+def get_mean_rmse_by_order(polynomial_dict_by_solvent_id, order_list):
+    """This gets the mean RMSE by order.
+    """
+    mean_rmse_dict = {}
+    for order in order_list:
+        mean_rmse_dict[order] = get_mean_rmse(polynomial_dict_by_solvent_id, order)
+    return mean_rmse_dict
+
+def get_mean_rmse(polynomial_dict_by_solvent_id, order):
+    """This extracts the 
+    """
+    rmse_array = np.array([polynomial_dict_by_solvent_id[solvent_id][order]["RMSE"] for solvent_id in polynomial_dict_by_solvent_id.keys()])
+    return rmse_array.mean()
+
+
 def get_total_sorted_by_alt_metric(full_order_list, best_order_sorted_dict):
     """This gets the sorted information and orders them ready to plot them.
     Need to feed in a list of all the orders, as not all may appear.

solventmapcreator/test/polynomialanalysistest/polynomialdataanalysistest.py

@@ -49,6 +49,26 @@ class PolynomialDataAnalysisTestCase(unittest.TestCase):
         del self.expected_data_by_solvent_id
         del self.rmse_dict
         del self.covar_dict
+    def test_get_mean_rmse_by_order_asarray(self):
+        """Test to see if expected array is returned.
+        """
+        expected_array = np.array([[1.0, 2.0], [0.020430299999999998, 0.0304303]])
+        actual_array = polynomialdataanalysis.get_mean_rmse_by_order_asarray(self.expected_data_by_solvent_id, [1,2])
+        np.testing.assert_array_almost_equal(expected_array, actual_array)
+    def test_get_mean_rmse_by_order(self):
+        """Test to see if expected dict is returned.
+        """
+        expected_dict = {1:0.020430299999999998, 2:0.0304303}
+        actual_dict = polynomialdataanalysis.get_mean_rmse_by_order(self.expected_data_by_solvent_id, [1,2])
+        self.assertEqual(sorted(expected_dict.keys()), sorted(actual_dict.keys()))
+        for key in expected_dict.keys():
+            self.assertAlmostEqual(expected_dict[key], actual_dict[key])
+    def test_get_mean_rmse(self):
+        """Test to see if expected mean is returned
+        """
+        expected_mean = 0.020430299999999998
+        actual_mean = polynomialdataanalysis.get_mean_rmse(self.expected_data_by_solvent_id, 1)
+        self.assertAlmostEqual(expected_mean, actual_mean)
     def test_get_total_sorted_by_alt_metric(self):
         """Test to see if 
         """