diff --git a/solventmapcreator/polynomialanalysis/polynomialdataanalysis.py b/solventmapcreator/polynomialanalysis/polynomialdataanalysis.py
index 615a1fe825ed0eaffe2c3375d1d65226ffbd5f87..c289ae9c0798453114a4e6f6cc2c51140dc1dc53 100644
--- a/solventmapcreator/polynomialanalysis/polynomialdataanalysis.py
+++ b/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():
diff --git a/solventmapcreator/test/polynomialanalysistest/polynomialdataanalysistest.py b/solventmapcreator/test/polynomialanalysistest/polynomialdataanalysistest.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e1927def200174d5d843c71b3f55daca880dced
--- /dev/null
+++ b/solventmapcreator/test/polynomialanalysistest/polynomialdataanalysistest.py
@@ -0,0 +1,127 @@
+#!/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
diff --git a/solventmapcreator/test/solvationmapcreatortests.py b/solventmapcreator/test/solvationmapcreatortests.py
index a251085850a66ed7dd261d7d51ead9120754af27..1cdf9d885aee53f68bb61d6c4678285f640e7590 100644
--- a/solventmapcreator/test/solvationmapcreatortests.py
+++ b/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__':