finished work on polynomialdataanalysis script, and implimented tests, leading...

finished work on polynomialdataanalysis script, and implimented tests, leading to correction to some functions.

solventmapcreator/polynomialanalysis/polynomialdataanalysis.py

@@ -15,6 +15,24 @@ logging.basicConfig()
 LOGGER = logging.getLogger(__name__)
 LOGGER.setLevel(logging.WARN)
 
+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.
+    """
+    order_tuple = tuple(sorted(best_order_sorted_dict.keys()))
+    numbers_by_order = []
+    for i in range(len(full_order_list)):
+        order = full_order_list[i]
+        order_info = []
+        for j in range(len(order_tuple)):
+            sorted_dict_order = full_order_list[j]
+            if order in best_order_sorted_dict[sorted_dict_order].keys():
+                order_info.append(len(best_order_sorted_dict[sorted_dict_order][order]))
+            else:
+                order_info.append(0)
+        numbers_by_order.append(tuple(order_info))
+    numbers_by_order_tuple = tuple(numbers_by_order)
+    return (order_tuple, numbers_by_order_tuple)
 
 def get_total_by_fit_order(best_order_dict):
     """This returns a tuple containing the order, and also the number of
@@ -24,6 +42,15 @@ def get_total_by_fit_order(best_order_dict):
     number_by_order = tuple([len(best_order_dict[order]) for order in order_tuple])
     return (order_tuple, number_by_order)
 
+def generate_lists_by_alt_metric(solvent_ids_by_order, solvent_ids_by_order_alt_metric):
+    """This goes through each order in the data and uses the best polynomial
+    fit data to sort the solvent_ids by the alternative metric.
+    """
+    solvent_ids_sorted_by_alt_metric = {}
+    for order, solvent_id_list in solvent_ids_by_order.items():
+        solvent_ids_sorted_by_alt_metric[order] = extract_lists_by_order_of_alt_metric(solvent_id_list, solvent_ids_by_order_alt_metric)
+    return solvent_ids_sorted_by_alt_metric
+
 def extract_lists_by_order_of_alt_metric(solvent_id_list, solvent_ids_by_order):
     """This returns a dictionary where the solvent IDs are sorted based on the
     best order from the alternate metric.
@@ -80,7 +107,7 @@ def extract_best_poly_fit_rmse(polynomial_dict):
     return best_order, smallest_rmse
 
 def get_best_poly_fit_covar(polynomial_dict_by_solvent_id):
-    """This 
+    """This returns a dict with tuples containing the information.
     """
     best_covar_order_dict = {}
     for solvent_id, polynomial_dict in polynomial_dict_by_solvent_id.items():

solventmapcreator/test/polynomialanalysistest/polynomialdataanalysistest.py

+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jul  6 21:13:47 2017
+
+@author: mark
+"""
+
+import logging
+import unittest
+import numpy as np
+import solventmapcreator.polynomialanalysis.polynomialdataanalysis as polynomialdataanalysis
+
+logging.basicConfig()
+LOGGER = logging.getLogger(__name__)
+LOGGER.setLevel(logging.WARN)
+
+class PolynomialDataAnalysisTestCase(unittest.TestCase):
+    """Test case for the polynomialdataanalysis script
+    """
+    def setUp(self):
+        """set up for class.
+        """
+        self.expected_data_by_solvent_id = {"expected_poly_fit":{1:{"coefficients":np.array([-0.05, 
+                                                                                             1.07142857]),
+                                                                    "RMSE":0.0154303,
+                                                                    "order":1,
+                                                                    "covar":0.0007143},
+                                                                 2:{"coefficients":np.array([-0.05, 
+                                                                                             1.07142857, 0.1]),
+                                                                    "RMSE":0.0254303,
+                                                                    "order":1,
+                                                                    "covar":0.0008143}},
+                                            "expected_poly_fit2":{1:{"coefficients":np.array([-0.05, 
+                                                                                             1.07142857]),
+                                                                    "RMSE":0.0254303,
+                                                                    "order":1,
+                                                                    "covar":0.007143},
+                                                                 2:{"coefficients":np.array([-0.05, 
+                                                                                             1.07142857, 0.1]),
+                                                                    "RMSE":0.0354303,
+                                                                    "order":1,
+                                                                    "covar":0.0008143}}}
+        self.rmse_dict = polynomialdataanalysis.get_best_poly_fit_rmse(self.expected_data_by_solvent_id)
+        self.covar_dict = polynomialdataanalysis.get_best_poly_fit_covar(self.expected_data_by_solvent_id)
+    def tearDown(self):
+        """tear down for tests.
+        """
+        del self.expected_data_by_solvent_id
+        del self.rmse_dict
+        del self.covar_dict
+    def test_get_total_sorted_by_alt_metric(self):
+        """Test to see if 
+        """
+        rmse_solvent_id_dict = polynomialdataanalysis.get_solvent_id_by_order(self.rmse_dict)
+        covar_solvent_id_dict = polynomialdataanalysis.get_solvent_id_by_order(self.covar_dict)
+        ordered_id_dict = polynomialdataanalysis.generate_lists_by_alt_metric(rmse_solvent_id_dict, covar_solvent_id_dict)
+        expected_tuple = ((1,),((1,),(1,)))
+        actual_tuple = polynomialdataanalysis.get_total_sorted_by_alt_metric([1, 2], ordered_id_dict)
+        self.assertEqual(expected_tuple, actual_tuple)
+    def test_get_total_by_fit_order(self):
+        """Test to see if expected totals are returned.
+        """
+        rmse_solvent_id_dict = polynomialdataanalysis.get_solvent_id_by_order(self.rmse_dict)
+        covar_solvent_id_dict = polynomialdataanalysis.get_solvent_id_by_order(self.covar_dict)
+        expected_tuple_rmse = ((1,), (2,))
+        actual_tuple_rmse = polynomialdataanalysis.get_total_by_fit_order(rmse_solvent_id_dict)
+        self.assertEqual(expected_tuple_rmse, actual_tuple_rmse)
+        expected_tuple_covar = ((1, 2), (1, 1))
+        actual_tuple_covar = polynomialdataanalysis.get_total_by_fit_order(covar_solvent_id_dict)
+        self.assertEqual(expected_tuple_covar, actual_tuple_covar)
+    def test_generate_lists_by_alt_metric(self):
+        """Test to see if expected dict is produced.
+        """
+        expected_dict = {1:{1: ['expected_poly_fit'], 2: ['expected_poly_fit2']}}
+        rmse_solvent_id_dict = polynomialdataanalysis.get_solvent_id_by_order(self.rmse_dict)
+        covar_solvent_id_dict = polynomialdataanalysis.get_solvent_id_by_order(self.covar_dict)
+        actual_dict = polynomialdataanalysis.generate_lists_by_alt_metric(rmse_solvent_id_dict, covar_solvent_id_dict)
+        self.assertDictEqual(expected_dict, actual_dict)
+    def test_extract_lists_by_order_of_alt_metric(self):
+        """Test to if expected dict is produced.
+        """
+        expected_dict = {1: ['expected_poly_fit'], 2: ['expected_poly_fit2']}
+        rmse_list = ['expected_poly_fit', 'expected_poly_fit2']
+        covar_solvent_id_dict = polynomialdataanalysis.get_solvent_id_by_order(self.covar_dict)
+        actual_dict = polynomialdataanalysis.extract_lists_by_order_of_alt_metric(rmse_list, covar_solvent_id_dict)
+        self.assertDictEqual(expected_dict, actual_dict)
+    def test_get_solvent_id_by_order(self):
+        """Test to see if expected dictionary is returned
+        """
+        expected_dict = {1: ['expected_poly_fit', 'expected_poly_fit2']}
+        actual_dict = polynomialdataanalysis.get_solvent_id_by_order(self.rmse_dict)
+        self.assertDictEqual(expected_dict, actual_dict)
+    def test_get_solvent_id(self):
+        """Test to see if expected list is returned.
+        """
+        expected_list = ['expected_poly_fit', 'expected_poly_fit2']
+        actual_list = polynomialdataanalysis.get_solvent_id(self.rmse_dict[1])
+        self.assertListEqual(expected_list, actual_list)
+    def test_get_best_poly_fit_rmse(self):
+        """Test to see if expected dict is produced.
+        """
+        expected_dict = {1: [('expected_poly_fit', 0.0154303), ('expected_poly_fit2', 0.0254303)]}
+        actual_dict = polynomialdataanalysis.get_best_poly_fit_rmse(self.expected_data_by_solvent_id)
+        self.assertDictEqual(expected_dict, actual_dict)
+    def test_extract_best_poly_fit_rmse(self):
+        """Test to see if expected value is extracted.
+        """
+        expected_order = 1
+        expected_rmse = 0.0154303
+        actual_order, actual_rmse = polynomialdataanalysis.extract_best_poly_fit_rmse(self.expected_data_by_solvent_id["expected_poly_fit"])
+        self.assertAlmostEqual(expected_rmse, actual_rmse)
+        self.assertEqual(expected_order, actual_order)
+    def test_get_best_poly_fit_covar(self):
+        """Test to see if expected dict is produced.
+        """
+        expected_dict = {1: [('expected_poly_fit', 0.0007143)], 2: [('expected_poly_fit2', 0.0008143)]}
+        actual_dict = polynomialdataanalysis.get_best_poly_fit_covar(self.expected_data_by_solvent_id)
+        self.assertDictEqual(expected_dict, actual_dict)
+    def test_extract_best_poly_fit_covar(self):
+        """Test to see if expected value is extracted.
+        """
+        expected_order = 1
+        expected_covar = 0.0007143
+        actual_order, actual_covar = polynomialdataanalysis.extract_best_poly_fit_covar(self.expected_data_by_solvent_id["expected_poly_fit"])
+        self.assertAlmostEqual(expected_covar, actual_covar)
+        self.assertEqual(expected_order, actual_order)
\ No newline at end of file

solventmapcreator/test/solvationmapcreatortests.py

@@ -12,6 +12,7 @@ from solventmapcreator.test.iotest.solvationenergyreadertest import SolvationEne
 from solventmapcreator.test.iotest.polynomialdatawritertest import PolynomialDataWriterTestCase
 from solventmapcreator.test.iotest.polynomialdatareadertest import PolynomialDataReaderTestCase
 from solventmapcreator.test.solvationcalculationtest.solvationcalculatortest import SolvationCalculatorTestCase
+from solventmapcreator.test.polynomialanalysistest.polynomialdataanalysistest import PolynomialDataAnalysisTestCase
 
 logging.basicConfig()
 LOGGER = logging.getLogger(__name__)
@@ -21,6 +22,9 @@ IO_TEST_CASES = [SolvationEnergyReaderTestCase, PolynomialDataWriterTestCase,
                  PolynomialDataReaderTestCase]
 
 SOLVATION_CALCULATION_TEST_CASES = [SolvationCalculatorTestCase]
+
+POLYNOMIAL_ANALYSIS_TEST_CASES = [PolynomialDataAnalysisTestCase]
+
 def test_suite():
     """Function creates a test suite and then loads all the tests from the
     different test cases.
@@ -34,6 +38,9 @@ def test_suite():
     for test_case in SOLVATION_CALCULATION_TEST_CASES:
         LOGGER.debug("Adding %s", test_case)
         suite.addTests(loader.loadTestsFromTestCase(test_case))
+    for test_case in POLYNOMIAL_ANALYSIS_TEST_CASES:
+        LOGGER.debug("Adding %s", test_case)
+        suite.addTests(loader.loadTestsFromTestCase(test_case))
     return suite
 
 if __name__ == '__main__':