source: sasview/src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingUtilitiesTest.py @ 44880ac

import sys
import unittest
from PyQt4 import QtGui

from sas.qtgui.Plotting.PlotterData import Data1D
from sas.qtgui.Plotting.PlotterData import Data2D

from UnitTesting.TestUtils import WarningTestNotImplemented

from sasmodels import generate
from sasmodels import modelinfo
from sasmodels.sasview_model import load_standard_models

# Tested module
from sas.qtgui.Perspectives.Fitting import FittingUtilities

class FittingUtilitiesTest(unittest.TestCase):
    '''Test the Fitting Utilities functions'''
    def setUp(self):
        '''Empty'''
        pass

    def tearDown(self):
        '''Empty'''
        pass

    def testReplaceShellName(self):
        """
        Test the utility function for string manipulation
        """
        param_name = "test [123]"
        value = "replaced"
        result = FittingUtilities.replaceShellName(param_name, value)
        
        self.assertEqual(result, "test replaced")

        # Assert!
        param_name = "no brackets"
        with self.assertRaises(AssertionError):
            result = FittingUtilities.replaceShellName(param_name, value)

        
    def testGetIterParams(self):
        """
        Assure the right multishell parameters are returned
        """
        # Use a single-shell parameter
        model_name = "barbell"
        kernel_module = generate.load_kernel_module(model_name)
        barbell_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        params = FittingUtilities.getIterParams(barbell_parameters)
        # returns empty list
        self.assertEqual(params, [])

        # Use a multi-shell parameter
        model_name = "core_multi_shell"
        kernel_module = generate.load_kernel_module(model_name)
        multishell_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        params = FittingUtilities.getIterParams(multishell_parameters)
        # returns a non-empty list
        self.assertNotEqual(params, [])
        self.assertIn('sld', str(params))
        self.assertIn('thickness', str(params))

    def testGetMultiplicity(self):
        """
        Assure more multishell parameters are evaluated correctly
        """
        # Use a single-shell parameter
        model_name = "barbell"
        kernel_module = generate.load_kernel_module(model_name)
        barbell_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        param_name, param_length = FittingUtilities.getMultiplicity(barbell_parameters)
        # returns nothing
        self.assertEqual(param_name, "")
        self.assertEqual(param_length, 0)

        # Use a multi-shell parameter
        model_name = "core_multi_shell"
        kernel_module = generate.load_kernel_module(model_name)
        multishell_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        param_name, param_length = FittingUtilities.getMultiplicity(multishell_parameters)

        self.assertEqual(param_name, "n")
        self.assertEqual(param_length, 10)

    def testAddParametersToModel(self):
        """
        Checks the QModel update from Sasmodel parameters
        """
        # Use a single-shell parameter
        model_name = "barbell"
        models = load_standard_models()

        kernel_module = generate.load_kernel_module(model_name)
        kernel_module_o = None
        for model in models:
            if model.name == model_name:
                kernel_module_o = model()
        self.assertIsNotNone(kernel_module_o)
        barbell_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        params = FittingUtilities.addParametersToModel(barbell_parameters, kernel_module_o, True)

        # Test the resulting model
        self.assertEqual(len(params), 7)
        self.assertEqual(len(params[0]), 5)
        self.assertTrue(params[0][0].isCheckable())
        self.assertEqual(params[0][0].text(), "sld")
        self.assertEqual(params[1][0].text(), "sld_solvent")

        # Use a multi-shell parameter to see that the method includes shell params
        model_name = "core_multi_shell"
        kernel_module = generate.load_kernel_module(model_name)
        kernel_module_o = None
        for model in models:
            if model.name == model_name:
                kernel_module_o = model()
        self.assertIsNotNone(kernel_module_o)
        multi_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        params = FittingUtilities.addParametersToModel(multi_parameters, kernel_module_o, False)

        # Test the resulting model
        self.assertEqual(len(params), 3)
        self.assertEqual(len(params[0]), 5)
        self.assertTrue(params[0][0].isCheckable())
        self.assertEqual(params[0][0].text(), "sld_core")
        self.assertEqual(params[1][0].text(), "radius")

    def testAddSimpleParametersToModel(self):
        """
        Checks the QModel update from Sasmodel parameters - no polydisp
        """
        # Use a multi-shell parameter to see that the method doesn't include shells
        model_name = "core_multi_shell"
        kernel_module = generate.load_kernel_module(model_name)
        models = load_standard_models()
        kernel_module_o = None
        for model in models:
            if model.name == model_name:
                kernel_module_o = model()
        self.assertIsNotNone(kernel_module_o)
        multi_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        params = FittingUtilities.addParametersToModel(multi_parameters, kernel_module_o, True)

        # Test the resulting model
        self.assertEqual(len(params), 3)
        self.assertEqual(len(params[0]), 5)
        self.assertTrue(params[0][0].isCheckable())
        self.assertEqual(params[0][0].text(), "sld_core")
        self.assertEqual(params[1][0].text(), "radius")

    def testAddCheckedListToModel(self):
        """
        Test for inserting a checkboxed item into a QModel
        """
        model = QtGui.QStandardItemModel()
        params = ["row1", "row2", "row3"]

        FittingUtilities.addCheckedListToModel(model, params)

        # Check the model
        self.assertEqual(model.rowCount(), 1)
        self.assertTrue(model.item(0).isCheckable())
        self.assertEqual(model.item(0, 0).text(), params[0])
        self.assertEqual(model.item(0, 1).text(), params[1])
        self.assertEqual(model.item(0, 2).text(), params[2])

    def testAddShellsToModel(self):
        """
        Test for inserting a list of QItems into a model
        """
        # Use a multi-shell parameter to see that the method doesn't include shells
        model_name = "core_multi_shell"
        kernel_module = generate.load_kernel_module(model_name)
        multi_parameters = modelinfo.make_parameter_table(getattr(kernel_module, 'parameters', []))

        model = QtGui.QStandardItemModel()

        index = 2
        FittingUtilities.addShellsToModel(multi_parameters, model, index)
        # There should be index*len(multi_parameters) new rows
        self.assertEqual(model.rowCount(), 4)

        model = QtGui.QStandardItemModel()
        index = 5
        FittingUtilities.addShellsToModel(multi_parameters, model, index)
        self.assertEqual(model.rowCount(), 10)
        
        self.assertEqual(model.item(1).child(0).text(), "Polydispersity")
        self.assertEqual(model.item(1).child(0).child(0).text(), "Distribution")
        self.assertEqual(model.item(1).child(0).child(0,1).text(), "40.0")

    def testCalculate1DChi2(self):
        """
        Test the chi2 calculator for Data1D
        """
        reference_data = Data1D(x=[0.1, 0.2], y=[0.0, 0.0])

        # 1. identical data
        current_data = Data1D(x=[0.1, 0.2], y=[0.0, 0.0])

        chi = FittingUtilities.calculateChi2(reference_data, current_data)

        # Should be zero
        self.assertAlmostEqual(chi, 0.0, 8)

        # 2. far data
        current_data = Data1D(x=[0.1, 0.2], y=[200.0, 150.0])

        chi = FittingUtilities.calculateChi2(reference_data, current_data)

        # Should not be zero
        self.assertAlmostEqual(chi, 31250.0, 8)

        # 3. Wrong data
        current_data = Data1D(x=[0.1, 0.2], y=[200.0, 150.0, 200.0])
        chi = FittingUtilities.calculateChi2(reference_data, current_data)
        # Should be None
        self.assertIsNone(chi)

    def testCalculate2DChi2(self):
        """
        Test the chi2 calculator for Data2D
        """
        reference_data = Data2D(image=[1.0, 2.0, 3.0],
                      err_image=[0.01, 0.02, 0.03],
                      qx_data=[0.1, 0.2, 0.3],
                      qy_data=[0.1, 0.2, 0.3])

        # 1. identical data
        current_data = Data2D(image=[1.0, 2.0, 3.0],
                      err_image=[0.01, 0.02, 0.03],
                      qx_data=[0.1, 0.2, 0.3],
                      qy_data=[0.1, 0.2, 0.3])

        chi = FittingUtilities.calculateChi2(reference_data, current_data)

        # Should be zero
        self.assertAlmostEqual(chi, 0.0, 8)

        # 2. far data
        current_data = Data2D(image=[100.0, 200.0, 300.0],
                      err_image=[1.01, 2.02, 3.03],
                      qx_data=[0.1, 0.2, 0.3],
                      qy_data=[100.0, 200., 300.])

        chi = FittingUtilities.calculateChi2(reference_data, current_data)

        # Should not be zero
        self.assertAlmostEqual(chi, 9607.88, 2)

        # 3. Wrong data
        current_data = Data2D(image=[1.0, 2.0, 3.0],
                      err_image=[0.01, 0.02],
                      qx_data=[0.1, 0.2],
                      qy_data=[0.1, 0.2, 0.3])
        # Should throw
        with self.assertRaises(ValueError):
            chi = FittingUtilities.calculateChi2(reference_data, current_data)

if __name__ == "__main__":
    unittest.main()