def isregistered(function):
status, msg = True, ""
try:
FunctionFactory.createFunction(function)
except RuntimeError as exc:
status, msg = False, 'Could not create {} function: {}'.format(function, str(exc))
return status, msg
def isregistered(function):
status, msg = True, ""
try:
FunctionFactory.createFunction(function)
except RuntimeError as exc:
status, msg = False, 'Could not create {} function: {}'.format(
function, str(exc))
return status, msg
def setUp(self):
context = setup_context()
self.model = ModelFittingModel(context, context.model_fitting_context)
self.result_table_names = ["Result1", "Result2"]
self.dataset_names = ["workspace_name_A0", "workspace_name_A1", "A0_A1"]
self.fit_function1 = FunctionFactory.createFunction("FlatBackground")
self.fit_function2 = FunctionFactory.createFunction("LinearBackground")
self.single_fit_functions = [self.fit_function1.clone(), self.fit_function1.clone(), self.fit_function2.clone()]
def setup_functions(self, flat_background: IFunction = None, exp_decay: IFunction = None) -> None:
"""Sets up the functions to use by default when doing Auto corrections."""
if flat_background is not None:
self.flat_background = flat_background.clone()
else:
self.flat_background = FunctionFactory.createFunction("FlatBackground")
if exp_decay is not None:
self.exp_decay = exp_decay.clone()
else:
self.exp_decay = FunctionFactory.createFunction("ExpDecayMuon")
self.exp_decay.setParameter("A", DEFAULT_A_VALUE)
self.exp_decay.setParameter("Lambda", DEFAULT_LAMBDA_VALUE)
self.exp_decay.fixParameter("Lambda")
def is_registered(function_name):
"""
Check whether the function with the specified name has been registered.
:param function_name: The name of the function to check for registration.
:return: A tuple of the status (True if function is registered,
false otherwise) and the error message (empty if the
function is registered).
"""
try:
FunctionFactory.createFunction(function_name)
except RuntimeError as exc:
return False, 'Could not create {} function: {}'.format(function_name,
str(exc))
return True, ""
def setUp(self):
self.dataset_names = ["Results1; A0 vs A1", "Results1; A1 vs A0"]
self.current_dataset_index = 0
self.start_x = 0.0
self.end_x = 15.0
self.fit_status = "success"
self.chi_squared = 1.5
self.function_name = "FlatBackground"
self.minimizer = "Levenberg-Marquardt"
self.evaluation_type = "eval type"
self.fit_to_raw = True
self.plot_guess = True
self.fit_function = FunctionFactory.createFunction("FlatBackground")
self.single_fit_functions = [
self.fit_function.clone(),
self.fit_function.clone()
]
self.param_combination_name = "Results1; A0 vs A1"
self.param_group_name = "Results1; Parameter Combinations"
self.result_table_names = ["Results1", "Results2"]
self.x_parameters = ["A0", "A1"]
self.y_parameters = ["A0", "A1"]
self.x_parameter_types = [
TableColumnType.Y.value, TableColumnType.Y.value
]
self.y_parameter_types = [
TableColumnType.Y.value, TableColumnType.Y.value
]
self._setup_mock_view()
self._setup_mock_model()
self._setup_presenter()
def setUp(self):
self.dataset_names = ["Name1", "Name2"]
self.current_dataset_index = 0
self.start_x = 0.0
self.end_x = 15.0
self.fit_status = "success"
self.chi_squared = 1.5
self.function_name = "FlatBackground"
self.minimizer = "Levenberg-Marquardt"
self.evaluation_type = "eval type"
self.fit_to_raw = True
self.plot_guess = True
self.fit_function = FunctionFactory.createFunction("FlatBackground")
self.single_fit_functions = [
self.fit_function.clone(),
self.fit_function.clone()
]
self._setup_mock_view()
self._setup_mock_model()
self._setup_presenter()
self.mock_view_minimizer.assert_called_once_with()
self.mock_view_evaluation_type.assert_called_once_with()
self.mock_view_fit_to_raw.assert_called_once_with()
self.mock_model_minimizer.assert_called_once_with(self.minimizer)
self.mock_model_evaluation_type.assert_called_once_with(
self.evaluation_type)
self.mock_model_fit_to_raw.assert_called_once_with(self.fit_to_raw)
self.assertEqual(
self.view.set_slot_for_fit_generator_clicked.call_count, 1)
self.assertEqual(self.view.set_slot_for_fit_button_clicked.call_count,
1)
self.assertEqual(self.view.set_slot_for_undo_fit_clicked.call_count, 1)
self.assertEqual(self.view.set_slot_for_plot_guess_changed.call_count,
1)
self.assertEqual(self.view.set_slot_for_fit_name_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_covariance_matrix_clicked.call_count, 1)
self.assertEqual(
self.view.set_slot_for_function_structure_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_function_parameter_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_function_attribute_changed.call_count, 1)
self.assertEqual(self.view.set_slot_for_start_x_updated.call_count, 1)
self.assertEqual(self.view.set_slot_for_end_x_updated.call_count, 1)
self.assertEqual(
self.view.set_slot_for_exclude_range_state_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_exclude_start_x_updated.call_count, 1)
self.assertEqual(
self.view.set_slot_for_exclude_end_x_updated.call_count, 1)
self.assertEqual(self.view.set_slot_for_minimizer_changed.call_count,
1)
self.assertEqual(
self.view.set_slot_for_evaluation_type_changed.call_count, 1)
self.assertEqual(self.view.set_slot_for_use_raw_changed.call_count, 1)
def setUp(self):
context = setup_context()
self.model = GeneralFittingModel(context, context.fitting_context)
self.dataset_names = ["Name1", "Name2"]
self.fit_function = FunctionFactory.createFunction("FlatBackground")
self.single_fit_functions = [self.fit_function.clone(), self.fit_function.clone()]
self.simultaneous_fit_function = FunctionFactory.createInitializedMultiDomainFunction(str(self.fit_function),
len(self.dataset_names))
def test_that_update_attribute_value_will_update_the_value_of_a_parameter_in_single_fit_mode(self):
self.model.dataset_names = self.dataset_names
self.model.single_fit_functions = [FunctionFactory.createFunction("Chebyshev"), None]
self.model.update_attribute_value("StartX", 0.0)
self.model.update_attribute_value("EndX", 15.0)
self.assertEqual(str(self.model.current_single_fit_function), "name=Chebyshev,EndX=15,StartX=0,n=0,A0=0")
def setUp(self):
self.fitting_context = BasicFittingContext()
self.dataset_names = ["Name1", "Name2"]
self.fit_function = FunctionFactory.createFunction("FlatBackground")
self.single_fit_functions = [
self.fit_function.clone(),
self.fit_function.clone()
]
def test_that_get_fit_function_parameters_will_return_a_list_of_parameter_names_when_in_single_fit_mode(self):
self.model.dataset_names = self.dataset_names
self.model.single_fit_functions = self.single_fit_functions
self.assertEqual(self.model.get_fit_function_parameters(), ["A0"])
self.fit_function = FunctionFactory.createFunction("ExpDecay")
self.model.single_fit_functions = [self.fit_function.clone(), self.fit_function.clone()]
self.assertEqual(self.model.get_fit_function_parameters(), ["Height", "Lifetime"])
def create_mantid_ifunction(self, function_name):
"""
Create and initiializes a Mantid IFunction.
Args:
function_name (str): The name of the function to use.
Returns:
ifunction: An instance of a Mantid IFunction
"""
return FunctionFactory.createFunction(function_name)
def setUp(self):
context = setup_context()
self.model = BasicFittingModel(context, context.fitting_context)
self.dataset_names = [
"EMU20884; Group; fwd; Asymmetry",
"EMU20884; Group; top; Asymmetry"
]
self.fit_function = FunctionFactory.createFunction("FlatBackground")
self.single_fit_functions = [
self.fit_function.clone(),
self.fit_function.clone()
]
def create_mantid_ifunction(self, function_name):
"""
Create and initiializes a Mantid IFunction.
Args:
function_name (str): The name of the function to use.
Returns:
ifunction: An instance of a Mantid IFunction
"""
from mantid.api import FunctionFactory
return FunctionFactory.createFunction(function_name)
def test_that_automatically_update_function_name_will_set_the_correct_function_name_for_a_composite_function(self):
composite = CompositeFunction()
composite.add(self.fit_function.clone())
f2 = FunctionFactory.createFunction("ExpDecay")
composite.add(f2)
self.model.dataset_names = self.dataset_names
self.model.single_fit_functions = [composite.clone(), composite.clone()]
self.assertEqual(self.model.function_name, "")
self.model.automatically_update_function_name()
self.assertEqual(self.model.function_name, " FlatBackground,ExpDecay")
def _get_fit_function_for_background_fit(self, correction_data: BackgroundCorrectionData) -> IFunction:
"""Returns the fit function to use for a background fit."""
correction_data = self._set_background_parameter_if_not_using_raw(correction_data)
if self._corrections_context.selected_function == FLAT_BACKGROUND:
return correction_data.flat_background
elif self._corrections_context.selected_function == FLAT_BACKGROUND_AND_EXP_DECAY:
composite = FunctionFactory.createFunction("CompositeFunction")
composite.add(correction_data.flat_background)
composite.add(correction_data.exp_decay)
return composite
raise RuntimeError("The selected background function is not recognised.")
def __init__(self, name, **kwargs):
"""
Called when creating an instance
:param name: name of fitting function to create or
an Ifunction object to wrap.
:param kwargs: standard argument for initializing fit
function
"""
if not isinstance(name, str):
self.fun = name
else:
self.fun = FunctionFactory.createFunction(name)
self.init_paramgeters_and_attributes(**kwargs)
def __init__(self, name, **kwargs):
"""
Called when creating an instance
:param name: name of fitting function to create or
an Ifunction object to wrap.
:param kwargs: standard argument for initializing fit
function
"""
if not isinstance(name, str):
self.fun = name
else:
self.fun = FunctionFactory.createFunction(name)
self.init_paramgeters_and_attributes(**kwargs)
def test_that_update_attribute_value_will_update_the_value_of_a_parameter_in_simultaneous_fit_mode(self):
self.model.dataset_names = self.dataset_names
self.fit_function = FunctionFactory.createFunction("Chebyshev")
self.model.simultaneous_fit_function = FunctionFactory.createInitializedMultiDomainFunction(
str(self.fit_function), len(self.dataset_names))
self.model.simultaneous_fitting_mode = True
self.model.current_dataset_index = 1
self.model.update_attribute_value("StartX", 0.0)
self.model.update_attribute_value("EndX", 15.0)
self.assertEqual(str(self.model.simultaneous_fit_function), "composite=MultiDomainFunction,NumDeriv=true;"
"name=Chebyshev,EndX=1,StartX=-1,n=0,A0=0,$domains=i;"
"name=Chebyshev,EndX=15,StartX=0,n=0,A0=0,$domains=i")
def setUp(self):
context = setup_context()
self.model = TFAsymmetryFittingModel(context, context.fitting_context)
self.dataset_names = [
"EMU20884; Group; fwd; Asymmetry",
"EMU20884; Group; top; Asymmetry"
]
self.tf_non_compliant_dataset_names = [
"EMU20884; Group; fwd; Asymmetry",
"EMU20884; Pair Asym; long; Asymmetry"
]
self.fit_function = FunctionFactory.createFunction("FlatBackground")
self.single_fit_functions = [
self.fit_function.clone(),
self.fit_function.clone()
]
self.simultaneous_fit_function = FunctionFactory.createInitializedMultiDomainFunction(
str(self.fit_function), len(self.dataset_names))
self.tf_single_function = create_tf_asymmetry_function(
self.fit_function.clone())
self.tf_single_fit_functions = [
self.tf_single_function.clone(),
self.tf_single_function.clone()
]
self.tf_simultaneous_fit_function = FunctionFactory.createInitializedMultiDomainFunction(
str(self.tf_single_function), len(self.dataset_names))
CreateSampleWorkspace(Function="One Peak",
XMin=0.0,
XMax=15.0,
BinWidth=0.1,
OutputWorkspace=self.dataset_names[0])
CreateSampleWorkspace(Function="One Peak",
XMin=0.0,
XMax=15.0,
BinWidth=0.1,
OutputWorkspace=self.dataset_names[1])
def create_tf_asymmetry_function(normal_function):
flat_back_normalisation = FunctionFactory.createFunction("FlatBackground")
comp1 = FunctionFactory.createFunction("CompositeFunction")
flat_back = FunctionFactory.createFunction("FlatBackground")
comp1.add(flat_back)
comp1.add(normal_function)
prod_func = FunctionFactory.createFunction("ProductFunction")
prod_func.add(flat_back_normalisation)
prod_func.add(comp1)
exp_decay_muon = FunctionFactory.createFunction("ExpDecayMuon")
comp2 = FunctionFactory.createFunction("CompositeFunction")
comp2.add(prod_func)
comp2.add(exp_decay_muon)
return comp2
def __init__(self, name, **kwargs):
"""
Called when creating an instance
:param name: name of fitting function to create or
an Ifunction object to wrap.
:param **kwargs: standard argument for __init__ function
"""
if not isinstance(name, str):
self.fun = name
else:
self.fun = FunctionFactory.createFunction(name)
# Deal with attributes first
for key in kwargs:
if key == "attributes":
atts = kwargs[key]
for keya in atts:
self.fun.setAttributeValue(keya, atts[keya])
elif self.fun.hasAttribute(key):
self.fun.setAttributeValue(key, kwargs[key])
# Then deal with parameters
for key in kwargs:
if key != "attributes" and not self.fun.hasAttribute(key):
self.fun.setParameter(key, kwargs[key])
def __init__(self, name, params_to_optimize=None, **kwargs):
"""
Called when creating an instance
:param name: name of fitting function to create or an Ifunction object to wrap.
:param params_to_optimize: names of the parameters you want to optimize. The omitted parameters will remain
fixed at their initial value.
:param kwargs: standard argument for initializing fit function
"""
if not isinstance(name, str):
self.fun = name
else:
self.fun = FunctionFactory.createFunction(name)
self.init_paramgeters_and_attributes(**kwargs)
def set_parameters_by_index(params):
for i in range(len(params)):
self.fun.setParameter(i, params[i])
def set_parameters_by_name(params):
for i, param_name in enumerate(params_to_optimize):
self.fun.setParameter(param_name, params[i])
self._set_parameters = set_parameters_by_index if params_to_optimize is None else set_parameters_by_name
def test_that_set_fit_function_will_set_the_function_in_the_browser(self):
fit_function = FunctionFactory.createFunction("FlatBackground")
self.view.set_fit_function(fit_function)
self.assertEqual(str(self.view.current_fit_function()),
str(fit_function))
def _setup_fitted_function(self):
function = FunctionFactory.createFunction("FlatBackground")
function.setParameter("A0", self.fitted_a0)
function.setError("A0", self.fitted_a0_error)
return function
def test_type(self):
p = FunctionFactory.createFunction("ProductFunction")
self.assertTrue(isinstance(p, ProductFunction))
self.assertTrue(isinstance(p, CompositeFunction))
def test_length(self):
p = FunctionFactory.createFunction("ProductFunction")
self.assertEquals(len(p), 0)
def setUp(self):
self.dataset_names = ["Name1", "Name2"]
self.current_dataset_index = 0
self.start_x = 0.0
self.end_x = 15.0
self.fit_status = "success"
self.chi_squared = 1.5
self.function_name = "FlatBackground"
self.minimizer = "Levenberg-Marquardt"
self.evaluation_type = "eval type"
self.fit_to_raw = True
self.plot_guess = True
self.simultaneous_fitting_mode = True
self.simultaneous_fit_by = "Group/Pair"
self.simultaneous_fit_by_specifier = "fwd"
self.global_parameters = ["A0"]
self.fit_function = FunctionFactory.createFunction("FlatBackground")
self.single_fit_functions = [
self.fit_function.clone(),
self.fit_function.clone()
]
self.tf_asymmetry_mode = True
self.normalisation = 3.0
self.normalisation_error = 0.3
self._setup_mock_view()
self._setup_mock_model()
self._setup_presenter()
self.mock_view_minimizer.assert_called_once_with()
self.mock_view_evaluation_type.assert_called_once_with()
self.mock_view_fit_to_raw.assert_called_once_with()
self.mock_view_simultaneous_fit_by.assert_called_once_with()
self.mock_view_simultaneous_fit_by_specifier.assert_called_once_with()
self.mock_view_global_parameters.assert_called_once_with()
self.mock_view_tf_asymmetry_mode.assert_called_once_with()
self.mock_model_minimizer.assert_called_once_with(self.minimizer)
self.mock_model_evaluation_type.assert_called_once_with(
self.evaluation_type)
self.mock_model_fit_to_raw.assert_called_once_with(self.fit_to_raw)
self.mock_model_simultaneous_fit_by.assert_called_once_with(
self.simultaneous_fit_by)
self.mock_model_simultaneous_fit_by_specifier.assert_called_once_with(
self.simultaneous_fit_by_specifier)
self.mock_model_global_parameters.assert_called_once_with(
self.global_parameters)
self.mock_model_tf_asymmetry_mode.assert_called_once_with(
self.tf_asymmetry_mode)
self.assertEqual(
self.view.set_slot_for_fit_generator_clicked.call_count, 1)
self.assertEqual(self.view.set_slot_for_fit_button_clicked.call_count,
1)
self.assertEqual(self.view.set_slot_for_undo_fit_clicked.call_count, 1)
self.assertEqual(self.view.set_slot_for_plot_guess_changed.call_count,
1)
self.assertEqual(self.view.set_slot_for_fit_name_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_function_structure_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_function_parameter_changed.call_count, 1)
self.assertEqual(self.view.set_slot_for_start_x_updated.call_count, 1)
self.assertEqual(self.view.set_slot_for_end_x_updated.call_count, 1)
self.assertEqual(self.view.set_slot_for_minimizer_changed.call_count,
1)
self.assertEqual(
self.view.set_slot_for_evaluation_type_changed.call_count, 1)
self.assertEqual(self.view.set_slot_for_use_raw_changed.call_count, 1)
self.assertEqual(self.view.set_slot_for_dataset_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_fitting_mode_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_simultaneous_fit_by_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_simultaneous_fit_by_specifier_changed.
call_count, 1)
self.assertEqual(
self.view.set_slot_for_fitting_type_changed.call_count, 1)
self.assertEqual(
self.view.set_slot_for_normalisation_changed.call_count, 1)
def test_addition(self):
p = FunctionFactory.createFunction("ProductFunction")
g = FunctionFactory.createFunction("Gaussian")
p.add(g)
p.add(g)
self.assertEquals(len(p), 2)
def test_addition(self):
p = FunctionFactory.createFunction("ProductFunction")
g = FunctionFactory.createFunction("Gaussian")
p.add(g)
p.add(g)
self.assertEquals(len(p), 2)
def test_get_Gaussian(self):
name = "Gaussian"
func = FunctionFactory.createFunction(name)
self.assertTrue(func.name() == name)
self.assertTrue(len(func.__repr__()) > len(name))
self.assertTrue("Peak" in func.categories())
def test_type(self):
p = FunctionFactory.createFunction("ProductFunction")
self.assertTrue( isinstance(p,ProductFunction) )
self.assertTrue( isinstance(p,CompositeFunction) )
def test_length(self):
p = FunctionFactory.createFunction("ProductFunction")
self.assertEquals(len(p), 0)
def test_category_with_no_override_returns_default_category(self):
FunctionFactory.subscribe(NoCatgeoryFunction)
func = FunctionFactory.createFunction("NoCatgeoryFunction")
self.assertEquals("General", func.category())
FunctionFactory.unsubscribe("NoCatgeoryFunction")
def test_category_override_returns_overridden_result(self):
FunctionFactory.subscribe(Times2)
func = FunctionFactory.createFunction("Times2")
self.assertEquals("SimpleFunction", func.category())
FunctionFactory.unsubscribe("Times2")
def test_instance_can_be_created_from_factory(self):
FunctionFactory.subscribe(Times2)
func_name = Times2.__name__
func = FunctionFactory.createFunction(func_name)
self.assertTrue(isinstance(func, IFunction1D))
FunctionFactory.unsubscribe(func_name)
def test_get_Gaussian(self):
name = "Gaussian"
func = FunctionFactory.createFunction(name)
self.assertTrue(func.name() == name)
self.assertTrue(len(func.__repr__()) > len(name))
self.assertTrue("Peak" in func.categories())
def test_instance_can_be_created_from_factory(self):
FunctionFactory.subscribe(Times2)
func_name = Times2.__name__
func = FunctionFactory.createFunction(func_name)
self.assertTrue(isinstance(func, IFunction1D))
FunctionFactory.unsubscribe(func_name)
def test_category_override_returns_overridden_result(self):
FunctionFactory.subscribe(Times2)
func = FunctionFactory.createFunction("Times2")
self.assertEquals("SimpleFunction", func.category())
FunctionFactory.unsubscribe("Times2")
def test_category_with_no_override_returns_default_category(self):
FunctionFactory.subscribe(NoCatgeoryFunction)
func = FunctionFactory.createFunction("NoCatgeoryFunction")
self.assertEquals("General", func.category())
FunctionFactory.unsubscribe("NoCatgeoryFunction")