From d1c20a4151ab04f5fb273144925302d99aa73e43 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Tue, 14 Oct 2025 19:54:57 +0200 Subject: [PATCH 01/44] Add basic sample_model and tests --- src/easydynamics/sample_model/sample_model.py | 473 ++++++++++++++++++ .../sample_model/test_sample_model.py | 261 ++++++++++ 2 files changed, 734 insertions(+) create mode 100644 src/easydynamics/sample_model/sample_model.py create mode 100644 tests/unit_tests/sample_model/test_sample_model.py diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py new file mode 100644 index 0000000..60310cc --- /dev/null +++ b/src/easydynamics/sample_model/sample_model.py @@ -0,0 +1,473 @@ + +from typing import Dict, List, Union, Tuple + +import numpy as np + +from easyscience.variable import Parameter +from easyscience.base_classes import ObjBase + +from easydynamics.utils import detailed_balance_factor +from .components import ModelComponent + +import scipp as sc + + +class SampleModel(ObjBase): + """ + A model of the scattering from a sample, combining multiple model components. + Optionally applies detailed balancing. + + Attributes + ---------- + components : dict + Dictionary of model components keyed by name. + """ + def __init__(self, name: str = "MySampleModel", temperature: Union[float, None] = None): + """ + Initialize a new SampleModel. + + Parameters + ---------- + name : str + Name of the sample model. + temperature : float or None, optional + """ + + self.components: Dict[str, ModelComponent] = {} + super().__init__(name=name) + if temperature is not None: + self._temperature = Parameter(name="temperature", value=temperature, unit='K', fixed=True) + self._use_detailed_balance = True + else: + self._temperature=None + self._use_detailed_balance = False + + def add_component(self, component: ModelComponent): + """ + Add a model component to the SampleModel. Component names must be unique. + """ + if component.name in self.components: + raise ValueError(f"Component with name '{component.name}' already exists.") + self.components[component.name] = component + + def remove_component(self, name: str): + """ + Remove a model component by name. + + Parameters + ---------- + name : str + Name of the component to remove. + + """ + if name not in self.components: + raise KeyError(f"No component named '{name}' exists in the model.") + del self.components[name] + + def list_components(self) -> List[str]: + """ + List the names of all components in the model. + + Returns + ------- + List[str] + Component names. + """ + return list(self.components.keys()) + + def clear_components(self): + """ + Remove all components from the model. + """ + self.components.clear() + + def __getitem__(self, key: str) -> ModelComponent: + """ + Access a component by name. + + Parameters + ---------- + key : str + Name of the component. + + Returns + ------- + ModelComponent + """ + return self.components[key] + + def __setitem__(self, key: str, value: ModelComponent): + """ + Set or replace a component by name using dictionary-like syntax. + + Parameters + ---------- + key : str + Name of the component. + value : ModelComponent + The component to assign. + """ + self.components[key] = value + + def __contains__(self, name: str) -> bool: + """ + Check if a component exists in the model. + + Parameters + ---------- + name : str + Name of the component. + + Returns + ------- + bool + """ + return name in self.components + + def __repr__(self): + """ + Return a string representation of the SampleModel. + + Returns + ------- + str + """ + comp_names = ", ".join(self.components.keys()) or "No components" + temp_str = (f" | Temperature: {self._temperature.value} {self._temperature.unit}" + if self._use_detailed_balance else "") + return (f"") + + @property + def temperature(self) -> Parameter: + """ + Access the temperature parameter. + + Returns + ------- + Parameter + """ + return self._temperature + + @temperature.setter + def temperature(self, value: Union[float, None], unit: str = 'K'): + """ + Set the temperature and enables detailed balance if value is non-negative. + + Parameters + ---------- + value : float + Temperature value. + unit : str, default 'K' + Unit of the temperature. + """ + if value is None: + self._use_detailed_balance = False + self._temperature = None + return + + if value < 0: + raise ValueError("Temperature must be non-negative.") + + if isinstance(self._temperature, Parameter): + self._temperature.value = value + else: + self._temperature = Parameter(name="temperature", value=value, unit=unit, fixed=True) + + if not self.use_detailed_balance: + self.use_detailed_balance = value >= 0 + + @property + def use_detailed_balance(self) -> bool: + """ + Indicates whether detailed balance is enabled. + + Returns + ------- + bool + """ + return self._use_detailed_balance + + @use_detailed_balance.setter + def use_detailed_balance(self, value: bool): + """ + Enable or disable the use of detailed balance. + + Parameters + ---------- + value : bool + True to enable, False to disable. + """ + self._use_detailed_balance = value + + def evaluate(self, x: Union[float,np.ndarray,sc.Variable]) -> np.ndarray: + """ + Evaluate the sum of all components, optionally applying detailed balance. + + Parameters + ---------- + x : np.ndarray or scipp.array + + Returns + ------- + np.ndarray + Evaluated model values. + """ + result = np.zeros_like(x, dtype=float) + for component in self.components.values(): + result += component.evaluate(x) + + #TODO: handle units properly + if self.use_detailed_balance and self._temperature.value >= 0: + result *= detailed_balance_factor(x, self._temperature.value) + + return result + + def evaluate_component(self, name: str, x: Union[float,np.ndarray,sc.Variable]) -> np.ndarray: + """ + Evaluate a single component by name, optionally applying detailed balance. + + Parameters + ---------- + name : str + Component name. + x : np.ndarray + Energy axis. + + Returns + ------- + np.ndarray + Evaluated values for the specified component. + + Raises + ------ + KeyError + If the component is not found. + """ + if name not in self.components: + raise KeyError(f"No component named '{name}' exists.") + + result = self.components[name].evaluate(x) + if self._use_detailed_balance and self._temperature.value >= 0: + result *= detailed_balance_factor(x, self._temperature.value) + + return result + + def normalize_area(self): + """ + Normalize the areas of all components so they sum to 1. + """ + area_params = [] + total_area = 0.0 + + for component in self.components.values(): + for param in component.get_parameters(): + if 'area' in param.name.lower(): + area_params.append(param) + total_area += param.value + + if total_area == 0: + raise ValueError("Total area is zero; cannot normalize.") + + for param in area_params: + param.value /= total_area + + def get_parameters(self) -> List[Parameter]: + """ + Return all parameters from the model, including temperature. + + Returns + ------- + List[Parameter] + """ + if isinstance(self._temperature, Parameter): + params = [self._temperature] + else: + params = [] + for comp in self.components.values(): + params.extend(comp.get_parameters()) + return params + + def get_fit_parameters(self): + """ + Get all fit parameters, removing fixed and dependent parameters. + + Returns: + List[Parameter]: A list of fit parameters. + """ + + parameters = self.get_parameters() + fit_parameters = [] + + for parameter in parameters: + is_not_fixed = not getattr(parameter, 'fixed', False) + is_independent = getattr(parameter, '_independent', True) + + if is_not_fixed and is_independent: + fit_parameters.append(parameter) + + return fit_parameters + + + def fix_all_parameters(self): + """ + Fix all unfixed parameters in the model. + """ + for param in self.get_parameters(): + param.fixed = True + + def free_all_parameters(self): + """ + Free all fixed parameters in the model. + """ + for param in self.get_parameters(): + param.fixed = False + + def fix_all_component_parameters(self,component_name: str): + """ + Fix all unfixed parameters in the specified component. + """ + if component_name not in self.components: + raise ValueError(f"Component '{component_name}' not found.") + + self.components[component_name].fix_all_parameters() + + def free_all_component_parameters(self, component_name: str): + """ + Free all fixed parameters in the specified component. + """ + if component_name not in self.components: + raise ValueError(f"Component '{component_name}' not found.") + + self.components[component_name].free_all_parameters() + + def fix_component_parameter(self,component_name: str, parameter_name: str): + """ + Fix a specific parameter in the specified component. + """ + if component_name not in self.components: + raise ValueError(f"Component '{component_name}' not found.") + + component = self.components[component_name] + param = component.get_parameter(parameter_name) + if param is None: + raise ValueError(f"Parameter '{parameter_name}' not found in component '{component_name}'.") + + param.fixed = True + + def free_component_parameter(self, component_name: str, parameter_name: str): + """ + Free a specific parameter in the specified component. + """ + if component_name not in self.components: + raise ValueError(f"Component '{component_name}' not found.") + + component = self.components[component_name] + param = component.get_parameter(parameter_name) + if param is None: + raise ValueError(f"Parameter '{parameter_name}' not found in component '{component_name}'.") + + param.fixed = False + + def update_values_from( + self, + other: "SampleModel", + *, + only_free: bool = True, + )-> Dict[str, Tuple[float, float]]: + """ + Overwrite this model's Parameter.values from another SampleModel, matching by + component name and Parameter.name. This is used to copy fit results when doing sequential fitting. + + Parameters + ---------- + other : SampleModel + Source of values. + only_free : bool, default True + If True, skip Parameters in *self* that are fixed. + + Returns + ------- + Dict[str, Tuple[float, float]] + Mapping key -> (old_value, new_value), where key is + ".". + + """ + if not isinstance(other, SampleModel): + raise TypeError("other must be a SampleModel") + + report: Dict[str, Tuple[float, float]] = {} + + # Check that components are the same + self_names = set(self.components.keys()) + other_names = set(other.components.keys()) + + if self_names != other_names: + missing = self_names - other_names + extra = other_names - self_names + raise ValueError( + f"Component name mismatch.\n" + f" Missing in source: {missing or '{}'}\n" + f" Extra in source: {extra or '{}'}" + ) + + + # Go through components + for cname in self_names: + c_self = self.components[cname] + c_other = other.components[cname] + + # Check that parameters are the same + self_params = {p.name: p for p in c_self.get_parameters()} + other_params = {p.name: p for p in c_other.get_parameters()} + + if set(self_params) != set(other_params): + missing = set(self_params) - set(other_params) + extra = set(other_params) - set(self_params) + raise ValueError( + f"Parameter name mismatch in component '{cname}'.\n" + f" Missing in source: {missing or '{}'}\n" + f" Extra in source: {extra or '{}'}" + ) + + + for pname in set(self_params): + p_self = self_params[pname] + p_other = other_params[pname] + + if only_free and getattr(p_self, "fixed", False): + continue + + # Units: convert units to other's unit if they differ + u_self = getattr(p_self, "unit", None) + u_other = getattr(p_other, "unit", None) + if u_self != u_other: + p_self.convert_unit(u_other) + + # Update value, but save the old one. + old = p_self.value + p_self.value = p_other.value + report[f"{cname}.{pname}"] = (old, p_self.value) + + return report + + + + def copy(self) -> "SampleModel": + """ + Create a deep copy of the SampleModel with independent parameters. + + Returns + ------- + SampleModel + A new instance with copied components and parameters. + """ + + new_model = SampleModel(name=self.name, temperature=self._temperature.value if self._temperature else None) + + new_model.use_detailed_balance = self._use_detailed_balance + + for comp in self.components.values(): + new_model.add_component(comp.copy()) + + return new_model diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py new file mode 100644 index 0000000..bd9a606 --- /dev/null +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -0,0 +1,261 @@ +import pytest +import numpy as np +from scipy.integrate import simpson + +from easyscience.variable import Parameter +from easydynamics.sample import SampleModel, Gaussian, Lorentzian +from easydynamics.sample.components import ModelComponent +from easydynamics.utils import detailed_balance_factor + +class TestSampleModel: + @pytest.fixture + def sample_model(self): + return SampleModel(name="TestSampleModel") + + # ───── Component Management ───── + + def test_add_component(self, sample_model): + #When + component = Gaussian(name="TestComponent", area=1.0, center=0.0, width=1.0, unit='meV') + #Then + sample_model.add_component(component) + #Expect + assert "TestComponent" in sample_model.components + + def test_add_duplicate_component_raises(self, sample_model): + #When + component = Gaussian(name="Dup", area=1.0, center=0.0, width=1.0, unit='meV') + #Then + sample_model.add_component(component) + #Expect + with pytest.raises(ValueError, match="already exists"): + sample_model.add_component(component) + + def test_remove_component(self, sample_model): + #When + component = Gaussian(name="TestComponent", area=1.0, center=0.0, width=1.0, unit='meV') + #Then + sample_model.add_component(component) + sample_model.remove_component("TestComponent") + #Expect + assert "TestComponent" not in sample_model.components + + def test_remove_nonexistent_component_raises(self, sample_model): + #When Then Expect + with pytest.raises(KeyError, match="No component named 'NonExistentComponent' exists"): + sample_model.remove_component("NonExistentComponent") + + def test_getitem(self, sample_model): + #When + component = Gaussian(name="TestComponent", area=1.0, center=0.0, width=1.0, unit='meV') + #Then + sample_model.add_component(component) + #Expect + assert sample_model["TestComponent"] is component + + def test_setitem(self, sample_model): + #When + component = ModelComponent(name="TestComponent") + #Then + sample_model["TestComponent"] = component + #Expect + assert sample_model["TestComponent"] is component + + def test_contains_component(self, sample_model): + #When + component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + #Then + sample_model.add_component(component) + #Expect + assert "TestGaussian" in sample_model + assert "NonExistentComponent" not in sample_model + + def test_list_components(self, sample_model): + #When + component1 = Gaussian(name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit='meV') + component2 = Gaussian(name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit='meV') + sample_model.add_component(component1) + sample_model.add_component(component2) + #Then + components = sample_model.list_components() + #Expect + assert len(components) == 2 + assert components[0] == 'TestGaussian1' + assert components[1] == 'TestGaussian2' + + def test_clear_components(self, sample_model): + #when + component1 = Gaussian(name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit='meV') + component2 = Gaussian(name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit='meV') + sample_model.add_component(component1) + sample_model.add_component(component2) + #Then + sample_model.clear_components() + #Expect + assert len(sample_model.components) == 0 + + # ───── Temperature and Detailed Balance ───── + + def test_temperature_init(self, sample_model): + # When Then Expect + assert sample_model._temperature is None + assert sample_model._use_detailed_balance is False + # assert sample_model._temperature.unit == 'K' + + def test_set_temperature(self, sample_model): + # When Then + sample_model.temperature = 300 + # Expect + assert sample_model._temperature.value == 300 + assert sample_model._temperature.unit == 'K' + assert sample_model._use_detailed_balance is True + + def test_negative_temperature_throws(self, sample_model): + # When + sample_model.use_detailed_balance = True + # Then Expect + with pytest.raises(ValueError, match="Temperature must be non-negative"): + sample_model.temperature = -50 + + def test_use_detailed_balance(self, sample_model): + # When Then Expect + assert sample_model._use_detailed_balance is False + sample_model._use_detailed_balance = True + assert sample_model._use_detailed_balance is True + sample_model._use_detailed_balance = False + assert sample_model._use_detailed_balance is False + + # ───── Evaluation ───── + + def test_evaluate(self, sample_model): + # When + component1 = Gaussian(name="Gaussian1", area=1.0, center=0.0, width=1.0, unit='meV') + component2 = Lorentzian(name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit='meV') + sample_model.add_component(component1) + sample_model.add_component(component2) + # Then + x = np.linspace(-5, 5, 100) + result = sample_model.evaluate(x) + # Expect + expected_result = component1.evaluate(x) + component2.evaluate(x) + np.testing.assert_allclose(result, expected_result, rtol=1e-5) + + def test_evaluate_with_detailed_balance(self, sample_model): + # When + sample_model.temperature = 300 + component1 = Gaussian(name="Gaussian1", area=1.0, center=0.0, width=1.0, unit='meV') + component2 = Lorentzian(name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit='meV') + sample_model.add_component(component1) + sample_model.add_component(component2) + x = np.linspace(-5, 5, 100) + # Then + result = sample_model.evaluate(x) + # Expect + expected_result = component1.evaluate(x) + component2.evaluate(x) + expected_result *= detailed_balance_factor(x, sample_model._temperature.value) + np.testing.assert_allclose(result, expected_result, rtol=1e-5) + + def test_evaluate_component(self, sample_model): + # When + component1 = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + component2 = Lorentzian(name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit='meV') + sample_model.add_component(component1) + sample_model.add_component(component2) + + # Then + x = np.linspace(-5, 5, 100) + result1 = sample_model.evaluate_component("TestGaussian", x) + result2 = sample_model.evaluate_component("TestLorentzian", x) + # Expect + expected_result1 = component1.evaluate(x) + expected_result2 = component2.evaluate(x) + np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) + np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) + + def test_evaluate_component_with_detailed_balance(self, sample_model): + # When + component1 = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + component2 = Lorentzian(name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit='meV') + sample_model.add_component(component1) + sample_model.add_component(component2) + sample_model.temperature = 300 + # Then + x = np.linspace(-5, 5, 100) + result1 = sample_model.evaluate_component('TestGaussian', x) + result2 = sample_model.evaluate_component('TestLorentzian', x) + # Expect + expected_result1 = component1.evaluate(x) + expected_result2 = component2.evaluate(x) + expected_result1 *= detailed_balance_factor(x, sample_model._temperature.value) + expected_result2 *= detailed_balance_factor(x, sample_model._temperature.value) + np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) + np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) + + def test_evaluate_nonexistent_component_raises(self, sample_model): + # When Then Expect + x = np.linspace(-5, 5, 100) + with pytest.raises(KeyError, match="No component named 'NonExistentComponent' exists"): + sample_model.evaluate_component("NonExistentComponent", x) + + # ───── Utilities ───── + + def test_normalize_area(self, sample_model): + # When + component1 = Gaussian(name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit='meV') + component2 = Gaussian(name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit='meV') + sample_model.add_component(component1) + sample_model.add_component(component2) + # Then + sample_model.normalize_area() + # Expect + x = np.linspace(-10, 10, 1000) + result = sample_model.evaluate(x) + numerical_area = simpson(result, x) + assert np.isclose(numerical_area, 1.0) + + def test_get_parameters(self, sample_model): + # When + component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + sample_model.add_component(component) + # Then + parameters = sample_model.get_parameters() + # Expect + assert len(parameters) == 3 + assert parameters[0].name == 'TestGaussian area' + assert parameters[1].name == 'TestGaussian center' + assert parameters[2].name == 'TestGaussian width' + assert all(isinstance(param, Parameter) for param in parameters) + + def test_get_parameters_no_components(self, sample_model): + # When Then + parameters = sample_model.get_parameters() + # Expect + assert len(parameters) == 0 + + def test_repr_contains_name_and_components(self, sample_model): + # When + component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + sample_model.add_component(component) + # Then + rep = repr(sample_model) + # Expect + assert "SampleModel" in rep + assert "TestGaussian" in rep + + # def test_repr_no_components(self, sample_model): + # # When Then + # rep = repr(sample_model) + # # Expect + # assert "SampleModel" in rep + # assert "Components: None" in rep + + def test_str_contains_name_and_components(self, sample_model): + # When + component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + sample_model.add_component(component) + # Then + str_repr = str(sample_model) + # Expect + assert "SampleModel" in str_repr + assert "TestGaussian" in str_repr + From a782693762cc6edbf3b0635d99ddd2e8be97b6e4 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Wed, 15 Oct 2025 12:00:09 +0200 Subject: [PATCH 02/44] Clean up, fix tests --- ...mponent_example.ipynb => components.ipynb} | 0 examples/sample_model.ipynb | 202 +++++++ src/easydynamics/sample_model/__init__.py | 1 + src/easydynamics/sample_model/sample_model.py | 505 +++++++++--------- .../sample_model/test_sample_model.py | 230 +++++--- 5 files changed, 621 insertions(+), 317 deletions(-) rename examples/{component_example.ipynb => components.ipynb} (100%) create mode 100644 examples/sample_model.ipynb diff --git a/examples/component_example.ipynb b/examples/components.ipynb similarity index 100% rename from examples/component_example.ipynb rename to examples/components.ipynb diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb new file mode 100644 index 0000000..fa70738 --- /dev/null +++ b/examples/sample_model.ipynb @@ -0,0 +1,202 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "64deaa41", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "from easydynamics.sample_model import Gaussian\n", + "from easydynamics.sample_model import Lorentzian\n", + "from easydynamics.sample_model import DampedHarmonicOscillator\n", + "from easydynamics.sample_model import Polynomial\n", + "from easydynamics.sample_model import DeltaFunction\n", + "from easydynamics.sample_model import SampleModel\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "784d9e82", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "85c000d048fa447c92f106becdf27e5f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample_model=SampleModel(name='sample_model')\n", + "\n", + "# Creating components\n", + "gaussian=Gaussian(name='Gaussian',width=0.5,area=1)\n", + "dho = DampedHarmonicOscillator(name='DHO',center=1.0,width=0.3,area=2.0)\n", + "lorentzian = Lorentzian(name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", + "polynomial = Polynomial(name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", + "\n", + "sample_model.add_component(gaussian)\n", + "sample_model.add_component(dho)\n", + "sample_model.add_component(lorentzian)\n", + "sample_model.add_component(polynomial)\n", + "\n", + "\n", + "x=np.linspace(-2, 2, 100)\n", + "\n", + "plt.figure()\n", + "y=sample_model.evaluate(x)\n", + "plt.plot(x, y, label='Sample Model')\n", + "\n", + "for component in sample_model.components.values():\n", + " y = component.evaluate(x)\n", + " plt.plot(x, y, label=component.name)\n", + "\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ac7061fd", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fbcf9802343e43e0a89319740a8bf595", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample_model=SampleModel(name='sample_model')\n", + "sample_model.temperature=5\n", + "sample_model.use_detailed_balance=True\n", + "sample_model.normalise_detailed_balance=True\n", + "\n", + "# Creating components\n", + "gaussian=Gaussian(name='Gaussian',width=0.5,area=1)\n", + "dho = DampedHarmonicOscillator(name='DHO',center=1.0,width=0.3,area=2.0)\n", + "lorentzian = Lorentzian(name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", + "polynomial = Polynomial(name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", + "\n", + "sample_model.add_component(gaussian)\n", + "sample_model.add_component(dho)\n", + "sample_model.add_component(lorentzian)\n", + "sample_model.add_component(polynomial)\n", + "\n", + "\n", + "x=np.linspace(-2, 2, 100)\n", + "\n", + "plt.figure()\n", + "y=sample_model.evaluate(x)\n", + "plt.plot(x, y, label='Sample Model')\n", + "\n", + "for component in sample_model.values():\n", + " y=sample_model.evaluate_component(x,component.name)\n", + " plt.plot(x, y, label=component.name)\n", + "\n", + "plt.legend()\n", + "plt.title('Sample model at 5 K with detailed balance')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bd1e57cd", + "metadata": {}, + "outputs": [], + "source": [ + "sample_model['Gaussian'].fix_all_parameters()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "115f672d", + "metadata": {}, + "outputs": [], + "source": [ + "sample_mode=SampleModel(name=\"TestSampleModel\")\n", + "component1 = Gaussian(\n", + " name=\"TestGaussian\", area=1.0, center=0.0, width=1.0, unit=\"meV\"\n", + ")\n", + "component2 = Lorentzian(\n", + " name=\"TestLorentzian\", area=2.0, center=1.0, width=0.5, unit=\"meV\"\n", + ")\n", + "sample_model.add_component(component1)\n", + "sample_model.add_component(component2)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "newdynamics", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/easydynamics/sample_model/__init__.py b/src/easydynamics/sample_model/__init__.py index a64ffd2..2b1274f 100644 --- a/src/easydynamics/sample_model/__init__.py +++ b/src/easydynamics/sample_model/__init__.py @@ -6,6 +6,7 @@ Polynomial, Voigt, ) +from .sample_model import SampleModel __all__ = [ "SampleModel", diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 60310cc..1726be4 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -1,18 +1,22 @@ - -from typing import Dict, List, Union, Tuple +import warnings +from collections.abc import MutableMapping +from copy import copy +from typing import Dict, List, Optional, Union import numpy as np - -from easyscience.variable import Parameter +import scipp as sc from easyscience.base_classes import ObjBase +from easyscience.variable import Parameter +from scipp import UnitError -from easydynamics.utils import detailed_balance_factor -from .components import ModelComponent +from easydynamics.utils import _detailed_balance_factor as detailed_balance_factor -import scipp as sc +from .components.model_component import ModelComponent +Numeric = Union[float, int] -class SampleModel(ObjBase): + +class SampleModel(ObjBase, MutableMapping): """ A model of the scattering from a sample, combining multiple model components. Optionally applies detailed balancing. @@ -21,8 +25,22 @@ class SampleModel(ObjBase): ---------- components : dict Dictionary of model components keyed by name. + temperature : Parameter + Temperature parameter for detailed balance. + use_detailed_balance : bool + Whether to apply detailed balance. + normalise_detailed_balance : bool + Whether to normalise the detailed balance by temperature. + name : str + Name of the SampleModel. """ - def __init__(self, name: str = "MySampleModel", temperature: Union[float, None] = None): + + def __init__( + self, + name: str = "MySampleModel", + temperature: Optional[Union[Numeric, None]] = None, + temperature_unit: Optional[str] = "K", + ): """ Initialize a new SampleModel. @@ -30,25 +48,53 @@ def __init__(self, name: str = "MySampleModel", temperature: Union[float, None] ---------- name : str Name of the sample model. - temperature : float or None, optional + temperature : Number or None, optional + Temperature for detailed balance. + temperature_unit : str, default 'K' + Unit of the temperature. """ - + self.components: Dict[str, ModelComponent] = {} super().__init__(name=name) + # If temperature is given, create a Parameter and enable detailed balance. if temperature is not None: - self._temperature = Parameter(name="temperature", value=temperature, unit='K', fixed=True) + self._temperature = Parameter( + name="temperature", value=temperature, unit=temperature_unit, fixed=True + ) self._use_detailed_balance = True else: - self._temperature=None + self._temperature = None self._use_detailed_balance = False - def add_component(self, component: ModelComponent): + self._normalise_detailed_balance = ( + True # Whether to normalise by temperature when using detailed balance. + ) + + ############################################## + # Methods for managing components # + ############################################## + + def add_component( + self, component: ModelComponent, name: Optional[str] = None + ) -> None: """ Add a model component to the SampleModel. Component names must be unique. + Parameters + ---------- + component : ModelComponent + The model component to add. + name : str, optional + Name to assign to the component. If None, uses the component's own name. """ - if component.name in self.components: - raise ValueError(f"Component with name '{component.name}' already exists.") - self.components[component.name] = component + if name is None: + name = component.name + if name in self.components: + raise ValueError(f"Component with name '{name}' already exists.") + + if not isinstance(component, ModelComponent): + raise TypeError("component must be an instance of ModelComponent.") + + self.components[name] = component def remove_component(self, name: str): """ @@ -58,8 +104,8 @@ def remove_component(self, name: str): ---------- name : str Name of the component to remove. - """ + if name not in self.components: raise KeyError(f"No component named '{name}' exists in the model.") del self.components[name] @@ -73,75 +119,47 @@ def list_components(self) -> List[str]: List[str] Component names. """ + return list(self.components.keys()) def clear_components(self): """ Remove all components from the model. """ - self.components.clear() - - def __getitem__(self, key: str) -> ModelComponent: - """ - Access a component by name. - - Parameters - ---------- - key : str - Name of the component. - - Returns - ------- - ModelComponent - """ - return self.components[key] - def __setitem__(self, key: str, value: ModelComponent): - """ - Set or replace a component by name using dictionary-like syntax. + self.components.clear() - Parameters - ---------- - key : str - Name of the component. - value : ModelComponent - The component to assign. + def normalize_area(self) -> None: + # Useful for convolutions. """ - self.components[key] = value - - def __contains__(self, name: str) -> bool: + Normalize the areas of all components so they sum to 1. """ - Check if a component exists in the model. + area_params = [] + total_area = 0.0 - Parameters - ---------- - name : str - Name of the component. + for component in self.components.values(): + if hasattr(component, "area"): + area_params.append(component.area) + total_area += component.area.value + else: + warnings.warn( + f"Component '{component.name}' does not have an 'area' attribute and will be skipped in normalization." + ) - Returns - ------- - bool - """ - return name in self.components + if total_area == 0: + raise ValueError("Total area is zero; cannot normalize.") - def __repr__(self): - """ - Return a string representation of the SampleModel. + for param in area_params: + param.value /= total_area - Returns - ------- - str - """ - comp_names = ", ".join(self.components.keys()) or "No components" - temp_str = (f" | Temperature: {self._temperature.value} {self._temperature.unit}" - if self._use_detailed_balance else "") - return (f"") + ########################################################## + # Methods for temperature and detailed balance # + ########################################################## @property def temperature(self) -> Parameter: """ - Access the temperature parameter. + Get the temperature. Returns ------- @@ -150,37 +168,56 @@ def temperature(self) -> Parameter: return self._temperature @temperature.setter - def temperature(self, value: Union[float, None], unit: str = 'K'): + def temperature(self, value: Union[Numeric, None]): """ - Set the temperature and enables detailed balance if value is non-negative. + Set the temperature. Parameters ---------- - value : float - Temperature value. - unit : str, default 'K' - Unit of the temperature. + value : Number + Temperature value. If None, removes temperature and disables detailed balance. """ + # If None, disable detailed balance and remove temperature parameter. if value is None: self._use_detailed_balance = False self._temperature = None return + if not isinstance(value, Numeric): + raise TypeError("Temperature must be a number or None.") + value = float(value) + if value < 0: raise ValueError("Temperature must be non-negative.") if isinstance(self._temperature, Parameter): self._temperature.value = value else: - self._temperature = Parameter(name="temperature", value=value, unit=unit, fixed=True) + self._temperature = Parameter( + name="temperature", value=value, unit="K", fixed=True + ) + + def convert_temperature_unit(self, new_unit: Union[str, sc.Unit]): + """ + Convert the temperature parameter to a new unit. + + Parameters + ---------- + new_unit : str or sc.Unit + The new unit for the temperature. + """ + if self._temperature is None: + raise ValueError("Temperature is not set; cannot convert units.") - if not self.use_detailed_balance: - self.use_detailed_balance = value >= 0 + try: + self._temperature.convert_unit(new_unit) + except Exception as e: + raise UnitError(f"Failed to convert temperature to unit '{new_unit}': {e}") @property def use_detailed_balance(self) -> bool: """ - Indicates whether detailed balance is enabled. + True if detailed balance is enabled, otherwise False. Returns ------- @@ -189,9 +226,9 @@ def use_detailed_balance(self) -> bool: return self._use_detailed_balance @use_detailed_balance.setter - def use_detailed_balance(self, value: bool): + def use_detailed_balance(self, value: bool) -> None: """ - Enable or disable the use of detailed balance. + If True, enables the use of detailed balance. Otherwise disables it. Parameters ---------- @@ -200,81 +237,98 @@ def use_detailed_balance(self, value: bool): """ self._use_detailed_balance = value - def evaluate(self, x: Union[float,np.ndarray,sc.Variable]) -> np.ndarray: + @property + def normalise_detailed_balance(self) -> bool: + """ + If True, detailed balance will be normalised by temperature. If False, it will not be normalised. + + """ + return self._normalise_detailed_balance + + @normalise_detailed_balance.setter + def normalise_detailed_balance(self, value: bool) -> None: + """ + If True, normalises the detailed balance by temperature. + + Parameters + ---------- + value : bool + True to normalise, False otherwise. + """ + self._normalise_detailed_balance = value + + ########################################################## + # Evaluate # + ########################################################## + + def evaluate( + self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + ) -> np.ndarray: """ Evaluate the sum of all components, optionally applying detailed balance. Parameters ---------- - x : np.ndarray or scipp.array + x : Number, list, np.ndarray, sc.Variable, or sc.DataArray + Energy axis. Returns ------- np.ndarray Evaluated model values. """ - result = np.zeros_like(x, dtype=float) - for component in self.components.values(): - result += component.evaluate(x) - - #TODO: handle units properly + result = sum( + (component.evaluate(x) for component in self.components.values()), 0 + ) if self.use_detailed_balance and self._temperature.value >= 0: - result *= detailed_balance_factor(x, self._temperature.value) + result *= detailed_balance_factor( + energy=x, + temperature=self._temperature, + divide_by_temperature=self._normalise_detailed_balance, + ) return result - def evaluate_component(self, name: str, x: Union[float,np.ndarray,sc.Variable]) -> np.ndarray: + def evaluate_component( + self, + x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray], + name: str, + ) -> np.ndarray: """ Evaluate a single component by name, optionally applying detailed balance. Parameters ---------- + x : Number, list, np.ndarray, sc.Variable, or sc.DataArray + Energy axis. name : str Component name. - x : np.ndarray - Energy axis. Returns ------- np.ndarray Evaluated values for the specified component. - - Raises - ------ - KeyError - If the component is not found. """ if name not in self.components: raise KeyError(f"No component named '{name}' exists.") result = self.components[name].evaluate(x) - if self._use_detailed_balance and self._temperature.value >= 0: - result *= detailed_balance_factor(x, self._temperature.value) + if self.use_detailed_balance and self._temperature.value >= 0: + result *= detailed_balance_factor( + energy=x, + temperature=self._temperature, + divide_by_temperature=self._normalise_detailed_balance, + ) return result - def normalize_area(self): - """ - Normalize the areas of all components so they sum to 1. - """ - area_params = [] - total_area = 0.0 - - for component in self.components.values(): - for param in component.get_parameters(): - if 'area' in param.name.lower(): - area_params.append(param) - total_area += param.value - - if total_area == 0: - raise ValueError("Total area is zero; cannot normalize.") - - for param in area_params: - param.value /= total_area + ############################################## + # Methods for managing parameters # + ############################################## def get_parameters(self) -> List[Parameter]: """ - Return all parameters from the model, including temperature. + Return all parameters in the SampleModel. Returns ------- @@ -287,8 +341,8 @@ def get_parameters(self) -> List[Parameter]: for comp in self.components.values(): params.extend(comp.get_parameters()) return params - - def get_fit_parameters(self): + + def get_fit_parameters(self) -> List[Parameter]: """ Get all fit parameters, removing fixed and dependent parameters. @@ -298,176 +352,141 @@ def get_fit_parameters(self): parameters = self.get_parameters() fit_parameters = [] - + for parameter in parameters: - is_not_fixed = not getattr(parameter, 'fixed', False) - is_independent = getattr(parameter, '_independent', True) - + is_not_fixed = not getattr(parameter, "fixed", False) + is_independent = getattr(parameter, "_independent", True) + if is_not_fixed and is_independent: fit_parameters.append(parameter) - + return fit_parameters - - def fix_all_parameters(self): + def fix_all_parameters(self) -> None: """ - Fix all unfixed parameters in the model. + Fix all free parameters in the model. """ for param in self.get_parameters(): param.fixed = True - def free_all_parameters(self): + def free_all_parameters(self) -> None: """ Free all fixed parameters in the model. """ for param in self.get_parameters(): param.fixed = False - def fix_all_component_parameters(self,component_name: str): - """ - Fix all unfixed parameters in the specified component. - """ - if component_name not in self.components: - raise ValueError(f"Component '{component_name}' not found.") - - self.components[component_name].fix_all_parameters() + ############################################## + # dunder methods # + ############################################## - def free_all_component_parameters(self, component_name: str): + def __copy__(self) -> "SampleModel": """ - Free all fixed parameters in the specified component. - """ - if component_name not in self.components: - raise ValueError(f"Component '{component_name}' not found.") - - self.components[component_name].free_all_parameters() + Create a deep copy of the SampleModel with independent parameters. - def fix_component_parameter(self,component_name: str, parameter_name: str): - """ - Fix a specific parameter in the specified component. + Returns + ------- + SampleModel + A new instance with copied components and parameters. """ - if component_name not in self.components: - raise ValueError(f"Component '{component_name}' not found.") - component = self.components[component_name] - param = component.get_parameter(parameter_name) - if param is None: - raise ValueError(f"Parameter '{parameter_name}' not found in component '{component_name}'.") + new_model = SampleModel( + name=self.name, + temperature=self._temperature.value if self._temperature else None, + ) - param.fixed = True + new_model.use_detailed_balance = self._use_detailed_balance - def free_component_parameter(self, component_name: str, parameter_name: str): - """ - Free a specific parameter in the specified component. - """ - if component_name not in self.components: - raise ValueError(f"Component '{component_name}' not found.") + for comp in self.components.values(): + new_model.add_component(copy(comp)) - component = self.components[component_name] - param = component.get_parameter(parameter_name) - if param is None: - raise ValueError(f"Parameter '{parameter_name}' not found in component '{component_name}'.") + return new_model - param.fixed = False + ############################################## + # dict-like behaviour # + ############################################## - def update_values_from( - self, - other: "SampleModel", - *, - only_free: bool = True, - )-> Dict[str, Tuple[float, float]]: + def __getitem__(self, key: str) -> ModelComponent: """ - Overwrite this model's Parameter.values from another SampleModel, matching by - component name and Parameter.name. This is used to copy fit results when doing sequential fitting. + Access a component by name. Parameters ---------- - other : SampleModel - Source of values. - only_free : bool, default True - If True, skip Parameters in *self* that are fixed. + key : str + Name of the component. Returns ------- - Dict[str, Tuple[float, float]] - Mapping key -> (old_value, new_value), where key is - ".". - + ModelComponent """ - if not isinstance(other, SampleModel): - raise TypeError("other must be a SampleModel") - - report: Dict[str, Tuple[float, float]] = {} - - # Check that components are the same - self_names = set(self.components.keys()) - other_names = set(other.components.keys()) - - if self_names != other_names: - missing = self_names - other_names - extra = other_names - self_names - raise ValueError( - f"Component name mismatch.\n" - f" Missing in source: {missing or '{}'}\n" - f" Extra in source: {extra or '{}'}" - ) - + return self.components[key] - # Go through components - for cname in self_names: - c_self = self.components[cname] - c_other = other.components[cname] + def __setitem__(self, key: str, value: ModelComponent) -> None: + """ + Set or replace a component. - # Check that parameters are the same - self_params = {p.name: p for p in c_self.get_parameters()} - other_params = {p.name: p for p in c_other.get_parameters()} + Parameters + ---------- + key : str + Name of the component. + value : ModelComponent + The component to assign. + """ + if not isinstance(value, ModelComponent): + raise TypeError("Value must be an instance of ModelComponent.") + self.components[key] = value - if set(self_params) != set(other_params): - missing = set(self_params) - set(other_params) - extra = set(other_params) - set(self_params) - raise ValueError( - f"Parameter name mismatch in component '{cname}'.\n" - f" Missing in source: {missing or '{}'}\n" - f" Extra in source: {extra or '{}'}" - ) + def __delitem__(self, key: str) -> None: + """ + Remove a component by name. + Parameters + ---------- + key : str + Name of the component to remove. + """ + if not isinstance(key, str): + raise TypeError("Key must be a string.") + if key not in self.components: + raise KeyError(f"No component named '{key}' exists in the model.") - for pname in set(self_params): - p_self = self_params[pname] - p_other = other_params[pname] + self.remove_component(key) - if only_free and getattr(p_self, "fixed", False): - continue + def __contains__(self, name: str) -> bool: + """ + Check if a component exists in the model. - # Units: convert units to other's unit if they differ - u_self = getattr(p_self, "unit", None) - u_other = getattr(p_other, "unit", None) - if u_self != u_other: - p_self.convert_unit(u_other) + Parameters + ---------- + name : str + Name of the component. - # Update value, but save the old one. - old = p_self.value - p_self.value = p_other.value - report[f"{cname}.{pname}"] = (old, p_self.value) + Returns + ------- + bool + """ + return name in self.components - return report + def __iter__(self) -> iter: + """Iterate over component names.""" + return iter(self.components) + def __len__(self) -> int: + """Return the number of components in the model.""" + return len(self.components) - - def copy(self) -> "SampleModel": + def __repr__(self) -> str: """ - Create a deep copy of the SampleModel with independent parameters. + Return a string representation of the SampleModel. Returns ------- - SampleModel - A new instance with copied components and parameters. + str """ - - new_model = SampleModel(name=self.name, temperature=self._temperature.value if self._temperature else None) - - new_model.use_detailed_balance = self._use_detailed_balance - - for comp in self.components.values(): - new_model.add_component(comp.copy()) - - return new_model + comp_names = ", ".join(self.components.keys()) or "No components" + temp_str = ( + f" | Temperature: {self._temperature.value} {self._temperature.unit}" + if self._use_detailed_balance + else "" + ) + return f"" diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index bd9a606..7556533 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -1,11 +1,12 @@ -import pytest import numpy as np +import pytest +from easyscience.variable import Parameter from scipy.integrate import simpson -from easyscience.variable import Parameter -from easydynamics.sample import SampleModel, Gaussian, Lorentzian -from easydynamics.sample.components import ModelComponent -from easydynamics.utils import detailed_balance_factor +from easydynamics.sample_model import Gaussian, Lorentzian, SampleModel +from easydynamics.sample_model.components.model_component import ModelComponent +from easydynamics.utils import _detailed_balance_factor as detailed_balance_factor + class TestSampleModel: @pytest.fixture @@ -15,83 +16,101 @@ def sample_model(self): # ───── Component Management ───── def test_add_component(self, sample_model): - #When - component = Gaussian(name="TestComponent", area=1.0, center=0.0, width=1.0, unit='meV') - #Then + # When + component = Gaussian( + name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" + ) + # Then sample_model.add_component(component) - #Expect + # Expect assert "TestComponent" in sample_model.components def test_add_duplicate_component_raises(self, sample_model): - #When - component = Gaussian(name="Dup", area=1.0, center=0.0, width=1.0, unit='meV') - #Then + # When + component = Gaussian(name="Dup", area=1.0, center=0.0, width=1.0, unit="meV") + # Then sample_model.add_component(component) - #Expect + # Expect with pytest.raises(ValueError, match="already exists"): sample_model.add_component(component) def test_remove_component(self, sample_model): - #When - component = Gaussian(name="TestComponent", area=1.0, center=0.0, width=1.0, unit='meV') - #Then + # When + component = Gaussian( + name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" + ) + # Then sample_model.add_component(component) sample_model.remove_component("TestComponent") - #Expect + # Expect assert "TestComponent" not in sample_model.components def test_remove_nonexistent_component_raises(self, sample_model): - #When Then Expect - with pytest.raises(KeyError, match="No component named 'NonExistentComponent' exists"): + # When Then Expect + with pytest.raises( + KeyError, match="No component named 'NonExistentComponent' exists" + ): sample_model.remove_component("NonExistentComponent") def test_getitem(self, sample_model): - #When - component = Gaussian(name="TestComponent", area=1.0, center=0.0, width=1.0, unit='meV') - #Then + # When + component = Gaussian( + name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" + ) + # Then sample_model.add_component(component) - #Expect + # Expect assert sample_model["TestComponent"] is component def test_setitem(self, sample_model): - #When + # When component = ModelComponent(name="TestComponent") - #Then + # Then sample_model["TestComponent"] = component - #Expect + # Expect assert sample_model["TestComponent"] is component def test_contains_component(self, sample_model): - #When - component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') - #Then + # When + component = Gaussian( + name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) + # Then sample_model.add_component(component) - #Expect + # Expect assert "TestGaussian" in sample_model assert "NonExistentComponent" not in sample_model def test_list_components(self, sample_model): - #When - component1 = Gaussian(name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit='meV') - component2 = Gaussian(name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit='meV') + # When + component1 = Gaussian( + name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Gaussian( + name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit="meV" + ) sample_model.add_component(component1) sample_model.add_component(component2) - #Then + # Then components = sample_model.list_components() - #Expect + # Expect assert len(components) == 2 - assert components[0] == 'TestGaussian1' - assert components[1] == 'TestGaussian2' + assert components[0] == "TestGaussian1" + assert components[1] == "TestGaussian2" def test_clear_components(self, sample_model): - #when - component1 = Gaussian(name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit='meV') - component2 = Gaussian(name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit='meV') + # when + component1 = Gaussian( + name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Gaussian( + name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit="meV" + ) sample_model.add_component(component1) sample_model.add_component(component2) - #Then + # Then sample_model.clear_components() - #Expect + # Expect assert len(sample_model.components) == 0 # ───── Temperature and Detailed Balance ───── @@ -103,12 +122,11 @@ def test_temperature_init(self, sample_model): # assert sample_model._temperature.unit == 'K' def test_set_temperature(self, sample_model): - # When Then + # When Then sample_model.temperature = 300 # Expect assert sample_model._temperature.value == 300 - assert sample_model._temperature.unit == 'K' - assert sample_model._use_detailed_balance is True + assert sample_model._temperature.unit == "K" def test_negative_temperature_throws(self, sample_model): # When @@ -129,8 +147,12 @@ def test_use_detailed_balance(self, sample_model): def test_evaluate(self, sample_model): # When - component1 = Gaussian(name="Gaussian1", area=1.0, center=0.0, width=1.0, unit='meV') - component2 = Lorentzian(name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit='meV') + component1 = Gaussian( + name="Gaussian1", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" + ) sample_model.add_component(component1) sample_model.add_component(component2) # Then @@ -140,69 +162,124 @@ def test_evaluate(self, sample_model): expected_result = component1.evaluate(x) + component2.evaluate(x) np.testing.assert_allclose(result, expected_result, rtol=1e-5) - def test_evaluate_with_detailed_balance(self, sample_model): + @pytest.mark.parametrize( + "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] + ) + def test_evaluate_with_detailed_balance(self, sample_model, normalise_db): # When sample_model.temperature = 300 - component1 = Gaussian(name="Gaussian1", area=1.0, center=0.0, width=1.0, unit='meV') - component2 = Lorentzian(name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit='meV') + component1 = Gaussian( + name="Gaussian1", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" + ) sample_model.add_component(component1) sample_model.add_component(component2) + sample_model.use_detailed_balance = True + sample_model.normalise_detailed_balance = normalise_db + x = np.linspace(-5, 5, 100) + # Then result = sample_model.evaluate(x) + # Expect expected_result = component1.evaluate(x) + component2.evaluate(x) - expected_result *= detailed_balance_factor(x, sample_model._temperature.value) + expected_result *= detailed_balance_factor( + energy=x, + temperature=sample_model._temperature, + divide_by_temperature=normalise_db, + ) np.testing.assert_allclose(result, expected_result, rtol=1e-5) def test_evaluate_component(self, sample_model): # When - component1 = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') - component2 = Lorentzian(name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit='meV') + component1 = Gaussian( + name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" + ) sample_model.add_component(component1) sample_model.add_component(component2) # Then x = np.linspace(-5, 5, 100) - result1 = sample_model.evaluate_component("TestGaussian", x) - result2 = sample_model.evaluate_component("TestLorentzian", x) + result1 = sample_model.evaluate_component(x, "TestGaussian") + result2 = sample_model.evaluate_component(x, "TestLorentzian") + # Expect expected_result1 = component1.evaluate(x) expected_result2 = component2.evaluate(x) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) - def test_evaluate_component_with_detailed_balance(self, sample_model): + @pytest.mark.parametrize( + "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] + ) + def test_evaluate_component_with_detailed_balance(self, sample_model, normalise_db): # When - component1 = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') - component2 = Lorentzian(name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit='meV') + component1 = Gaussian( + name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" + ) sample_model.add_component(component1) sample_model.add_component(component2) sample_model.temperature = 300 + sample_model.use_detailed_balance = True + sample_model.normalise_detailed_balance = normalise_db + # Then x = np.linspace(-5, 5, 100) - result1 = sample_model.evaluate_component('TestGaussian', x) - result2 = sample_model.evaluate_component('TestLorentzian', x) + result1 = sample_model.evaluate_component(x, name="TestGaussian") + result2 = sample_model.evaluate_component(x, name="TestLorentzian") # Expect expected_result1 = component1.evaluate(x) expected_result2 = component2.evaluate(x) - expected_result1 *= detailed_balance_factor(x, sample_model._temperature.value) - expected_result2 *= detailed_balance_factor(x, sample_model._temperature.value) + expected_result1 *= detailed_balance_factor( + energy=x, + temperature=sample_model.temperature, + divide_by_temperature=normalise_db, + ) + expected_result2 *= detailed_balance_factor( + energy=x, + temperature=sample_model.temperature, + divide_by_temperature=normalise_db, + ) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) def test_evaluate_nonexistent_component_raises(self, sample_model): - # When Then Expect + # WHEN + component1 = Gaussian( + name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" + ) + sample_model.add_component(component1) + sample_model.add_component(component2) x = np.linspace(-5, 5, 100) - with pytest.raises(KeyError, match="No component named 'NonExistentComponent' exists"): - sample_model.evaluate_component("NonExistentComponent", x) + + # Then Expect + with pytest.raises( + KeyError, match="No component named 'NonExistentComponent' exists" + ): + sample_model.evaluate_component(x, "NonExistentComponent") # ───── Utilities ───── def test_normalize_area(self, sample_model): # When - component1 = Gaussian(name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit='meV') - component2 = Gaussian(name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit='meV') + component1 = Gaussian( + name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Gaussian( + name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit="meV" + ) sample_model.add_component(component1) sample_model.add_component(component2) # Then @@ -215,15 +292,17 @@ def test_normalize_area(self, sample_model): def test_get_parameters(self, sample_model): # When - component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + component = Gaussian( + name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) sample_model.add_component(component) # Then parameters = sample_model.get_parameters() # Expect assert len(parameters) == 3 - assert parameters[0].name == 'TestGaussian area' - assert parameters[1].name == 'TestGaussian center' - assert parameters[2].name == 'TestGaussian width' + assert parameters[0].name == "TestGaussian area" + assert parameters[1].name == "TestGaussian center" + assert parameters[2].name == "TestGaussian width" assert all(isinstance(param, Parameter) for param in parameters) def test_get_parameters_no_components(self, sample_model): @@ -234,7 +313,9 @@ def test_get_parameters_no_components(self, sample_model): def test_repr_contains_name_and_components(self, sample_model): # When - component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + component = Gaussian( + name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) sample_model.add_component(component) # Then rep = repr(sample_model) @@ -251,11 +332,12 @@ def test_repr_contains_name_and_components(self, sample_model): def test_str_contains_name_and_components(self, sample_model): # When - component = Gaussian(name="TestGaussian", area=1.0, center=0.0, width=1.0, unit='meV') + component = Gaussian( + name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) sample_model.add_component(component) # Then str_repr = str(sample_model) # Expect assert "SampleModel" in str_repr assert "TestGaussian" in str_repr - From 2fb844ba691ebb3bbedb201efe5b8d427633a5b2 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 17 Oct 2025 10:57:53 +0200 Subject: [PATCH 03/44] Improve tests --- examples/sample_model.ipynb | 106 +++- src/easydynamics/sample_model/sample_model.py | 52 +- .../sample_model/test_sample_model.py | 514 ++++++++++-------- 3 files changed, 433 insertions(+), 239 deletions(-) diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb index fa70738..3875874 100644 --- a/examples/sample_model.ipynb +++ b/examples/sample_model.ipynb @@ -32,7 +32,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "85c000d048fa447c92f106becdf27e5f", + "model_id": "85227f7e718342749b433c8067629028", "version_major": 2, "version_minor": 0 }, @@ -93,7 +93,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fbcf9802343e43e0a89319740a8bf595", + "model_id": "f1ca548a33f442258664aaff8e549814", "version_major": 2, "version_minor": 0 }, @@ -161,7 +161,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "id": "115f672d", "metadata": {}, "outputs": [], @@ -176,6 +176,106 @@ "sample_model.add_component(component1)\n", "sample_model.add_component(component2)" ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f4e1fb01", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_mode=SampleModel(name=\"TestSampleModel\")\n", + "not sample_mode.components" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f8cec9a3", + "metadata": {}, + "outputs": [ + { + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mAssertionError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 26\u001b[39m\n\u001b[32m 24\u001b[39m copied_comp = model_copy.components[name]\n\u001b[32m 25\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m copied_comp \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m comp\n\u001b[32m---> \u001b[39m\u001b[32m26\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m copied_comp.name == comp.name\n\u001b[32m 27\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m param_orig, param_copy \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\n\u001b[32m 28\u001b[39m comp.get_parameters(), copied_comp.get_parameters()\n\u001b[32m 29\u001b[39m ):\n\u001b[32m 30\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m param_copy \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m param_orig\n", + "\u001b[31mAssertionError\u001b[39m: " + ] + } + ], + "source": [ + "from copy import copy\n", + "model = SampleModel(name=\"TwoComponentModel\")\n", + "component1 = Gaussian(\n", + " name=\"TestGaussian1\", area=1.0, center=0.0, width=1.0, unit=\"meV\"\n", + ")\n", + "component2 = Lorentzian(\n", + " name=\"TestLorentzian1\", area=2.0, center=1.0, width=0.5, unit=\"meV\"\n", + ")\n", + "model.add_component(component1)\n", + "model.add_component(component2)\n", + "\n", + "sample_model_with_components=model\n", + "\n", + "model_copy = copy(sample_model_with_components)\n", + "\n", + "\n", + "\n", + "assert model_copy is not sample_model_with_components\n", + "assert model_copy.name == \"copy of \" + sample_model_with_components.name\n", + "assert len(model_copy.components) == len(\n", + " sample_model_with_components.components\n", + ")\n", + "for name, comp in sample_model_with_components.components.items():\n", + " copied_comp = model_copy.components[name]\n", + " assert copied_comp is not comp\n", + " assert copied_comp.name == comp.name\n", + " for param_orig, param_copy in zip(\n", + " comp.get_parameters(), copied_comp.get_parameters()\n", + " ):\n", + " assert param_copy is not param_orig\n", + " assert param_copy.name == param_orig.name\n", + " assert param_copy.value == param_orig.value\n", + " assert param_copy.fixed == param_orig.fixed" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c660f129", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Gaussian(name = copy of TestGaussian1, unit = meV,\n", + " area = ,\n", + " center = ,\n", + " width = )" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_copy['TestGaussian1']" + ] } ], "metadata": { diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 1726be4..19bf4f1 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -134,6 +134,9 @@ def normalize_area(self) -> None: """ Normalize the areas of all components so they sum to 1. """ + if not self.components: + raise ValueError("No components in the model to normalize.") + area_params = [] total_area = 0.0 @@ -149,6 +152,9 @@ def normalize_area(self) -> None: if total_area == 0: raise ValueError("Total area is zero; cannot normalize.") + if not np.isfinite(total_area): + raise ValueError("Total area is not finite; cannot normalize.") + for param in area_params: param.value /= total_area @@ -157,7 +163,7 @@ def normalize_area(self) -> None: ########################################################## @property - def temperature(self) -> Parameter: + def temperature(self) -> Union[Parameter, None]: """ Get the temperature. @@ -168,7 +174,7 @@ def temperature(self) -> Parameter: return self._temperature @temperature.setter - def temperature(self, value: Union[Numeric, None]): + def temperature(self, value: Union[Numeric, None]) -> None: """ Set the temperature. @@ -197,7 +203,7 @@ def temperature(self, value: Union[Numeric, None]): name="temperature", value=value, unit="K", fixed=True ) - def convert_temperature_unit(self, new_unit: Union[str, sc.Unit]): + def convert_temperature_unit(self, new_unit: Union[str, sc.Unit]) -> None: """ Convert the temperature parameter to a new unit. @@ -211,8 +217,10 @@ def convert_temperature_unit(self, new_unit: Union[str, sc.Unit]): try: self._temperature.convert_unit(new_unit) - except Exception as e: + except UnitError as e: raise UnitError(f"Failed to convert temperature to unit '{new_unit}': {e}") + except Exception as e: + raise RuntimeError(f"An error occurred during unit conversion: {e}") @property def use_detailed_balance(self) -> bool: @@ -235,6 +243,8 @@ def use_detailed_balance(self, value: bool) -> None: value : bool True to enable, False to disable. """ + if self._temperature is None: + raise ValueError("Temperature must be set to use detailed balance.") self._use_detailed_balance = value @property @@ -277,10 +287,19 @@ def evaluate( np.ndarray Evaluated model values. """ - result = sum( - (component.evaluate(x) for component in self.components.values()), 0 - ) - if self.use_detailed_balance and self._temperature.value >= 0: + + if not self.components: + raise ValueError("No components in the model to evaluate.") + result = None + for component in self.components.values(): + value = component.evaluate(x) + result = value if result is None else result + value + + if ( + self.use_detailed_balance + and self._temperature is not None + and self._temperature.value >= 0 + ): result *= detailed_balance_factor( energy=x, temperature=self._temperature, @@ -313,7 +332,11 @@ def evaluate_component( raise KeyError(f"No component named '{name}' exists.") result = self.components[name].evaluate(x) - if self.use_detailed_balance and self._temperature.value >= 0: + if ( + self.use_detailed_balance + and self._temperature is not None + and self._temperature.value >= 0 + ): result *= detailed_balance_factor( energy=x, temperature=self._temperature, @@ -389,16 +412,21 @@ def __copy__(self) -> "SampleModel": SampleModel A new instance with copied components and parameters. """ + name = "copy of " + self.name new_model = SampleModel( - name=self.name, + name=name, temperature=self._temperature.value if self._temperature else None, ) - new_model.use_detailed_balance = self._use_detailed_balance + if self._temperature: + new_model.use_detailed_balance = self.use_detailed_balance for comp in self.components.values(): - new_model.add_component(copy(comp)) + new_model.add_component(component=copy(comp), name=comp.name) + new_model[comp.name].name = comp.name # Remove 'copy of ' prefix + for par in new_model[comp.name].get_parameters(): + par.name = par.name.removeprefix("copy of ") return new_model diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 7556533..62c33f4 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -1,9 +1,11 @@ +from copy import copy + import numpy as np import pytest from easyscience.variable import Parameter from scipy.integrate import simpson -from easydynamics.sample_model import Gaussian, Lorentzian, SampleModel +from easydynamics.sample_model import Gaussian, Lorentzian, Polynomial, SampleModel from easydynamics.sample_model.components.model_component import ModelComponent from easydynamics.utils import _detailed_balance_factor as detailed_balance_factor @@ -13,331 +15,395 @@ class TestSampleModel: def sample_model(self): return SampleModel(name="TestSampleModel") + @pytest.fixture + def sample_model_with_components(self): + model = SampleModel(name="TwoComponentModel") + component1 = Gaussian( + name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + name="TestLorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" + ) + model.add_component(component1) + model.add_component(component2) + return model + + def test_init_no_temperature(self, sample_model): + # WHEN THEN EXPECT + assert sample_model.name == "TestSampleModel" + assert isinstance(sample_model.components, dict) + assert len(sample_model.components) == 0 + assert not sample_model.use_detailed_balance + + def test_init_with_temperature(self): + # WHEN THEN + sample_model = SampleModel(name="TempModel", temperature=100) + + # EXPECT + assert sample_model.name == "TempModel" + assert isinstance(sample_model.components, dict) + assert len(sample_model.components) == 0 + assert sample_model.use_detailed_balance + assert isinstance(sample_model.temperature, Parameter) + assert sample_model.temperature.value == 100 + # ───── Component Management ───── def test_add_component(self, sample_model): - # When + # WHEN component = Gaussian( name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) - # Then + # THEN sample_model.add_component(component) - # Expect + # EXPECT assert "TestComponent" in sample_model.components - def test_add_duplicate_component_raises(self, sample_model): - # When - component = Gaussian(name="Dup", area=1.0, center=0.0, width=1.0, unit="meV") - # Then - sample_model.add_component(component) - # Expect - with pytest.raises(ValueError, match="already exists"): - sample_model.add_component(component) - - def test_remove_component(self, sample_model): - # When + def test_add_duplicate_component_raises(self, sample_model_with_components): + # WHEN THEN component = Gaussian( - name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" + name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) - # Then - sample_model.add_component(component) - sample_model.remove_component("TestComponent") - # Expect - assert "TestComponent" not in sample_model.components + # EXPECT + with pytest.raises(ValueError, match="already exists"): + sample_model_with_components.add_component(component) - def test_remove_nonexistent_component_raises(self, sample_model): - # When Then Expect + def test_remove_component(self, sample_model_with_components): + # WHEN THEN + sample_model_with_components.remove_component("TestGaussian1") + # EXPECT + assert "TestGaussian1" not in sample_model_with_components.components + + def test_remove_nonexistent_component_raises(self, sample_model_with_components): + # WHEN THEN EXPECT with pytest.raises( KeyError, match="No component named 'NonExistentComponent' exists" ): - sample_model.remove_component("NonExistentComponent") + sample_model_with_components.remove_component("NonExistentComponent") def test_getitem(self, sample_model): - # When + # WHEN component = Gaussian( name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) - # Then + # THEN sample_model.add_component(component) - # Expect + # EXPECT assert sample_model["TestComponent"] is component def test_setitem(self, sample_model): - # When + # WHEN component = ModelComponent(name="TestComponent") - # Then + # THEN sample_model["TestComponent"] = component - # Expect + # EXPECT assert sample_model["TestComponent"] is component - def test_contains_component(self, sample_model): - # When - component = Gaussian( - name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" - ) - # Then - sample_model.add_component(component) - # Expect - assert "TestGaussian" in sample_model - assert "NonExistentComponent" not in sample_model + def test_contains_component(self, sample_model_with_components): + # WHEN THEN EXPECT + # EXPECT + assert "TestGaussian1" in sample_model_with_components + assert "NonExistentComponent" not in sample_model_with_components - def test_list_components(self, sample_model): - # When - component1 = Gaussian( - name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Gaussian( - name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit="meV" - ) - sample_model.add_component(component1) - sample_model.add_component(component2) - # Then - components = sample_model.list_components() - # Expect + def test_list_components(self, sample_model_with_components): + # WHEN THEN + components = sample_model_with_components.list_components() + # EXPECT assert len(components) == 2 assert components[0] == "TestGaussian1" - assert components[1] == "TestGaussian2" + assert components[1] == "TestLorentzian1" - def test_clear_components(self, sample_model): - # when - component1 = Gaussian( - name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Gaussian( - name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit="meV" - ) - sample_model.add_component(component1) - sample_model.add_component(component2) - # Then - sample_model.clear_components() - # Expect - assert len(sample_model.components) == 0 + def test_clear_components(self, sample_model_with_components): + # WHEN THEN + sample_model_with_components.clear_components() + # EXPECT + assert len(sample_model_with_components.components) == 0 # ───── Temperature and Detailed Balance ───── - def test_temperature_init(self, sample_model): - # When Then Expect - assert sample_model._temperature is None - assert sample_model._use_detailed_balance is False - # assert sample_model._temperature.unit == 'K' - def test_set_temperature(self, sample_model): - # When Then + # Set valid temperature + # WHEN THEN sample_model.temperature = 300 - # Expect - assert sample_model._temperature.value == 300 - assert sample_model._temperature.unit == "K" - - def test_negative_temperature_throws(self, sample_model): - # When - sample_model.use_detailed_balance = True - # Then Expect + # EXPECT + assert sample_model.temperature.value == 300 + assert sample_model.temperature.unit == "K" + + # Set temperature to None + # WHEN THEN + sample_model.temperature = None + # EXPECT + assert sample_model.temperature is None + assert not sample_model.use_detailed_balance + + def test_invalid_temperature_raises(self, sample_model): + # WHEN THEN EXPECT + with pytest.raises(TypeError, match="Temperature must be a number or None."): + sample_model.temperature = "invalid" + + def test_negative_temperature_raises(self, sample_model): + # WHEN THEN EXPECT with pytest.raises(ValueError, match="Temperature must be non-negative"): sample_model.temperature = -50 + def test_convert_temperature_unit(self, sample_model): + # WHEN + sample_model.temperature = 300 # Kelvin + # THEN + sample_model.convert_temperature_unit("mK") + # EXPECT + assert np.isclose(sample_model.temperature.value, 300000.0) + assert sample_model.temperature.unit == "mK" + def test_use_detailed_balance(self, sample_model): - # When Then Expect - assert sample_model._use_detailed_balance is False - sample_model._use_detailed_balance = True - assert sample_model._use_detailed_balance is True - sample_model._use_detailed_balance = False - assert sample_model._use_detailed_balance is False + sample_model.temperature = 300 + # WHEN THEN EXPECT + assert sample_model.use_detailed_balance is False + sample_model.use_detailed_balance = True + assert sample_model.use_detailed_balance is True + sample_model.use_detailed_balance = False + assert sample_model.use_detailed_balance is False # ───── Evaluation ───── - def test_evaluate(self, sample_model): - # When - component1 = Gaussian( - name="Gaussian1", area=1.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Lorentzian( - name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" - ) - sample_model.add_component(component1) - sample_model.add_component(component2) - # Then + def test_evaluate(self, sample_model_with_components): + # WHEN x = np.linspace(-5, 5, 100) - result = sample_model.evaluate(x) - # Expect - expected_result = component1.evaluate(x) + component2.evaluate(x) + result = sample_model_with_components.evaluate(x) + # EXPECT + expected_result = sample_model_with_components["TestGaussian1"].evaluate( + x + ) + sample_model_with_components["TestLorentzian1"].evaluate(x) np.testing.assert_allclose(result, expected_result, rtol=1e-5) @pytest.mark.parametrize( "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] ) - def test_evaluate_with_detailed_balance(self, sample_model, normalise_db): - # When - sample_model.temperature = 300 - component1 = Gaussian( - name="Gaussian1", area=1.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Lorentzian( - name="Lorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" - ) - sample_model.add_component(component1) - sample_model.add_component(component2) - sample_model.use_detailed_balance = True - sample_model.normalise_detailed_balance = normalise_db + def test_evaluate_with_detailed_balance( + self, sample_model_with_components, normalise_db + ): + # WHEN + sample_model_with_components.temperature = 300 + sample_model_with_components.use_detailed_balance = True + sample_model_with_components.normalise_detailed_balance = normalise_db x = np.linspace(-5, 5, 100) - # Then - result = sample_model.evaluate(x) + # THEN + result = sample_model_with_components.evaluate(x) - # Expect - expected_result = component1.evaluate(x) + component2.evaluate(x) + # EXPECT + expected_result = sample_model_with_components["TestGaussian1"].evaluate( + x + ) + sample_model_with_components["TestLorentzian1"].evaluate(x) expected_result *= detailed_balance_factor( energy=x, - temperature=sample_model._temperature, + temperature=sample_model_with_components.temperature, divide_by_temperature=normalise_db, ) np.testing.assert_allclose(result, expected_result, rtol=1e-5) - def test_evaluate_component(self, sample_model): - # When - component1 = Gaussian( - name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Lorentzian( - name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" - ) - sample_model.add_component(component1) - sample_model.add_component(component2) - - # Then + def test_evaluate_component(self, sample_model_with_components): + # WHEN THEN x = np.linspace(-5, 5, 100) - result1 = sample_model.evaluate_component(x, "TestGaussian") - result2 = sample_model.evaluate_component(x, "TestLorentzian") + result1 = sample_model_with_components.evaluate_component(x, "TestGaussian1") + result2 = sample_model_with_components.evaluate_component(x, "TestLorentzian1") - # Expect - expected_result1 = component1.evaluate(x) - expected_result2 = component2.evaluate(x) + # EXPECT + expected_result1 = sample_model_with_components["TestGaussian1"].evaluate(x) + expected_result2 = sample_model_with_components["TestLorentzian1"].evaluate(x) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) @pytest.mark.parametrize( "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] ) - def test_evaluate_component_with_detailed_balance(self, sample_model, normalise_db): - # When - component1 = Gaussian( - name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + def test_evaluate_component_with_detailed_balance( + self, sample_model_with_components, normalise_db + ): + # WHEN + sample_model_with_components.temperature = 300 + sample_model_with_components.use_detailed_balance = True + sample_model_with_components.normalise_detailed_balance = normalise_db + + # THEN + x = np.linspace(-5, 5, 100) + result1 = sample_model_with_components.evaluate_component( + x, name="TestGaussian1" ) - component2 = Lorentzian( - name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" + result2 = sample_model_with_components.evaluate_component( + x, name="TestLorentzian1" ) - sample_model.add_component(component1) - sample_model.add_component(component2) - sample_model.temperature = 300 - sample_model.use_detailed_balance = True - sample_model.normalise_detailed_balance = normalise_db - # Then - x = np.linspace(-5, 5, 100) - result1 = sample_model.evaluate_component(x, name="TestGaussian") - result2 = sample_model.evaluate_component(x, name="TestLorentzian") - # Expect - expected_result1 = component1.evaluate(x) - expected_result2 = component2.evaluate(x) + # EXPECT + expected_result1 = sample_model_with_components["TestGaussian1"].evaluate(x) + expected_result2 = sample_model_with_components["TestLorentzian1"].evaluate(x) expected_result1 *= detailed_balance_factor( energy=x, - temperature=sample_model.temperature, + temperature=sample_model_with_components.temperature, divide_by_temperature=normalise_db, ) expected_result2 *= detailed_balance_factor( energy=x, - temperature=sample_model.temperature, + temperature=sample_model_with_components.temperature, divide_by_temperature=normalise_db, ) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) - def test_evaluate_nonexistent_component_raises(self, sample_model): + def test_evaluate_nonexistent_component_raises(self, sample_model_with_components): # WHEN - component1 = Gaussian( - name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Lorentzian( - name="TestLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" - ) - sample_model.add_component(component1) - sample_model.add_component(component2) x = np.linspace(-5, 5, 100) - # Then Expect + # THEN EXPECT with pytest.raises( KeyError, match="No component named 'NonExistentComponent' exists" ): - sample_model.evaluate_component(x, "NonExistentComponent") + sample_model_with_components.evaluate_component(x, "NonExistentComponent") # ───── Utilities ───── - def test_normalize_area(self, sample_model): - # When - component1 = Gaussian( - name="TestGaussian1", area=2.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Gaussian( - name="TestGaussian2", area=3.0, center=1.0, width=0.5, unit="meV" - ) - sample_model.add_component(component1) - sample_model.add_component(component2) - # Then - sample_model.normalize_area() - # Expect - x = np.linspace(-10, 10, 1000) - result = sample_model.evaluate(x) + def test_normalize_area(self, sample_model_with_components): + # WHEN THEN + sample_model_with_components.normalize_area() + # EXPECT + x = np.linspace(-10000, 10000, 1000000) # Lorentzians have long tails + result = sample_model_with_components.evaluate(x) numerical_area = simpson(result, x) - assert np.isclose(numerical_area, 1.0) + assert np.isclose(numerical_area, 1.0, rtol=1e-4) - def test_get_parameters(self, sample_model): - # When - component = Gaussian( - name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + def test_normalize_area_no_components_raises(self, sample_model): + # WHEN THEN EXPECT + with pytest.raises( + ValueError, match="No components in the model to normalize." + ): + sample_model.normalize_area() + + def test_normalize_area_zero_total_raises(self, sample_model_with_components): + # WHEN THEN + sample_model_with_components["TestGaussian1"].area = 0.0 + sample_model_with_components["TestLorentzian1"].area = 0.0 + + # EXPECT + with pytest.raises(ValueError, match="Total area is zero; cannot normalize."): + sample_model_with_components.normalize_area() + + def test_normalize_area_non_area_component_warns( + self, sample_model_with_components + ): + # WHEN + component1 = Polynomial( + name="TestPolynomial", coefficients=[1, 2, 3], unit="meV" ) - sample_model.add_component(component) - # Then - parameters = sample_model.get_parameters() - # Expect - assert len(parameters) == 3 - assert parameters[0].name == "TestGaussian area" - assert parameters[1].name == "TestGaussian center" - assert parameters[2].name == "TestGaussian width" + sample_model_with_components.add_component(component1) + + # THEN EXPECT + with pytest.warns(UserWarning, match="does not have an 'area' "): + sample_model_with_components.normalize_area() + + def test_get_parameters(self, sample_model_with_components): + # WHEN THEN + parameters = sample_model_with_components.get_parameters() + # EXPECT + assert len(parameters) == 6 + + expected_names = { + "TestGaussian1 area", + "TestGaussian1 center", + "TestGaussian1 width", + "TestLorentzian1 area", + "TestLorentzian1 center", + "TestLorentzian1 width", + } + actual_names = {param.name for param in parameters} + assert actual_names == expected_names assert all(isinstance(param, Parameter) for param in parameters) + # WHEN + sample_model_with_components.temperature = 300 + # THEN + parameters = sample_model_with_components.get_parameters() + # EXPECT + assert len(parameters) == 7 + expected_names.add("temperature") + actual_names = {param.name for param in parameters} + assert actual_names == expected_names + def test_get_parameters_no_components(self, sample_model): - # When Then + # WHEN THEN parameters = sample_model.get_parameters() - # Expect + # EXPECT assert len(parameters) == 0 - def test_repr_contains_name_and_components(self, sample_model): - # When - component = Gaussian( - name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + # WHEN THEN + sample_model.temperature = 300 + parameters = sample_model.get_parameters() + # EXPECT + assert len(parameters) == 1 + assert parameters[0].name == "temperature" + + def test_get_fit_parameters(self, sample_model_with_components): + # WHEN + + # Fix one parameter and make another dependent + sample_model_with_components["TestGaussian1"].area.fixed = True + sample_model_with_components["TestLorentzian1"].width.make_dependent_on( + "comp1_width", + {"comp1_width": sample_model_with_components["TestGaussian1"].width}, ) - sample_model.add_component(component) - # Then - rep = repr(sample_model) - # Expect + + # THEN + fit_parameters = sample_model_with_components.get_fit_parameters() + # EXPECT + assert len(fit_parameters) == 4 + + expected_names = { + "TestGaussian1 center", + "TestGaussian1 width", + "TestLorentzian1 area", + "TestLorentzian1 center", + } + actual_names = {param.name for param in fit_parameters} + assert actual_names == expected_names + assert all(isinstance(param, Parameter) for param in fit_parameters) + + def test_fix_and_free_all_parameters(self, sample_model_with_components): + # WHEN THEN + sample_model_with_components.fix_all_parameters() + # EXPECT + for param in sample_model_with_components.get_parameters(): + assert param.fixed is True + + # WHEN + sample_model_with_components.free_all_parameters() + # THEN + for param in sample_model_with_components.get_parameters(): + assert param.fixed is False + + def test_repr_contains_name_and_components(self, sample_model_with_components): + # WHEN THEN + rep = repr(sample_model_with_components) + # EXPECT assert "SampleModel" in rep assert "TestGaussian" in rep - # def test_repr_no_components(self, sample_model): - # # When Then - # rep = repr(sample_model) - # # Expect - # assert "SampleModel" in rep - # assert "Components: None" in rep - - def test_str_contains_name_and_components(self, sample_model): - # When - component = Gaussian( - name="TestGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + def test_copy(self, sample_model_with_components): + # WHEN THEN + model_copy = copy(sample_model_with_components) + # EXPECT + assert model_copy is not sample_model_with_components + assert model_copy.name == "copy of " + sample_model_with_components.name + assert len(model_copy.components) == len( + sample_model_with_components.components ) - sample_model.add_component(component) - # Then - str_repr = str(sample_model) - # Expect - assert "SampleModel" in str_repr - assert "TestGaussian" in str_repr + for name, comp in sample_model_with_components.components.items(): + copied_comp = model_copy.components[name] + assert copied_comp is not comp + assert copied_comp.name == comp.name + for param_orig, param_copy in zip( + comp.get_parameters(), copied_comp.get_parameters() + ): + assert param_copy is not param_orig + assert param_copy.name == param_orig.name + assert param_copy.value == param_orig.value + assert param_copy.fixed == param_orig.fixed From d4309fc81a8b64503392346ff8a7e66217744192 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 17 Oct 2025 11:04:43 +0200 Subject: [PATCH 04/44] Update example and tests --- examples/sample_model.ipynb | 192 +----------------- .../sample_model/test_sample_model.py | 189 ++++++++--------- 2 files changed, 95 insertions(+), 286 deletions(-) diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb index 3875874..1753444 100644 --- a/examples/sample_model.ipynb +++ b/examples/sample_model.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "64deaa41", "metadata": {}, "outputs": [], @@ -13,7 +13,7 @@ "from easydynamics.sample_model import Lorentzian\n", "from easydynamics.sample_model import DampedHarmonicOscillator\n", "from easydynamics.sample_model import Polynomial\n", - "from easydynamics.sample_model import DeltaFunction\n", + "\n", "from easydynamics.sample_model import SampleModel\n", "\n", "\n", @@ -25,36 +25,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "784d9e82", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "85227f7e718342749b433c8067629028", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAwG1JREFUeJzsnQV4U1cbx/91dzcqUEopFIq7uztsDAbb2AYT5hvfjClzNjZgYwIzGDB0wGC4W9FiRQp1t9T9e95zm9JCWypJY+/vee6TmzRNTpJ7z/nfV/XKysrKwDAMwzAMw+gM+qoeAMMwDMMwDNO0sABkGIZhGIbRMVgAMgzDMAzD6BgsABmGYRiGYXQMFoAMwzAMwzA6BgtAhmEYhmEYHYMFIMMwDMMwjI7BApBhGIZhGEbHYAHIMAzDMAyjY7AAZBiGYRiG0TFYADIMwzAMw+gYLAAZhmEYhmF0DBaADMMwDMMwOgYLQIZhGIZhGB2DBSDDMAzDMIyOwQKQYRiGYRhGx2AByDAMwzAMo2OwAGQYhmEYhtExWAAyDMMwDMPoGCwAGYZhGIZhdAwWgAzDMAzDMDoGC0CGYRiGYRgdgwUgwzAMwzCMjsECkGEYhmEYRsdgAcgwDMMwDKNjsABkGIZhGIbRMVgAMgzDMAzD6BgsABmGYRiGYXQMFoAMwzAMwzA6BgtAhmEYhmEYHYMFIMMwDMMwjI7BApBhGIZhGEbHYAHIMAzDMAyjY7AAZBiGYRiG0TFYADIMwzAMw+gYLAAZhmEYhmF0DBaADMMwDMMwOgYLQIZhGIZhGB2DBSDDMAzDMIyOwQKQYRiGYRhGx2AByDAMwzAMo2OwAGQYhmEYhtExWAAyDMMwDMPoGCwAGYZhGIZhdAwWgAzDMAzDMDoGC0CGYRiGYRgdgwUgwzAMwzCMjsECkGEYhmEYRsdgAcgwDMMwDKNjsABkGIZhGIbRMVgAMgzDMAzD6BgsABmGYRiGYXQMFoAMwzAMwzA6BgtAhmEYhmEYHYMFIMMwDMMwjI7BApBhGIZhGEbHMIQWsHz5crHduXNH3A8KCsI777yD4cOHV/v8VatWYfbs2VUeMzExQX5+fr3et7S0FHFxcbCysoKenl4jPgHDMAzDME1FWVkZsrKy4O7uDn193bSFaYUA9PT0xCeffAJ/f3/xo/76668YO3Yszp07J8RgdVhbWyM8PLzifkMEHIk/Ly+vRo2dYRiGYRjVEB0dLTSELqIVAnD06NFV7n/00UfCInjixIkaBSAJPldX10a9L1n+5AcQCUqGYRiGYdQfmUwmDDjydVwX0QoBWJmSkhKsX78eOTk56N69e43Py87Ohre3t3DjdujQAR9//HGNYrEm5FZDEn8sABmGYRhGs9DT4fAtrRGAYWFhQvBRHJ+lpSU2bdqE1q1bV/vcgIAA/PLLLwgODkZmZia++OIL9OjRA5cvX67VFFxQUCC2ylcQDMMwDMMwmoZeGQXNaQGFhYWIiooSgu7vv//GTz/9hIMHD9YoAitTVFSEwMBAPPTQQ/jggw9qfN7ChQvx3nvv3fc4vSdbABmGYRhGM5DJZLCxsdHp9VtrBOC9DBo0CM2bN8cPP/xQp+dPnjwZhoaGWLNmTb0sgBRDoMsHEMMwDMNoGiwAtcgFfC8U21dZrD0obpBcyCNGjKj1eVQqhjaGYRhGeZBdori4WMzNDNMQDAwMhFFHl2P8dEIALliwQNT8a9asmajrs3r1ahw4cAC7du0Sf585cyY8PDywaNEicf/9999Ht27d0KJFC2RkZODzzz9HZGQknnjiCRV/EoZhGN2Gwnni4+ORm5ur6qEwGo65uTnc3NxgbGys6qGoJVohAJOSkoTIo0mDTLqU3EHib/DgweLvFBtYudBjeno65syZg4SEBNjZ2aFjx444duxYneIFGYZhGOV5bm7fvi2sN1SglxZutuAwDbEg04VEcnKyOJ6oRrCuFnvWyRjApoBjCBiGYRQHVXGgBZtKdJH1hmEaA1mRybvn6+sLU1PTKn+T8frNvYAZhmEY9YKtNYwi4OOodvjbYRiGYRiG0TFYADIMwzCMFkNxlJs3b4a6069fP7zwwgt1fv6qVatga2ur1DFpMywAGYZhGKYRULLB3LlzRSUKKhVGfeaHDh2Ko0ePQhu4c+eOEJGUnBMbG1vlb5R8KS+3Qs9jNAcWgAzDMAzTCCZOnIhz587h119/xfXr17F161ZhzUpNTYU2QeXUfvvttyqP0WemxxnNgwUgwyiJ8IQsfLDtCuIz81Q9FIZhlATVkj18+DA+/fRT9O/fX2Qwd+nSRdSnHTNmTMXzvvrqK7Rt2xYWFhaig9S8efOQnZ19nztz27Ztol89ZUFPmjRJZLKSyPLx8RFly55//vkqBbLpcWphSq1M6bVJjC1durTWMUdHR2PKlCni/ezt7TF27Ng6We8effRRrFy5sspjdJ8evxdqxUrfA1lEqRbfG2+8IYp7y8nJyRHl2ywtLcXfv/zyy/teg5o5vPLKK+Iz0Wfr2rWrqPHLKAYWgAyjBKi60msbLuLnI7fxyE8nkZ5TqOohMYxGnke5hcUq2epaIY0EDG0UY1db9ynKSF2yZAkuX74sBN2+ffvw2muvVXkOiT16zl9//YWdO3cKsTN+/Hjs2LFDbL///rtob0r97itDzQzatWsnrJAktObPn4/du3dXO46ioiLhnrayshLCldzUNP5hw4aJ2nm1QYKW6ugeOXJE3Kdbuj969OgqzyM3MXXW6ty5My5cuIDly5fj559/xocffljxnFdffVWIxC1btuC///4Tn/Xs2bNVXufZZ5/F8ePHxfdx8eJF0bKVxnnjxo1ax8noUCFohlE3Tt1Ow4XoDLF/KzkHs1edxuo5XWFuzKccw9SVvKIStH5H6ujU1Fx5f2idzleKfyPrHTUX+P7779GhQwf07dsX06ZNE00J5FRObiCrHYmhp59+GsuWLasizkgsUR97giyAJPoSExOFSKNmBWRl3L9/P6ZOnVrxfz179hTCj2jZsqUQdYsXL65ohlCZtWvXioLbP/30U0WRbbLikTWQRNiQIUNq/KxGRkZ45JFH8Msvv6BXr17ilu7T45Whz0RWzu+++068R6tWrRAXF4fXX38d77zzjhC6JAj/+OMPDBw4UPwPiWJPT8+K16AGDjQuuqWi4ARZA0kY0+Mff/zxA38bpnbYAsgwSmDFoQhx2z/ACbbmRjgfnYF5f55FUUmpqofGMIwSYgBJ4FDsH1moSEiRECRhKGfPnj1C7JA7k6xvM2bMEDGClVvekdtXLv4IFxcXIRZJ/FV+jLpfVaZ79+733b969Wq1YyWL3M2bN8UY5NZLcgNTEe5bt2498LM+9thjWL9+veikRbd0/17ovWkMlbu4kEgll3dMTIx4H7I2kktXDo2BXN9ywsLChKubBK18nLSR1bAu42QeDJsjGEbB3EjMwt5rSaC5753RQUjLKcT0n07gQHgyXvv7Ir6c3A76+tzeimEehJmRgbDEqeq96wN1miCLG21vv/226C3/7rvvYtasWSK+btSoUSJT+KOPPhJih9ynjz/+uBBC8q4n91rSSEBV9xhZ8BoKiTBqf/rnn3/e9zcnJ6cH/j/FMZJFj2IOAwMD0aZNG5w/f77B46ltnJR1fObMGXFbmcqCmGk4LAAZRknWv2FBrvB1tBDb8ukd8cRvodh0LhbO1iZYMDxQ1cNkGLWHxI6mhk2Qu1Zee49EDIk2SnSQd6dYt26dwt7rxIkT990ncVYdZJkkN7Czs3ODW6CR1Y+SWMhdXR303hs2bBBxlHIrILmlyepIbl4SwCRsT548KUrnEBRLSBnU5D4nQkJChAWQrJ29e/du0DiZ2mEXMMMokITMfGw+L9XJerKPX8Xj/Vs54/NJwRUCkayCDMNoPuTGHTBggIhno0QF6mVMrtHPPvtMZNcSLVq0EPF93377LSIiIkRcH8ULKgoSV/R+JKAoA5jenxJBqmP69OlwdHQUY6MkEBovuawpu5jcs3WB4h2p9iFZOauDxCFlGj/33HO4du2aSPQga+hLL70kBDBZ8Mj6SYkglAxz6dIlYSmt3LqNXL80VsoU3rhxoxjnqVOnsGjRImzfvr2B3xRTGRaADKNAVh67jaKSMnTxtUdIM7sqf5vQwROtXK1AyYXHbqWobIwMwygOEjMUy0ZJF3369BEuUXIBk0iiJAiCMnSpDAyViqG/k/uVhIyiePnllxEaGiqsZpRcQu9Fmb7VQe7mQ4cOCcvbhAkThLWOxBjFANbVIkiJLyQi6bY6KM6RspZJsNFnp2QXeo+33nqrSuYyWfYog3jQoEEiqYRc05WhZA8SgPT5KD5w3LhxOH36dIXVkGkcemV1zXVn7kMmk8HGxgaZmZkNNqUz2kNWfhF6LNqHrIJi/PxoJwwMdLnvOR9uu4KfjtzGtM5e+GTi3QxBhmEgRAhZenx9fUVMHfNgKEmEMozr00JNV6jteJLx+s0WQIZRFGtORQnx18LZEv0DnKt9Tk9/R3F7+EZKneuMMQzDMIyiYQHIMAqgsLgUvxy5UxH7V1OWb1dfexgZ6CE2Iw+RqXfLPzAMwzBMU6KZ6VUMo2acjUpHgiwfDhbGGNteKlpaHZTR2KGZHU7eTsPhmynwcbRo0nEyDKNd1KWFG8NUB1sAGUYBhMVkitvOPvYwMay9fljvcjfwkRvJTTI2hmEYhrkXFoAMowAuxkoCsK2nzQOf28tfKrZ67FYqSko5DpBhGIZpelgAMowCuBgj9f0NroMAbOthA2tTQ2TlF1f8H8MwDMM0JSwAGaaRZOYWVSR0BHvYPvD5Bvp66NFc7gbmeoAMwzBM08MCkGEaSVi5+9fbwRw25lX7dtZEL3kc4E0WgAzDMEzTwwKQYRrJhXI3Lrl260qvFo4V2cM5BcVKGxvDMAzDVAcLQIZRUAZwO88Hu3/lkLXQ085MtI07dTtNiaNjGIaRWLVqFWxt6z5PMdoNC0CGUZALuC4ZwHL09PTuloNhNzDDaAUJCQmYP38+WrRoIVqPubi4oGfPnli+fDlyc1Vf+H3q1Km4fv26qofBqAlcCJphGkFKdoHo6qGnBwS516+fZM8WjlhzKpoTQRhGC4iIiBBijyxsH3/8Mdq2bQsTExOEhYVhxYoV8PDwwJgxY1Q6RjMzM7ExDMEWQIZRgPvXz9ECVqZ1SwCRQ5nAJBzDE7OQJMtX0ggZhmkK5s2bB0NDQ4SGhmLKlCkIDAyEn58fxo4di+3bt2P06NHieV999ZUQhxYWFvDy8hL/l52dXfE6CxcuRPv27au89tdffw0fH5+K+wcOHECXLl3Ea5DgJOEZGRkp/nbhwgX0798fVlZWsLa2RseOHcWYqnMB37p1S4yPLJWWlpbo3Lkz9uzZU+W96X1J0D722GPiNZs1ayYELaP5sABkmEZwsQHxf3LsLYwrrIZHb7EVkGHuo6wMKMxRzUbvXUdSU1Px33//4ZlnnhGirKawD0JfXx9LlizB5cuX8euvv2Lfvn147bXX6vxexcXFGDduHPr27YuLFy/i+PHjePLJJytef/r06fD09MTp06dx5swZvPHGGzAyqv7ilITniBEjsHfvXpw7dw7Dhg0TQjUqKqrK87788kt06tRJPIcE69y5cxEeHl7nMTPqCbuAGaYRyAs51yf+71438KVYGU5GpGF8iKeCR8cwGk5RLvBxzb21lcr/4gDjuvXqvnnzJsrKyhAQEFDlcUdHR+TnS9Z9EoeffvopXnjhhSrWtQ8//BBPP/00li1bVqf3kslkyMzMxKhRo9C8eXPxGFkb5ZB4e/XVV9GqVStx39/fv8bXateundjkfPDBB9i0aRO2bt2KZ599tuJxEokk/IjXX38dixcvxv79++/7vIxmwRZAhmkgNOHLW8DVpQNIdbQvtxxejpMpdGwMw6ieU6dO4fz58wgKCkJBQYF4jFysAwcOFDGB5FKdMWOGsCDWNUnE3t4es2bNwtChQ4W17ptvvkF8fHzF31966SU88cQTGDRoED755BPh5q0JsgC+8sorQkCSa5jcwFevXr3PAhgcHFyxT5ZGV1dXJCUlNeAbYdQJtgAyTANJlBUgOatAdPZo7dYwAdimvHZgeEIWCotLYWzI12QMU4GRuWSJU9V71xHK+iVhdK9blGIACXnixZ07d4TljlyoH330kRBzR44cweOPP47CwkKYm5sLFzFdXFamqKioyv2VK1fi+eefx86dO7F27Vq89dZb2L17N7p16yZiCB9++GERd/jvv//i3XffxV9//YXx48ffN24Sf/R/X3zxhfgMNM5JkyaJsVT5Ku5xIdNnLS0trfP3w6gnvNowTCMLQPs7W8LM2KBBr0G1AKkvcGFJKW4kZSl4hAyj4VBcG7lhVbGVx9TVBQcHBwwePBjfffcdcnJyanwexeSRcKKYOhJrLVu2RFxcVYHr5OQkyslUFoFkRbyXkJAQLFiwAMeOHUObNm2wevXqir/R67744osiLnHChAlCMFbH0aNHhTWRxCElppBlj0QqoxuwAGSYRmYAN9T9K7+SllsBL8eyG5hhNBWK4aMEDUqWIKscuVLJIvjHH3/g2rVrMDAwEFY2suZ9++23omzM77//ju+//77K6/Tr1w/Jycn47LPPhPt26dKlwpIn5/bt20L4UfIHZf6SyLtx44Zw4+bl5YnYPcoSpr+RwKNkkMoxgpWh+MCNGzcKgUnZw2Q5ZMue7sACkGEayN34v8ZV1pcLwEtx0usxDKN5UEIGZclS7B0JNEquIDFIYo9crZRgQY9RGRhKBiGr3Z9//olFixZVeR0SayQmSfjR8ymOkP5fDrmJSVBOnDhRWPooA5gSTJ566ikhMimecObMmeJvVI5m+PDheO+996odM43Fzs4OPXr0EPGEFFfYoUMHpX9XjHqgV3ZvsAFTZygby8bGRmRkUb0lRneg0ybkg93IyC3C1md7NkoEbjkfi/l/nUeHZrbYOK+nQsfJMJoEZcyShcvX11d00mAYZR1PMl6/2QLIMA0hJj1PiD8jAz0EuFo16rWC3CUL4JV4GUpK+XqMYRiGUT4sABmmEQWgA92sYWLYsAQQOb6OFjA3NkB+USkiku92BGAYhmEYZcECkGEaUwC6PH6vMUhlZCQXBMcBMgzDME0BC0CGaQByoaYIAVglEYQzgRmGYZgmQCsE4PLly0WlcgrkpK179+5V0uarY/369aJVDgWGUv2jHTt2NNl4Gc3neqLkqm1VbrlrLPKewJfKM4sZhmEYRplohQCkxtfU8oaKbIaGhmLAgAEYO3asaLZdHVQ486GHHhLV1yltnxpr03bp0qUmHzujeWTmFokOIERzp7r1Cq2rBfBKnAylnAjCMAzDKBmtEIBUv4iaVVNRS6p9RC12qKfhiRMnqn0+9U4cNmyYaJhNNZeoPhPVPqIq7gzzIG4mSx07XK1NYWVatUVSQ2nhbCnawGUVFCMqrW49QRmGYRhGpwVgZUpKSkTfQ2rHQ67g6qAK6lSsszJUAJMerw1q5k21gypvjO5xM0ly//q7WCrsNY0M9BFYXk6GE0EYhmEYZaM1AjAsLExY/UxMTPD0009j06ZNaN26dbXPpT6LLi4uVR6j+/R4bVDFdiocKd+8vLwU+hkYzRKAzZ0UJwCJIE4EYRiGYZoIrRGAAQEBop/hyZMnMXfuXDz66KO4cuWKQt+D2vtQ1XD5Fh0drdDXZzSDG0qwABJtygtCX2YLIMMwDKNktEYAGhsbi0bbHTt2FJY66qFIsX7V4erqisTExCqP0X16vDbIuijPNJZvjO5aAFso2ALYxuNuJjB3aGQYzWLWrFnQ09MTm5GRkfAqDR48GL/88gtKS0srnufj44Ovv/76vv9fuHAh2rdvX+WxtLQ0vPDCC/D29hZrnLu7Ox577DFERUU1yWditButEYD3QiccxexVB8UG7t27t8pju3fvrjFmkGHk5BYWizZw8sQNRdLSxQqG+npIzy1CXGa+Ql+bYRjlQ8mF8fHxuHPnjihF1r9/f8yfPx+jRo1CcXFxvV6LxF+3bt2wZ88efP/997h586aIb6fbzp07IyIiQmmfg9ENDKEFkGt2+PDhaNasGbKysrB69WocOHAAu3btEn+fOXMmPDw8hGWQoBOyb9+++PLLLzFy5EhxUlH5mBUrVqj4kzDqTkRyjri1tzCGg6WJQl/b1MgA/i5WuBovE1ZAD1szhb4+wzDKhbxEck8SrTlUXYJE3MCBA7Fq1So88cQTdX6tN998E3FxcULwyV+T1jha16jixTPPPPPAercMo/UCMCkpSYg8uvKi5AwqCk0nCZnfCTKX6+vfNXb26NFDiMS33noL//vf/8TJtHnzZrRp00aFn4LRZfevnDbu1kIAXo7NxNCg2kMSGEbboVCIvGLJ4t7UmBmaCXduY6G6tBSStHHjxjoLQPJgkWFi+vTp94UmmZmZYd68eWL9Iiuhvb19o8fI6CZaIQB//vnnWv9O1sB7mTx5stgYpj7cSJJqALZQcAJI5YLQ68/E4FIcZwIzDIm/rqu7quS9Tz58EuZG5gp5Leo6dfHixYr7r7/+uhBwlSksLKyoXJGcnIyMjAxRp7Y66HESx2Qd7NKli0LGyOgeWiEAGUZrLICVEkEYhtEOSKxVtiZSEwJKGqnMkiVLcOjQofv+j2GUBQtAhmlACRhFJ4DICXSzhr4ekJRVgKSsfDhbmSrlfRhGEyA3LFniVPXeiuLq1avw9fWtuO/o6CiqVlSmsivXyckJtra24v9qej0SlPe+BsPUBxaADFNHCotLEZmaq5QagHLMjQ3h42ghkk2uxmexAGR0GhI5inLDqop9+/aJRgUvvvhinf+HYtanTJmCP//8E++//36VOMC8vDwsW7ZMdK/i+D+mMWhtGRiGUTSRqTkoKS2DpYmh6AOsLMgKSFAyCMMwmgOVHqOOUrGxsTh79iw+/vhjjB07VpSBoUTF+kD/S8KPkhkp25caD5CLmIRfUVERli5dqrTPwegGLAAZpp7u3+bOlgrJDqyJ1uUC8BoLQIbRKHbu3Ak3NzdR7JlqAu7fv1/E9m3ZsgUGBgb1ei0HBwecOHFC1BJ86qmn0Lx5c2EVpNvTp0/Dz89PaZ+D0Q30yjjKtMHIZDJRdobawnFXEO1nyd4b+Gr3dUzs4Ikvp7RT2vvsvZqIx38NRYCLFXa92Edp78Mw6kZ+fj5u374t4uVMTTn8gVHe8STj9ZstgAyjLgkg97qAbyVno6C4RKnvxTAMw+gmLAAZpp4lYPyVLADdbExhY2aE4tIy3EiU3pNhGIZhFAkLQIapA5T8EZHcNBZAii8MdLMS+5wIwjAMwygDFoAMUwdi0nNRUFwKY0N9eNkrvyzF3UxgqfMIwzAMwygSFoAMUw/3r5+jBQyoUnMTCcBrCWwBZBiGYRQPC0CGUaMEEDmBrndrAXKiPsMwDKNoWAAyTL0SQKTYPGVDnUbI0pieW4REWUGTvCfDMAyjO7AAZBg1tACaGhkIdzPBiSAMwzCMomEByDAPgFywt+QWQCX1AK4tDvAKC0CGYRhGwbAAZJgHQC7Y7IJi4ZL1cZCsck0B9wRmGKapuXPnjihFdf78eVUPhVEyLAAZ5gHcSJJKsXjbm4syME2FvBbgtQQuBcMw6s6sWbMwbtw4qBsk5jZv3lzn53t5eSE+Ph5t2rRR6rgY1cMCkGHqmADSVPF/91oAqQB1fhG3hGMYXaGwsFBl721gYABXV1cYGhqqbAxM08ACkGHqmADSlPF/hLOVCewtjFFaBlxPZCsgw2gqBw8eRJcuXWBiYgI3Nze88cYbKC4urvh7v3798Oyzz+KFF16Ao6Mjhg4dKh6/dOkShg8fDktLS7i4uGDGjBlISUmp8n/PP/88XnvtNdjb2wvhtnDhwoq/+/j4iNvx48cLS6D8Pt3S/Xu36lzAJSUlePzxx+Hr6wszMzMEBATgm2++qdb6+cUXX4jP5+DggGeeeQZFRUVK/V6ZxsESn2EewM1E1VgA5S3hjt5MFXGAwZ62Tfr+DKMOCVhleXkqeW89M7MKUdQYYmNjMWLECCGSfvvtN1y7dg1z5syBqalpFbH266+/Yu7cuTh69Ki4n5GRgQEDBuCJJ57A4sWLkZeXh9dffx1TpkzBvn37qvzfSy+9hJMnT+L48ePifXr27InBgwfj9OnTcHZ2xsqVKzFs2DBh3SPocRJ2BN1OmjQJRkZG1Y6/tLQUnp6eWL9+vRB2x44dw5NPPimEHo1Fzv79+8VjdHvz5k1MnToV7du3F5+VUU9YADLMA7iZ3LQ1AO8tCC0JQLYAMroHib/wDh1V8t4BZ89Az7zxbR+XLVsm4uq+++47IShbtWqFuLg4Iebeeecd6OtLjjh/f3989tlnFf/34YcfIiQkBB9//HHFY7/88ot4revXr6Nly5biseDgYLz77rsVr0Hvs3fvXiEAnZycxOO2trbCOihH/jgxf/58EfNHorA6SBi+9957FffJEkhCc926dVUEoJ2dnXhvEpn0GUeOHCnGwQJQfWEByDC1kJpdgLScQpAhoLlT01oACc4EZhjN5urVq+jevXsVayJZ6LKzsxETE4NmzZqJxzp2rCp0L1y4IKxp5P69l1u3blURgJUhK1xSUlKdxrZixQr8/PPPwqpXWRTey9KlS4X4jIqKEpZIilEk615lgoKCKiyM8nGEhYXVaRyMamAByDB1SADxsDWDmfHdya2paFWeCSxvCacIlxTDaArkhiVLnKreuymxsKhaYooE4ujRo/Hpp5/e91wSV3Ludd3SHEFu2wdB4vK5557DmjVr7hORlfnrr7/wyiuv4MsvvxRC1srKCp9//rlwOVemoeNgVAcLQIapSwJIE8f/yaG4Q0N9PcjyixGXmS+EKMPoCiI5QQFuWFUSGBiIDRs2VLmAozg/ElIUW1cTHTp0EP9HCRuNycglYSaP95NDMXoU9/e///0PEyZMqPX/aaw9evTAvHnzqlggGc2Hs4AZpi49gF2aPv6PMDE0qEg+uRrHbmCGUWcyMzNF9mzljRImoqOjhbWNEkC2bNkiYvYocUMe/1cdlEWblpaGhx56SMTnkejatWsXZs+efZ+gqw0SkBSLl5CQgPT0dOHCJcsixRfS2Ohx+VYdFFcYGhoq3ptiD99+++0a4wUZzYIFIMPUpQagCuL/5HAcIMNoBgcOHBDCqvL2wQcfYMeOHTh16hTatWuHp59+WpRVeeutt2p9LXd3d2F9I7E3ZMgQtG3bVpSJoYSO2oTjvZDrdvfu3SJ5hMaTmJgohCiJQnoPcifLt+p46qmnhJWQsnq7du2K1NTUKtZARnPRKyO7NNMgZDIZbGxsxFWftbW0SDPaRdeP94hWcBvn9UCHZnYqGcOKQ7fw8Y5rGNHWFcumqyYjkmGagvz8fNy+fVtkmlKZFIZR1vEk4/WbLYAMUxOy/CIh/lRRA7Ayrd1sxO1ldgEzDMMwCoIFIMM8wP3ram0Ka9Pqi6Q2BUHu0tVpZGquEKUMwzAM01hYADKMmnUAuRc7C+OK7N8rbAVkGIZhFAALQIapgRtJWWohACtbAdkNzDAMwygCFoAM88ASMOogAMvjAGMzVT0UhmEYRgtgAcgwDygCrcoSMHLYAsgwDMMoEhaADFMNuYXFiEnPU2kR6Mq08ZAsgDeTs5FfVPcisAzDMAxTHSwAGaYaIpJzxK2DhTHsLYxVPRy4WJuIsZSUluFaghSbyDAMwzANhQUgw9SSANJcDRJACOoh2rrCDcxxgAzDMEzjYAHIMLUlgKiJAKzsBuY4QIbRLlatWiVavGkCCxcuRPv27et9Abt582aljYlpGCwAGaYabiSqnwCsSAThTGCGUTtmzZolhA5txsbGaNGiBd5//30UFxdDm3jllVdEH2FG8zFU9QAYRp0tgC2cVZ8Acm8pmKsJWSgqKYWRAV+/MYw6MWzYMKxcuRIFBQXYsWMHnnnmGRgZGWHBggXQFiwtLcXGaD5asYIsWrQInTt3hpWVFZydnTFu3DiEh4c/0OQuv1qTb9x8nCEKiksQmZarNjUA5Xjbm8PSxBCFxaW4lSwJVIZh1AcTExO4urrC29sbc+fOxaBBg7B161akp6dj5syZsLOzg7m5OYYPH44bN25U+xp37tyBvr4+QkNDqzz+9ddfi9ctLS3FgQMHxJpFlrhOnTqJ1+zRo8d9697y5cvRvHlzYZEMCAjA77//XuXv9Bo//PADRo0aJV4jMDAQx48fx82bN9GvXz9YWFiI171161aNLuDTp09j8ODBcHR0hI2NDfr27YuzZ88q6BtllIlWCMCDBw+KK60TJ05g9+7dKCoqwpAhQ5CTI2Vy1oS1tTXi4+MrtsjIyCYbM6O+3EnJFdm2VqaGcLYygbqgr6+H1m5yNzDHATLaT1lZGYoKSlSy0Xs3FjMzMxQWFgr3MAk6EoMksOi1R4wYIdaqe/Hx8RHCkSyJlaH79DokDuW8+eab+PLLL8VrGxoa4rHHHqv426ZNmzB//ny8/PLLuHTpEp566inMnj0b+/fvr/K6H3zwgRCn58+fR6tWrfDwww+L55LVkl6Xxvrss8/W+BmzsrLw6KOP4siRI2IN9vf3F5+NHmfUG61wAe/cufM+6x5ZAs+cOYM+ffrU+H909UNXawxTUws4OkbUCcoEPnUnTSSCTOyo6tEwjHIpLizFivkHVfLeT37TF0YmBg36XxJNZJ3btWuXsPZRAsTRo0eFNY34888/4eXlJR6fPHnyff//xBNP4Omnn8ZXX30lrIpkUQsLC8OWLVuqPO+jjz4SFjfijTfewMiRI5Gfny+8WV988YUQjPPmzRN/f+mll4RAo8f79+9f8RokCqdMmSL2X3/9dXTv3h1vv/02hg4dKh4jEUnPqYkBAwZUub9ixQqR0EKGGbIsMuqLVlgA7yUzUwqSt7e3r/V52dnZwqROJ+LYsWNx+fLlWp9PcR0ymazKxmgf6pgBfG8m8CUuBcMwase2bdtEfBwJMBJ+U6dOFSKMrHNdu3ateJ6Dg4NwyV69erXa16EwJgMDA2HFkxs1SLSRdbAywcHBFftubm7iNikpSdzSa/fs2bPK8+n+ve9Z+TVcXFzEbdu2bas8RqKypvUuMTERc+bMEZY/cgGTZ43W1qioqAd+X4xq0QoLYGUoPuKFF14QB3qbNm1qfB6dfL/88os4+Ekw0lURXZ2RCPT09Kwx1vC9995T4ugZdWoB569GCSD3ZgJfjZOhtLRMuIUZRlsxNNYXljhVvXd9IZFGcXcUc+fu7i6EH7l96wv9P7llye07YcIErF69Gt988819z6MEEzlybwWtgfWhuteoz+uS+zc1NVWMjwwqZLEkKyK5vhn1RusEIMUCUrwDxSPUBh2gtMkh8UcBsBQQSzER1UExEWRGl0NXRGQ9ZLSLm+UlYMgFrG7QmIwN9ZFVUIzo9Fx4O1ioekgMozRIfDTUDasKKGmCyr9UhtYVKgVz8uTJChcwCSZK2GjdunWNr0VuYDJiLFu2TPw/CcH6QO9LbmcSaHLofm3v2RDoNWmMFPdHREdHIyUlRaHvwSgHrRKAFKhKJvhDhw7VaMWrCbriCQkJEdlPNUFXNrQx2gv12ZVn2LZyUz8LIJV+aeVqhYsxmbgUK2MByDBqDrlGKcSI3KRkYKBqFRSv5+HhIR6vTcB169ZNxOVRcgcllNSHV199VcT20bpGSSX//PMPNm7ciD179kDRn4+yiykbmYwi9L71HSujGrQiBlCepUTxEvv27YOvr2+9X6OkpEQE2crjKBjdjf8rLi2DrbkRXK3VsyxQRUFojgNkGI2AXLkdO3YUSRHkeaI1i+oEVna1Vsfjjz8uXKmVs3vrCsURkluWwpuCgoKE+KRxUHkXRfLzzz+LMjcdOnTAjBkz8Pzzz4skTEb90StTRK67iqEsJ4qRoAwpiu2TQwGp8isRiqegKy6K4yOoQjtdXZG5PiMjA59//rnIyKLM4bqayOlqh96DYggp8JXRfNadjsZrGy6iR3MHrJ7TDerI7yci8fbmS+jT0gm/PdZF1cNhGIVByQa3b98WF/Fcl1Uq0bJ+/XpcvHhR1UPRuuNJxuu3driAKeiWuPfKRl43iaCMpMr1k+iKhUzyCQkJojgnXZ0dO3ZM4fERjGZxJV7KdJPX21NH2pRbAK/EZQpLgrqVqmEYpnFQFi0VhP7uu+/w4Ycfqno4jJaiFQKwLkZMqpxemcWLF4uNYaoVgOUiSx1p5WoNSv5NyS5EUlYBXNTUVc0wTMOgkKY1a9YIN25D3L8MozMxgAyjqAsJKq+i7gLQzNigIkP5QnSGqofDMIyCobp/VHd27dq1oh4gwygDFoAMU05Mep4or2JsoI/mTupXAqYy7b1sxe15FoAMwzBMA2AByDDlUHs1wt/FUpRbUWdCmtmJWxaADMMwTENQ71WOYZoQTUgAudcCSC7gklKNT+RnmCrUt5sFw1QHH0c6kATCMIrgigbE/8lp6WIFc2MD5BSWiNqFAa7qV7SaYRrSAo2qNcTFxcHJyUnc5yx3piHx3FQ/MTk5WRxPdBwx98MCkGHKuapBFkADfT0Ee9rgREQazkWlswBktAJarKlmW3x8vBCBDNMYzM3N0axZsyol4Ji7sABkGACZuUWIzcgT+4EaYAEk2nvZCQFIcYDTujRT9XAYRiGQtYYWbep/Sx2aGKYhUPa0oaEhW5BrgQUgw1SK//OyN4O1ae3tmdSFkGacCcxoJ7RoU5u0B7VKYxim4bBdlGEqCcBAV82w/hEh5Ykg4YlZyC4oVvVwGIZhGA2CBSDDaFgCiBxna1N42JqBGuFcjGErIMMwDFN3WAAyjIaVgKmuHMy5KBaADMMwTN1hAcjoPIXFpbiZlKVxFkCC4wAZhmGYhsACkNF5qI5eUUkZrE0NhUtVk6jcEo5qXzEMwzBMXWAByOg8Fe5fd2uNKxnQxsMGhvp6SM4qqChjwzAMwzAPggUgo/NUJIC42UDTMDUyQGB53CK7gRmGYZi6wgKQ0XmuxGeK20A3zeymwYkgDMMwTH1hAcjoNBQ3p4klYCrDiSAMwzBMfWEByOg0FDcnyy+GkYEe/J012wJ4KTZTZDQzDMMwzINgAcjoNFfjpfIvLZytYGyomaeDr6MFbMyMUFBcimsJkjWTYRiGYWpDM1c8hlEQ56PTxW2Qhrp/CcpcrlwOhmEYhmEeBAtARqcJvSMJwM4+dtBkOBGEYRiGqQ8sANWUklIu6qtsKF5ObjHr6G0PTaaDtyRgQyPTVD0UhmEYRgNgAaiGhN5Jw9CvD+FERKqqh6LVXI7LFHFzduZGaO5kAU2mo7cdDPT1EJ2Wh5j0XFUPh2EYhlFzWACqIRvOxor2ZAs2hiG/qETVw9F69y9Z/zStA8i9WJoYIthTKmR9IoKtgAzDMEztsABUQxaMaAVnKxPcTsnBN3tvqHo4WovcXdpJw+P/5HT3cxC3x2+x5ZhhGIapHRaAaoi1qRE+GNdG7K84FCHquzGKLwB9JlKyAHYqj5/TdLqVC0AKHaDPxzAMwzA1wQJQTRka5IoRbV1FMsgbGy+iuIQL/CqSO6m5SMkuFLX/2pa7TjUdsmQa6uuJ4tYx6XmqHg7DMAyjxrAAVGMWjgkSBX4vxcrw85Hbqh6O1iXaEMEeNjAxNIA2YG5siHbl5WDYDcwwjKaTml2AX47cRhEbQJQCC0A1xtnKFG+ODBT7X+2+jjspOaoektZQ4f710ezyLzXFAXIGOcMwms6nO6/h/W1X8Mr6C6oeilbCAlDNmdzREz1bOIhyJZQVzLFdiuF0uQVQW+L/5HRvXp4IwnGADMNoMGci07AuNEbsz+zuo+rhaCUsANUcKk+yaHwwTI30xaL+58koVQ9J40nPKcSt5JyK+nnaRIdmdjAy0EN8Zj4iU7keIMMwmgfFvL+9+bLYn9rJS+vmaXWBBaCakpNZgNLybiDNHMzx2tBWYv/jHVcRncYLuyLcvy2cLWFnYQxtwszYACFe0mTJbmCGYTQRMnRciZfB1tQIz/XwVfVwtBYWgGrIhb3R+OPt47h2LL7isVk9fNDFxx65hSV47e+LFeKQqT+n5fX/tPSqslslNzDDMIwmkZxVgC/+Cxf7z/u5YfunZ8WayCgeFoBqCMVuFReW4sSWWyjMKxaP6evr4bNJwTAzMhAL+x8nI1U9TI3lTEUHEC0VgH72FZnAHAfIMIwmsejfq8jKL0aIqzXKLmaguIC7YSkLFoBqSNt+nrB1MUdeVhHO7LxT8biPowXeGC65ghftuIYojvGqN9Ra72KMVFi7s5ZlAFeOA6T6hklZBaKbDMMwjCZw6nYaNp6NBXXmfNTOHvnZRWItbNPPQ9VD00pYAKohBob66Dmxhdg/vzcamcl3hd6Mbt7CwpNXVIJX/r7AruB6Ql1VCktK4WhpDG8Hc2gjpkYUB1heD5DdwAzDaEjixztbLon96UHuiD+dJPZ7TmoBAwOWKsqAv1U1xbutA7wC7VBaXIZjG29VPC5cwRPbwdzYQFwtrTp210LIPJjQyLvuX8qw1lbk5WBOREjxjgzDMOrMyqN3cC0hC7bmRuicqS/WPq/W9vBuI81ljOJhAaimkDjpOdlfmMIjziUjNlwSLvKs4AUjAisKZd5IzFLhSDWL0PL4P211/95bEJrjABmGUXeofSU1OyBebtcMMWGp0NPXE9Y/bb5QVzUsANUYB3dLBPWRYh+O/H2jirv3ka7N0LelkygQPf+v8ygs5lY5D4L6KoeWZwBrawKInPbNbGFiqI+U7ALcSs5W9XAYhmFq5N0tl0VYU2dvWxiFycRjbXq7izWQUR5aIQAXLVqEzp07w8rKCs7Ozhg3bhzCw6U08tpYv349WrVqBVNTU7Rt2xY7duyAutFltC+MzQyREp1dpSwMXRV9PikYduZGol7S4j3S1RNTM+ej05GRWwRrU0O08bCBNkP9jTv5SCL34PUUVQ+HYRimWv67nIA9VxNhqK+Huc3ckBqTDRNzQ3QezfX/lI1WCMCDBw/imWeewYkTJ7B7924UFRVhyJAhyMmpOQPy2LFjeOihh/D444/j3LlzQjTSdumSFISqLphZGqPzSKkNTuWyMISztSkWTWgr9r8/eAsnOeC/VnZfkYKK+7dyhpEOBBX3D3AWt3uvJqp6KAzDMPeRU1CMhVuljh9PdvfBnQOxYr/zSF+x9jHKRStWwZ07d2LWrFkICgpCu3btsGrVKkRFReHMmTM1/s8333yDYcOG4dVXX0VgYCA++OADdOjQAd999x3UuSzM6R1Vkz6GtXET/YIpzOuldRcgyy9S2TjVHbrKJAYGukAXGFT+OSlZiI8LhmHUjcW7ryMuMx9e9mbommco1jgu+9J0aIUAvJfMTKnOm719zYH+x48fx6BBg6o8NnToUPF4TRQUFEAmk1XZmqwszCSpLMzFfdHISKxa/+/dMUFoZm8uAmkXbpGuppiq3EnJwc2kbOFmoNhJXYDqRlK7u+LSMhwMT1b1cBiGYSq4HJeJleVVLN7s7Y8r5da/XpP9uexLE6F133JpaSleeOEF9OzZE23atKnxeQkJCXBxqWoJovv0eG2xhjY2NhWbl5cXmgqfto6iNExpSRmOrL9R5W+WJoZYPLUd9PWAjediseW8dCIx91v/uvjaw8bMCLrCwEDnKp+fYRhGHRLy/rcxTNyObOOKotBUkeTo09aBy740IVonACkWkOL4/vrrL4W/9oIFC4R1Ub5FRzdtf8Jek/yhb6CHyEupuBNWNbC/o7c9nhvgL/bpxOIOEFWRCyC5W1RXkH/eA+HJotAqwzCMqqH6tRdiMmFlaognWrgh6nKaWNt6TpLWMKZp0CoB+Oyzz2Lbtm3Yv38/PD09a32uq6srEhOrWkXoPj1eEyYmJrC2tq6yNSUUG9FugGR1JCtgyT2lX54b0EJYuHIKS/Ds6rMoKOYeikRmbhFOl9f/0zUBSG3hKFM8M6+oogg2wzCMqohOy8UXu6QqHQuGtsLl7VJf+3YDvcQaxzQdWiEAqdAtib9NmzZh37598PV9cPp49+7dsXfv3iqPUQYxPa7OdBrhAzNrY2Qm5eHCvqoWSEMDfSyZFiIW/MtxMtEvmAEOXE8SroaWLpaiiLYuYaCvJ7KeiT1X2A3MMIxq1+o3N18SNf+6+tojILMMmcl5MLc2Fmsb07Toa4vb948//sDq1atFLUCK46MtLy+v4jkzZ84ULlw58+fPF9nDX375Ja5du4aFCxciNDRUCEl1hmoC9hjfXOyHbr+DnMyCKn93tTHFl1PaVZjZd12uOaZRV9hdLnx0zfonR/65yQ3OXUEYhlEVm87F4tD1ZBgb6uPdwQE4869k/es+oTmMTQ1VPTydQysE4PLly0VMXr9+/eDm5laxrV27tuI5VBYmPv5uIeUePXoIwbhixQpROubvv//G5s2ba00cURcCurrC2ccaRQUlOL7pbp9gOQNauWBOb8kK+trfF0V2sK5CHVIOXk/WqfIv99KnpROMDfRxJzUXt5I5NpRhmKaHuhK9v+2K2J8/0B9xhxLEGubia42ALjWHXjHKQysEIFk1qtuoNqCcAwcOiPqAlZk8ebLoGELlXShxZMSIEdAEqEdin6ktxX74iQTE35LK3lTm1aGt0M7LVsR+6XI84Ok7acjKL4ajpTHae9lCF6Es8a5+UkkkLgrNMIwq+GDbFdGJqZWrFcZ4OIi1C3pA7yktxZrGND1aIQB1EbpqCuzpJvYP/RVepU8wQSb27x4KEW3PzkVliJNPl92/1BWD4uF0lcGtJevn3qtSNxSGYZimYt+1RGw5HydKlX0yvi2OlZcya93DTaxljGpgAajBdB/XXPRMpD7BVw7fX/vPy94cX09rL/b/OBGFv8/EQJcgK/Dea+Xxf+UCSFcZUJ4IEhqZhvScQlUPh2EYHYG8UAs2hon9x3r6wuB2jlizaO3qNk6KZ2dUAwtADcbMyhhdx/iJ/RNbIpCXXVhtPOALg6TaSm9uCsOl2PvdxdrK9cRsRKflCWtob39H6DKedubC9UKG4v3hbAVkGKZp+HDbFSTKCuDraIFnevji5NYI8TitXbSGMaqDBaCGE9TbHQ6elijILcaJzdKJdS/PD/AXFqCC4lI8/ccZnbEA7bwkZUD3bO4Ac2POMJO7gbkrCMMwTQFdbK4/EwM9PeCzScE4v/2OWKscvSwR1If7/aoaFoAajr6BPvpOkxJCrhyNQ+Kd+/sT6+vrYfGU9qJfcEx6HuavPS/q4mkz1PVi7ekosT+6nbuqh6N2XUFyCopVPRyGYbQYWX4RFmyQXL+ze/iiWZkhrhyTKnFQEiOtS4xqYQGoBbi1sBWlYVAGHFoTjrJqxJ2NuRF+mNERpkb6og7Tpzu1u0j0vmtJiMvMF0WxR7SVkmV0nWBPG/g4mCO3sKTCOsowDKMMPtp2FQmyfHg7mOOVwS1FsiKtUQHdXMWaxageFoBaAhXSNDI1QFJklrAEVkegmzU+myQViV5xKKLCQqaN/H5CKjA6pbMXTI0MVD0ctUBPTw8TOkgtEjee062EIIZhmg4yMqwNjRau388ntcPt04libTI2NUD38kYGjOphAaglWNiYoOtoKSGEikPnZVUf5zemnbsowkm8uekSjt9KhbZxOyUHh2+kiMlnehdvVQ9HrRgfIsXdHLuVijgdLhDOaCa5hcX48r9w9Pt8PyYtP4YFGy/ilyO3cfhGsnA5MuqR9fv6hoti/9HuPmjraFnRsKDLaD+xVjHqAQtALaJtPw84eEgJIdV1CJFDWcEUF1dcWiaSQkgwaRN/llv/+rV00rnevw+CSgNRD07qCEdtmRhGU0o6bT4XiwFfHMS3+26KrjahkelYcypadJeY8fMp9P50P07dTlP1UHWehVsvIz4zX4SbvDYsAMc23RJrEiUr0hrFqA8sALUtIeThALF/9Vg84m9m1OgK/HxSsOiMQVdrj686jYxc7cgMzi8qEVlnxIzubP2rjolyN/DZGO4NzKg9F2MyMHH5Mbyw9ryIKfOyN8Piqe3wzbT2eG5ACwwLcoW7jamYy2b8fBJ7you/M03PjrB4cWFJ+R1fTmmPjKhsXCtP/Oj3cIBYoxj1gX8NLcOtuU1Fh5CDa8JRWlJa7fMoLm7FzI7wsDVDREoOnvr9jBBPms4/F+LEQuBpZ4a+LaXix0xVhrd1FclA1Bf4Qozu1IVkNA8KUSHxdzYqA+bGBnh1aAB2v9gX40M8Mba9B14eEoDvZ3TE3pf7YWB5qaun/jiD9aHRqh66zpGUlS9qzRJz+zVHe08bHFwdLu637ukGVz8bFY+QuRcWgFoIBdmaWBgiNTYHF/fXHOzvbGWKnx7tJHrFnrydhvl/nRPlUzSZP8rdv9O7eut067fasDI1wtAg1worIMOoIzeTsvHU76EoKilD/wAn7H+lH57p36LapC4zYwMhBMm6TSWuXv37In44WHMYDKNYyJPwxoYwpOcWobWbNeYPbImw/TFIi8sRa1E3TvxQS1gAaiFmlsaiTRxx6p/byE4vqPG5lBlMlkBjA33supwoEkM01S14ITpDWLTos0zpJLk5meqRZwNvvRCHwmLNFv2M9pGSXYDZq05Bll+Mjt52WP5IR7hYm9b6P0YG+vhicjCe7CMlwy369xqLwCZi7eloUXqL5t7FU9ujMKtIrD1Ej/EtxJrEqB8sALWU1j3dRZPtooISHP1barxdEz2aO2LJQ+1F3Aal7n+6UzLba6r1b2SwGxwsOdOsNnq1cISzlQkycovExM0w6gKFosz5LVS0caTi9StE/dK6lXKi+Ob/jQgUyQfEF/+F41rC/cXxGcURlZqLD7ZdEfvkog9wtcKR9TfE2kNrUGAPrsOqrrAA1FL09PXQ96EAUQrl5pkkRF6uvdzLsDZuWDShrdj//uAt/Hio+rZy6kp8Zp6wZhGPdGum6uGoPeQel5eEYTcwoy6UlpbhpXXncS4qAzZmRlg5u3ODLubm9m0uOt+Q+/iV9RdQpOGhLeoKfa/P/3UOOYUl6OJrj8d6+SLyUipunU0Sa49YgzgUR21hAajFODWzQnB/L7FPHUKKCmtP8pjauRleH9ZK7H+04yr+PClZ1DSBj3dcEwHgnbzt0KGZnaqHo1FuYOrXmaYj/aEZ9eabvTewIywBRgZ6onNRcyfLBr0OWQI/Ht9GiMhLsTJ2BSuJJXtv4Hx0BqxMDYXrt7S4VCQfEsEDvMQaxKgvLAC1nC5jfGFpZwJZSj5Cd9x54POf7uuHp8pjaCge8NdjD/4fVXMiIlVk/9IV58IxQWLyZx4MuWraeFgLKwlbARlVExaTie/23xT7iyYEo5ufQ6Nez9naFAvHtK4QluwKVvy8e/f3aisqSoRuv4Os1Hyx5nQZ7avqITIPgAWglmNsaojeU1uK/fP/RSE1LrvW55N4emN4qwoR+O7Wy2rtDqasZSo8Skzv2gxtPLjUQH14qIvkLl959I7GZ4AzmgslIr369wWRwTuyrRsmdVRMEte49h7sClYCmblFeHHteVFQnhLuRgW7IzU2G+d3S+1Fac2htYdRb1gA6gB+7Z3gE+wo4muoLlNZaVmdRCAVWZW7g5eWX+mpY+LHtYQs2Job4eXBUuA3U3eobIaDhTFiM/KwPUwq2MowTQ1Zkug8trcwxntjgxT2uuwKVjxUJWLBpoui24evowXeHR0k1hRaW2iN8W3nKNYcRv1hAagj9JnWEoYmBoi/mYmrx+PrNHFSkdWXBkvWw893heOr/8LVqkQMlYr4cvd1sf/KkADYWXCpgfpC2ZWP9vAR+ysORajV78voBpfjMrGs/ALzvTFBcFRwBv+9ruCI5Nq9IEztrAuNrojTXDItBBYmhlLnqVuZYo2Re5wY9YcFoI5gZW+KruUxGcc23ESurG5B/88P9K9IDFmy7yZeXn8BBcXq0THk853hyMovRpC7dYUrk6k/M7p5w8zIAJfjZDh2q/ZscYZRJOSSfXX9RdGXnFq6jQpWTskQcgX3C3ASruBPd15TynvoAuEJWSIsSH7R3dbTRqwlxzZKAp7WGFprGM2ABaAOEdzfE45elqIx94NqA1aG2vp8OK6NKB2y8WwsZvx0SuVZo5R5tu6M1O7p/bFB3PWjEZDlVF44+wc1jvdktI/lB27hSrxMhHB8MK6N0hK46HXfHBEoap1SwfvTd9KU8j7aTE5BMeb9SS1DS9Hb3xFzektx4lTzj9YUWltojWE0BxaAOgQ14u43vZXIlr1+KhFRD6gNWJlHunlj5azOsDIxxKk7aRi/7Kho1aSqmn/z/jgjApAndPBAR297lYxDm3iit59YHA9dT8bVeM6WZJTPjcQsfLtPuhBdODoITlbKLd7u72KFqZ2lslgf77jK4Q71gL6rtzZfEv3DXa1N8fXU9tDX1xM1/26cThRrSv9HWok1htEc+NfSMVx8rCtqAx5YHS6qtdeVPi2dsHFeD3jZmyEyNVeIwL1XE9GUZOQWYubPpxCXmQ8/Rwu8PVKK7WEah5e9OYa3ldxv6pz1zWiXoCCX7MBWzhjb3r1J3vfFQS1hbmwgCk1THBtT91Zvm87FCk/Ltw+HiOLchfnFIvFDXvPP2dta1cNk6gkLQB2tDUhxGlSv6eQ/EfW+it48r6foz0nxd4//Gor/bQoT7gFlk1dYgid+DcWNpGy4WJvgt8e7cOKHApGX/qGOKnEZeaoeDqPFUCjJydtpMDXSb9LanZQQInddfrbrGvfBrgNX4mR4p1LcX2cfyeNCvX6z0vLFWsI1/zQTFoA6CNVn6vuwVDLl4t5oJEXWz+VHV3+r53TFE72kk371ySiMXHIYZ6PSoSyoRt1za84iNDId1qaG+O2xrvC0M1fa++kiwZ626OZnLwLyVx6VGrkzjDJqyJELVp5kRtbnpuTJPn7C3UxeDHn/cKZ6svKL8Mzqs0Io9w9wqrhITLwjw8V9Ugx23+kBXPNPQ2EBqKN4t3GAf2cXEUe3/49rKKlngVQTQwO8Nao1Vj/RFe42priTmovJ3x/HF7vCFW4NpMnnjY1h2HM1CSaG+vjp0c6iiwWjeJ7q07xC1Cdl5at6OIwWQpa31JxC+Dtb4olekqBoSqhsCbmCiSX7biAzr6jJx6AJUE0/Kp59OyVHzPFfTZHi/mitoDWD1g5aQ7yDGtexhVEdLAB1mF6T/WFiboiU6Gxc2CNdzdWXHi0c8e8LfTCuvbuo4k8FXft8th8/H7mN/KLGl4s5E5mGUd8ext9nYkSSwrcPhYim44xyoFIZwZ42orn7l7ukGosMo8js/dWnpG4RlPVrbKiaJYiy3ls4WyIjtwjLDqhnkXtVs/zgLZExbWygj6XTO1SE29BakRqTDRMLQ7GGMJoLC0AdxtzaGD0nSd0+Tm27jYzE3Aa9DlXZ/3paCJZP7wAfB3Nxdf/Btivo/8UBYUlqSN1AWX4R3tochknfH8f1xGzRIWDZ9A4YEuTaoDEydYNisd4ZJSXWUJmdS7GZqh4SoyXQBeKbm8Kk7P0Qj0b3+m0Mhgb6WDC8VUUbRI55rcr+8CR88V94RZmtkGZ2Yp/WCForiJ4T/cUawmguLAB1nFbd3eDZyg4lReVm/Qe0iasNyiLd/VJffDKhLdxsTEWrIEoQ6fjBHhFHsuV8rBB2tRWFPROZLtrODfryIP44ESUWi8kdPbH3pb4Y1kY5RWKZqnTyscfodu7iu39/2xUul8EohN+P3xHFximG938jA1U9HAxo5Sy8CRRisri8oxAD3EnJwfw158T5/3DXZphWXmSf1gYRLlRUKtaMVt35YlzT0Svj2b3ByGQy2NjYIDMzE9bWmpsCL0vJw5r3T6K4sFQkh7Tp49Ho1yT3L1n/qL1YguxuLBm1D2rrYSMselamRrAyNRRdKKgYLIm/3MK71kLqM/nR+Dbo0dyx0eNh6gf1Bh745QFR9JUsryPKS8QwTENIyMzHoK8OIrugWBSVp7qi6sC5qHSMX3ZMhJf8O7+PzscWU/w2lfcirwtVelgzp1uFm/7SwRgcXHNdtHt76O0usHY0gyYj05L1uzFw6g4jTuRuY5uLiu7U0ocSRBrbzod6zD7WyxezevjgYmwm/rucgP+uJIri0WejMmr8PztzI3T1dUBPf0dh+aPXYZoeD1szPNmnOZbsvSEyNslawr8F01De3XpJiL+QZrZ4WI3aNpJrc3gbV/x7KQGf77omEsx0Oenj1b8vCPHnbGUiQnrk4o/KvRzbeEvsdxvrp/Hij5FgAcgI2vb3xM0ziUiIkOHAn+EY9WywQmpzUdZYey9bsb02rJVoxE7WPqohSCUG6JYWhmb25uje3AEtna3E/zCq5+m+flh3Ohox6XkiqeeZ/lK8KMPUB7r4o2QCQ309LJrQVu3O71eGBoiLU6oycOp2ms4mmS3ec10UxyYvzfJHOoiaiQQ5CWlNoKYBrn42CO7H7d60BY4BZAQ0KfefEQh9Qz3RIo5axSkDPydLjAp2x0NdmgkL08tDAvDu6CDM7umLVq7Warc4NJSy0lKk/fYboh57HAW3pCtnTcPc2BBvlAfKU1xmYiVXPsPUBbrIe2fL5Yr6e3SOqxvNnSwrWsR98q9utojbcCYG3+6TsqE/Ht+2SnvN6ycTxJpgYKiPATNbQU9L5miGBSBTCXs3C3QeKRV3PrzuOnJlhaoekkZSFBeHqNmPIfHjRcg5dgyJH30MTYVadJHbjmIz39x0SScXR6bhfPnfdRED7O1gLoo+qysvDPQXscgUnkLWSl3iZEQq3th4Uew/0785JneSxDBBa8Dh9VK/5s6jfGDnaqGycTKKhwUgU4WQIc3g6GWJgpxiHPpLKgPA1A0SR5lbtiBizFjknjwJPTMzwNBQiMDcs2ehiVAYAAXtUy2wPVcT8dtx7pzA1L3m36/H74j9j8a1VesYUnJ3PtHbt6JQNXUe0gWoyPNTf5wRPZlHtnXDy4OlDlHy+ezgmnCxFtCa0H6w+sRuMoqBBSBTBQMDMvMHClfsrbPJuBGqW1fDjXH5xr36GuJefwOl2dkwa9cOfps2wnb8OPH3lO+WQlMJcrfBghGSK/ij7VdxOY5rAzK1QyWdFmy8W/Ovl7/6Z/KTi5qqE0Qk5+DPk1Kxam0mI7cQj606LYphU4z2l1PaVQnBuXkmCRHnksVjtCbQ2sBoF/yLMvfh5GWFDsOlMg2H/mJXcF3IOXIEsm3bhMXPaf7z8P7zDxj7+MDhqac03gpIUDb3oEBnFIqezOcU3u6P0S6W7b+Fq/EykdX/phrU/KsLVJbqpcFSizgqgpySXQBtJbewGI//GiosgJTx/+PMTlUstDTnH1oj1UbsONxbrAmM9qE1AvDQoUMYPXo03N3dhdtq8+bNtT7/wIED4nn3bgkJCU02ZnWm03AfOHhYIj+7iF3BdUD233/i1m7KZDjOnQs9QynB3tjTUyusgHRufD6pHVytTYWF5N2tUmA/w1Tn+qUeuwQleDlYmkBToOS0Nh7WojrBJ/9egzZCha/n/nFW1F2loty/zOoMJyuT+1y/+TlFcPC0RMfhPiodL6M8tEYA5uTkoF27dli6tH6LbHh4OOLj4ys2Z2dnpY1Rk6CMr4GPsiu4LpQVFyN7z16xbzVkyH1/1xYrIPUC/Xpae1E0l3ozbz4Xq+ohMWpoWXpx7XnR9m1UsJtIItIkDPT18P7YNmKfjnESSdpW6++V9Rdw8HoyTI30sXJ25/uKX1d2/dIaQGsBo51ozS87fPhwfPjhhxg/fny9/o8En6ura8Wmr681X0mjcWrGruC6kBsaipKMDBjY2sK8U6f7/q4tVkCC+rfKszmpzR9ZexhGDhUNJ7ciWYop8UMRtUSbmg7N7DClk1Tr7p0tl4SY1QbIsvfeP5ex9UKcqMm4/JGOVcq9EOz61S10Xu20b98ebm5uGDx4MI4eParq4ai3K3hNOJcBqYascvev5aCBFa5fbbUCEs8N8EevFo6iNMyjv5wSsV4Ms/9akujfTVBCgY25ETSV14e1Eu5R6l28+qR2ZL4v2XsTvx6PBGly+n36B1T1drHrV/fQWQFIou/777/Hhg0bxObl5YV+/frhbC2Lc0FBgegfWHnTKVfwOXYFV5f9m7V7j9i3rsb9q41WQHKT/TCjIzo0s0VmXhFm/HxSdHhhdJfU7AK8+rdUS+6xnr7o2UL9s35rg+IWXx0qlUT5fFe4+HyaDBVyp04fxMLRQRjb/v5+7zdOJ7LrV8fQ2V84ICAATz31FDp27IgePXrgl19+EbeLFy+u8X8WLVokmkfLNxKNuuIK7jhCuhok90BOhmZPhook7/x5FCcnQ9/SEhbdutX6XGEF1NMTVsCipCRoMhYmhlg5uwtau1kjJbsQ0386iei0XFUPi1FRXNnrG8JE1qy/syVeG3a3lpwm83BXbwS5W0OWX4yPd2huQsg3e24IEUuQqH20x/2Wvez0AhHmQ3Qa6cOuXx1BZwVgdXTp0gU3b0rtcKpjwYIFyMzMrNiio6OhK4h4kGZWKMgtxr7fdbNdUnVk7Sp3//bvDz1j41qfS1ZAk0Cpnl7uqdPQdGzMjPD7413Q3MkC8Zn5eOTnk9wuTgf5Zu8NUSScioUvntperQs+NyQhhFymG87GYPvFeGgSNEd/9V94heWPhHl1/bzpefv/uCrmdmdvK3QYJsV9M9oPC8BKnD9/XriGa8LExATW1tZVNl2BioAOmtVauAWiLqfhypE46Do0cWbt3i32rYYMrtP/WHSVrIQ5J45DGyBX2Z9PdIOXvRkiU3MxbulRXODEEJ3h37B4IQCJD8e3QRsPG2gTHb3tMLdvc7FP7dI0xcpNcxPVMlxS3t/3fyNaYV6/+8UfcflwnJjTRbgPzfFc8Fln0JpfOjs7Wwg42ojbt2+L/aioqArr3cyZMyue//XXX2PLli3C4nfp0iW88MIL2LdvH5555hmVfQZ1x97dAl3H+on9I3/fRGZyHnSZ/EuXRd9favlm2atXnf7HoltXcZt74iS0BVcbU6x+ohv8yi2Bk384jnWndcc6rqtciZPhpXUXKuL+plTqIatNvDi4peiHTbUBn//rnOhyou4u+Q+2XcXS/bfE/bdGBuLJPpKIvReaw49ukERit3F+oh88oztojQAMDQ1FSEiI2IiXXnpJ7L/zzjviPtX4k4tBorCwEC+//DLatm2Lvn374sKFC9izZw8GDhyoss+gCbQb6AW3FjYoLijBvt+uokxLSiQ0Kvu3Tx/oU9/fOmDWsROZU1EUE4PCmBhoC1725tjyTE8Mbu0iCs2+tuEi3tocJvYZ7YOSIub8Foq8ohL09ncUFiZtxchAH0umhcDK1BDnojKweLfkUlVH8otKMO/Ps/jl6G1x/93RrfFEb+mivTqhuPfXK2Iud/e3RbsB2ingmZrRK+NgrgZDWcCUDELxgLrkDqarxr8+PCUmjh4TWyBEB5uE02kTMWw4CiMj4f7lF7AZObLO/3tn2kMiecTtow9hO3EitAlaVL4rzzikmYUyhT+dGAx/Fw4q1xZI1FO856nbafBxIOHfS6NLvtQVigF8ZvVZERP4+2Nd1a6/MYnyJ34LFSKV4jE/nxxcbbavnHO7o3Bsw00YmRhg2ttdYO1Yt4tYbUGmo+u3VloAmabDxskMvSZJ8SQnttxCaqzulQApuH5DiD9K/LDs269e/2te7gbO0SI3sBwqIUGFon9+tJOwmJyNysCwbw7j/X+uQJZfpOrhMY2E3J8vrD0nxJ+liSF+erSTTog/YmSwm2gVRxc2L647jyQ1SniiMkwTlh8T4k+enFWb+EuJyRZzN9FzUgudE3+MBAtApkG07uUOn7YOKC0uw+5fLqOkqFQn3b8WPXvCwLJ+cTPycjG5J05obTb1gFYu2PF8bwxp7SI6KZBLasAXB7AuNFpYCRnNg8Tf82vOYUdYgrAwffdwCFo465Zl951RrdHSxRLJWQWi9BGVvlGHAtwk/igJy9PODBvm9kBXP4can19cVII9Ky+Ludsn2FHM5YxuwgKQaRDU4qn/jECYWRkhNTYHJ7ZGQJfIPnRI3FoNGlTv/zVr315YDql+YOFtKVZHG6G4wBUzO+G3x7qIBBGqF/ja3xcx5OtD+P34HWQXFKt6iEw9xd+/lyTxR4XA+93TSUIXMDM2wI8zO4lWdzeSsjH9x5NIyylUmSv+o+1XMHvVaWTkFqGdly02zeuJFs6Wtf7fyS0RYs6mubv/I600sl0foxhYADINxtzaWIhA4vyeKMSEa1fj9JoozctD/tWrYt+8q+TOrQ/6pqYwK09WyjlxAtpOn5ZO2Dm/D94cEQgrE0PcTMrG21suo/vHe7Fw62Xc4i4iai/+nltdVfz1b6V74k+Ot4MF1jzZDc5WJghPzMLDP55AehOLQCpHQ9n2Px6WLiBn9fDBuqe6wcnKpNb/i7mWhvN7pAz9ATMCxRzO6C4sAJlG4St3IZQBe1ddQUGu9sd55V0MA4qLYejsDCOPhrlPLLrL3cDaFwdYHcaG+pjTxw/HFgzAe2OChEUwq6AYq47dwcAvD2LI4oP45N9rOH0nDcVqXmZDlyAr7dw/zmLn5QTxG/4wU7fFnxxfR0kEkuC6lpAl3MEZucoXgRQysulcDEYsOSzqbVK8HwnyhWOCYGJYewFu6vG791fpwrV1b3fh/mV0m+o71zNMPaAg4tjwdJEdfHDNdQx5PAjaTN45qV+0WYcODXafyC2HuSdPin7Cevq6cS1mZWokWlHN6OaNo7dS8OuxO9gfnozridli+/7gLdiaG6Grrz2CPW3R1sNGbHYWbKloam4kZuHpP87gVnKOEH8rdNTtWxPNnSyxZk5XTFtxAlfiZZjyw3F8NaW90ophX4rNFBbz0Mj0iiLVSx4KgYdt3RI4qNUbtXyjJL6eE6svCs3oFiwAmUZjbGqIQbNbY+MXZ0VDce82Dgjo6gptJfesJADNO0hu3IZg1qYN9M3NUZKZiYLwcJgGSq50XYGyhXv7O4mNLCcHryeLYHYSgxTPtOtyotjk0CJHVpdmDubwtjeHt4M5PGzNhQXGwdJY1GpjFMc/F+Lw+oaLyC0sEfFuS6d3EIKDqQolwaye0w0P/3hSXMCMXXoU8/o1x7MDWjzQIlef8i5f/Hcdf52OEhnIZkYG4vWf7ONX5+M+/GSCmJv19PUw6LHWYs5mGD4KGIXg6meDziN9cOqf2zi4JlzcpytNbYOsdXnnpe4HZiEdGvw6ekZGMOvcCTkHD4lyMLomACtja24sSlbQRu7f89EZopxFWGym2G6n5CA2I09sqKFVt72FMZwsTYT1UGxmxuLW2sxIuMno1trUUNza0mZuLO4bsnC8L7Fg0b9XsfLoHXG/R3MHYWVytKw9tkyXaelihZ0v9Ma7Wy5je1g8vt13E/9dThR1+MiK3VAoVnb1ySisPxMtupAQY9u7443hreBmU/e5VfLMhIt9mqNdfbWrXR/TcFgAMgqj4zBvRF9JQ/ytTFEaZsIrHaCvZQtswc2bKJXJRPs301YBjXot6gtMApDKwTjMnqWwMWoyJMg6+diLTU5mXhGuxcsQmZaLqNRcRKXliv2EzDyRWUxlZigTsyHZmFSr0M7cWAhIR0vp1t7CRAT4U4s7F2va6L6pcINqKxRbtu9aEj7afhURKTniMbJkvTwkAAb6nCX6IEggk5V0ZFg83t58SSSHUF9sSoAaFeyOIUEusDY1qlMnj91XEvHnyUiciEireLy1mzXeGxuEzpXOi7pQUlIq5uKi/BLRwanjcJ8GfT5GO2EByCgMEnvkXlj74Wkk3pbh9PY76Dqm+jZEmkreOanXtFlwsLDiNYaKvsCnT6OsqKjRr6etkAWP6ppVV9uMagqm5xYiObsAKVmFyMgrFC5kciun5xZBllckBCQVoc7MK664Ly9BQ5YV2khU1gaFepIrlOqsedmZi9tmDhbwdTSHr6Ml7MyNNLacBsX6vb/tCg7fSBH3SQh/PL4thgRpbxiHshjR1g3d/Bzw7tbLwo1+IDxZbMYb9YUY7OZnL4SghYkhLE0NYWSgJyx9FN93KVaG64lZKC6vk0m6m+ppTu/WDH38nRokxEO33xFzsbGZFKZDoRcMI4cFIKNQrB3M0O/hAPz382Wc+fcOvALtRZ9JbSGvPP7PrBHxf3JMWrWCvo0NSjMzkX/5sqgPyNQPWtAcLCkO0ARwrV9pExKDGXlFooRHarkFkeKtyKpIhX4TZPlIyMxHUlY+ikrKEJ+ZL7bTd+4vd0TuZF8nSzR3soC/s5WoxUZbM3tztbWgXUuQ4bfjkVh7OlpYUanEy+xePni2fwuRrMM0DLIif/tQCOYP9Bft47ZdjBM1A/dcTRTbg6ALjSmdvTCtsxfc65jgUR1xN9LFHEz0mx4g5maGqQwLQEbh+Hd2QdSVVFw7niDcD1Pf6gJTC+1YUHLPnRO35h0aHv8nhzJ/Lbp0Qdbu3SIOkAVg00HB8xXC0an255KVkQRiTHouYtLzxBadnovI1BzcTs5BXGY+ZPnFoiwHbZUhtzFli1L3CIoVo83f2VIUyVaFMMwtLMa2C/FYczpKxFnKoY4tb44MFDXuGMVAFwDzB/mLLTwhS8QHUjxrTkExsvOLhRU6v7gEPg4WaONujSAPG5FB7G5j2mhrMpV82f3LFZE00qqHG/w7uSjsczHaAwtARin0ntoScTczIUvOw4E/r2HonDYa6yKTU5ySgqKoKOEPVJRYM+/cWQjA3PLSMox6Whkp25i2kGb3Z8LmFZYgMk0Sg+TOu5mcjRuJ2YhIyUZ+USmuxsvEVhmTcmHo70JWQ0v4OFrAz9FC3FKPXUVBlj2y9FHv3pMRaThyM6XC/W1IGaGBLpjV00e4LRnlEeBqJbamiuekOVde8qX3FP8meV9G82AByCgFKjNA9QA3fnYGt84m4/LhOLTpU3Nzck0q/2Li7w8DK8VM5mYhkpDMP39BTNyaLpJ1EWoP1srVWmz3Wg7JWkgJARTbRbF24SQMk7NRUFwqasfRVl1CgYedGdysTeFmawo3G1MhPq1MjETSCsWO0T5RVFqK4pIy4dImy1JcZh7iMvLLLZW5wiJJ1snK+DiYY2rnZpjU0fOBnSMYzYPmWppz9Q30MPjxIC75wtQIHxmM0nDxsUa38c1xbMNNHFl/A27NbeDgUXufSnUm7+w5hcX/yTENCICeiYmoB1h45w5MfH0V9tqM6i2HVLeQtsGtXapY5UickZXwelIWIpJzcCclB3dSc0T8YYqIQyyAVGyo8VgYG4is6i6+9sLSF+Jly8kAWkpKTDaOrLsh9ruPby7mYIapCRaAjFJpP9ALMdfSEXU5Fbt+vITJCzrDyEQxBVKbGrmbVhHxf3L0jI1hGhQkkkvyLlxgAagDUOwfxdrRNqiSMCQoWzkyJVdY8hLKk07k5W6odV5WflFF/JjcjUvxjPSaZIl0tzET1kNKHvCwNUWgm7UoIcL1DrWfooIS/PfTJZQUl4pi/O0GeKl6SIyawwKQUSqi8vysQPz14SmkJ+Ti8Lrrogm5plGan4/8K1crWsApErN27SQBeP48bMeNU+hrM5oFlQhp62kjNoapD4fXXhdzrIWNMQY+GijmXoapDb4sZJSOmZUxBj8WBOgBV4/G4/rpBGga+WFhQFERDJ2cYOSh2FhGeUJJ3oWLCn1dhmF0g+unEnD1WLyoV0lzLc25DPMgWAAyTYJngB06jZCq0B/4IxwZibUX3lU3civi/zooPFHDrH07cUs9gUtzpC4MDMMwdYHm0gN/Sq3eaI71COCezUzdYAHINBmdR/iIotAUq7Lrp0soLiyBphWANldgAogcIxcXGLq5Udoo8i5dVvjrMwyjndAcuvPHS2JOpblVfpHNMHWBBSDTpK3iqDSMmZURUqKzcXi9lK2m7pSVliL3/HmlxP9VjgMkKA6QYRimLhxedwOpMdliTqW5Vdt6rzPKhY8WpkmxsDXB4NlSPOCVw3EIP6n+8YCFERGiXZueqSlMW7VSynvI3cAsABmGqQs0d145EifmUor7o7mVYeoDC0CmyfFqbS/cwcSB1eFIi8/RiPZvZm3bQs/ISLkWwAtSQWiGYZiaSIvLEd0+iM4jfUXPdYapLywAGZXQaaQvPFvZoZjiActjWNQVuVVOmb16qRYgicuStDQURUcr7X0YhtFsaK6kuL/iwlIxh3LcH9NQWAAyKoE6EZDbwtzaWFzNHlwdrraWr7zzF6q0bVMG+sbGMGkdWGEFZBiGuReaI2muTI/PgbmNVF6Lu7owDYUFIKMySPwNeSJI1K6ieBbqYaluiBZtt25VcdMqC3N5PcBzHAfIMMz9XD4UK+ZKKvJMSR80hzJMQ+FOIIxK8Whph27jmuP4pluiS4iTlxVcfNWnf2XeRak4s5F3Mxg6OCj0tQtKCvD39b9xIPoAWtq1xFAfW1CEIVsAGeZ+SstKcTH5InZH7sb19Ovo79UfE1tOhImBbiQ/JNzOFFm/RLdxfmLuZJjGwAKQUTkhQ5oh8bYMEeeTsXNFGKa82RlmlupxZSu3xsmtc4qgsKQQG25swE9hPyEpN0k8diL+BLZnlmE5JZ1cu4LLMWcR5KmckjMMo0lcTrmMLbe2YG/kXiTlSeeL/Jz5+dLPmNN2Dib4T4CxgXrMGcogL6sQu1ZcQmlJGfxCnBAyuJmqh8RoAewCZlQOddYY8GggbJzNkJ1egP9+uozS0jKtTAD559Y/GLFxBD4++bEQfy7mLpjfYT5G+o1EvoMF0iwB/ZIyvL/qUWyP2K6Q92QYTWVbxDY8vONhrLm2Rog/CyMLca7QOUPnDp1DH538CCM3jRTnljZCc+F/P18Wc6OtizkGzgxUeDciRjdhCyCjFpiYGWL4U23x96ehiLmWjlP/RKDb2OYqLwAtdwErQgDuidyD/x35n9h3Nne+z3JBlsEr+2cBR86hRWypeG4ZyjDKb1Sj35thNA0SdG8dfUu4fvt59cPklpPRza1bxfkys/VMbLyxET9e/BEJOQnifDE3NMdA74HQJk5tjRBzoqGxPoY91QbGZrxsM4qBLYCM2uDgYYn+j0iFls/8G4nbF5JVOp6CmzdRmp0NPXNzmPj7N+q1YrJi8M7Rd8T+1ICp2DFhB6a1mlbFbUX7Xt0Hif1+mW5i4XvzyJtaa9lgmLqIv0ktJ+Gb/t+gj2ef+84XOod2TNwhzini7WNvIzY7FtoChcWc2Rkp9vvPaAUHd0tVD4nRIlgAMmpFyy6uaNvfU+zvXnkF6Qk5qnf/UgFow4ZfdReVFOHVg68iqygL7Zza4fUur9cYuC7vCOIdVYBJ/hPFAkgLIYtARlegY50ufOjYJ6vf293ehr5ezUsVnUt0TgU7BSOrMEuca3TOaTo09+1ZdUXsB/f3RMvOrqoeEqNlsABk1I6ek1qIxuZF+SXYsTwMBXnFqq3/10j37+Kzi3Ep9RKsja3xeZ/PYaRvVGtBaBgaoiQlBW80e1wsgHJL4M7bOxs1DoZRd+gYp2OdQh+mtJyCt7q9Vav4k0PnFJ1bdI6FpYTh67NfQ5OhOY/mPpoDaS7sMamFqofEaCEsABm1w8BAH0PntIGlnQkyEnOxZ+UVlKkgKeRuAkjD6//ti9qH36/8LvY/6vUR3Czdan2+PvUbbt1a7OefOy8WQBKBtCC+e+xd4UpmGG0kOitaHON0rNMx/2a3N+sk/uS4W7rjw54fiv3frvyG/VH7oYnQXEdzHs19NAfSXEhzIsMoGj6qGLWECpwOe6otDAz1cediCk7vuNOk71+SkYHCiIhGWQDjsuOE+1YesE6B7HXBvINU/iX3zBmxAL7Z9U10cO6A3OJcEeheUqq+bfMYpiHQMU2WPzrG6VinY74+4k9O/2b9MaP1DLFP5x6dg5rG6e23xZxHc9/wp9tysWdGabAAZNQWFx9r9H04QOyf3na7SZNC5Nm/xt7eMLRrWMHVT059ImKS2jq2xQsdXqjz/5l1lARg3pmz4tZA30BYD6kExrmkc1h5eWWDxsMw6sovl34RxzYd4x/3/lgc8w3lxQ4vinNOVigT56CmJX2c3i5d7NLc5+ytPkXxGe2DBSCj1gT2cEPbvh4VSSGpcdkaUf/vaupV7I/eL6wYH/b6EEYGNcf91WQBpCxkakVHeFp54o0ub4j9peeWitdnGG3gSuoVLDu/TOwv6LIAHpbS+d5Q6Fyjc04PeuIcvJZ2DZoAzW3k+iXa9vMUcx/DKBMWgIza03OK/92kkGUXkZ9d1HQCMKRhAvD7C9+L2+G+w+Fn41ev/6WWc2R5RFlZxTiIsc3HYlCzQSguK8Ybh99AfnF+g8bGMOoCHcMLDi8Qx/Rg78EY03yMQl6Xzjk69yqfi+oMzWk0txUVSEkfPSdz0gejfFgAMmoPBUBTAVQrB1PIUvKx88cwlJSUKu39ykpKkHeh4QWgyeKwL3qfsEA8Gfxkg8Zg1rGjuM0tdwMTVP3/ne7vwNHMERGZERqf6cgwi88sFseyk5kT3un2jkI7XDwV/JQ4B/dG7UV4WjjUFZrLaE6juc3a0VTMdZz0wTQFWnOUHTp0CKNHj4a7u7uYRDZv3vzA/zlw4AA6dOgAExMTtGjRAqtWrWqSsTL1h3oDj5wXDCMTA8SGZ+BoeVN0ZVBw8xZKc3Kg38AC0HKLwzDfYfW2/skxL48DzD17psrjdqZ2eL/H+2L/z6t/IjQhtEGvzzCqho7d1ddWi/33e74PW1Nbhb6+n60fhvkMU3sr4JF1N8ScRnPbiLnBatMHndF+tEYA5uTkoF27dli6dGmdnn/79m2MHDkS/fv3x/nz5/HCCy/giSeewK5du5Q+VqbhnUIGzW4N6AFhB2Nx6ZByKv7L3a6mwcHQM6hfMDpZGsjiQJaHp4OfbvAYzMrjAPPDLqG0sLDK33p79sZE/4lin/qgFpVqftFbRregY/bDE1LJFur00cujl1Le56l2khVwT9QetbQC0hx26WCsmNMGP9ZazHEM01RojQAcPnw4PvzwQ4wfP75Oz//+++/h6+uLL7/8EoGBgXj22WcxadIkLF68WOljZRqOX3sndB0jWdUO/3UdseHpCn+PvHPnGlz/r8L65zNMWCAairGPDwzs7VFWUID8y5fv+/uLHV+EnYkdbmbcxJ9X/mzw+zCMKvjjyh+4lXkL9qb29cqQry/NbZtjqM9Qsf/DxR+gTsSEp4s5jOg21g++7ZxUPSRGx9AaAVhfjh8/jkGDpL6rcoYOHSoeZ9SbjsO84d/ZBaWlZfj3hzBRMFU5ArB+8X9kYSBLA1kcyPLQGCiMwaxDiDSes3fjAOXYmNgIEUgsu7AMCTkJjXo/hmkq6FhdfmG52KdjmI5lZSKPBdwduRvX0yXBpWpoztr5Q5iYw2gu6zDUW9VDYnQQnRWACQkJcHFxqfIY3ZfJZMjLy6v2fwoKCsTfK29M00PiaMCMVnDxtUZBbjG2Lb2A/BzFuEGLEpNQGBlJb1JRjqWuyC0MZHEgy0NjMe9wfyJIZca2GIsQ5xDkFefhs9OfNfr9GKYp+PTUp+KYpYLPisr6rY0Wdi0wxGeI2sQCUsbvtu8uiLmL5rABM1spNPmFYeqKzgrAhrBo0SLY2NhUbF5eXqoeks5iaCwFTFvZmyIzKQ//fh+GkuLGZwbnnj4tbk0DA2FgXfcirJTJSBYGYf0Lbpz1T455JQtgWdn9rfDkXUIM9AzEex+OOayQ92UYZXEo5pCwktMxW99Wb41Bfk7SeULnqqqgOYq8FpnJeWLuojnM0KjhRa8ZpjHorAB0dXVFYmJilcfovrW1NczMzKr9nwULFiAzM7Nii46ObqLRMtVBLZJGPhMMI1MDxN3IwIHV4dUKpfqQe+qU9NpdutTr/9ZeWytuqd0bWRwUAfUE1jMxkdrS3b5d7XMC7AMwPXC62F90ahEKSgoU8t4Mo4yaf4tOLhL7jwQ+gpZ2LZvsvf3t/CtaMa4LXwdVQHPTgT+vibmK5iyau7jNG6NKdFYAdu/eHXv37q3y2O7du8XjNUHlYkggVt4Y1UJZc9QsnTwo147F4+yuyCYXgLlFudh6a6vYn9ZqGhSFnrExzIKDpfc4U7UcTGXmtZ8HZzNnRGdF4+ewnxX2/gyj6HZvMdkxcDZ3xtz2c5v8/R8KeEjcbrm5RZyzTQ3NTdeOJ4i5iuYszvhlVI3WCMDs7GxRzoU2eZkX2o+Kiqqw3s2cObPi+U8//TQiIiLw2muv4dq1a1i2bBnWrVuHF1+UAusZzcE7yAG9pkjWhBObI3AjtKplt17xf3fuSPF/naT4u7qwLWIbsouy4WPtg25u3aBIKvoCn5USU6qD+qe+1uU1sU8CkIQgw6gT0bK7FyevdX5NHLNNTTf3bvC29hbn6vbb25v0vW+cThRzE9F7aksxZzGMqtEaARgaGoqQkBCxES+99JLYf+edd8T9+Pj4CjFIUAmY7du3C6sf1Q+kcjA//fSTyARmNI/g/p5iI/asuiLcLE0R/0dunb/C/xL7UwKmKDymSZ6Icm9B6HsZ4j0EXd26orC0EJ+d4oQQRr349PSn4tikCyQ6VlUBnZtTWk4R+39d+6vR4SJ1Je5GOvb8KvX4DR7gKfr8Mow6oDUCsF+/fuKEvneTd/egW+r8ce//nDt3TmT33rp1C7NmzVLR6BlF0HOyP3zbOaK0uAw7ll9EekKO0t2/55LO4Ub6DZgamColo1GUotHTQ1FkFIqTk2t8HmUR/q/L/2CoZ4gDMQdEsD3DqAMHow/iYMxBcWwu6LpApRmvlDlP5yqVgzmffLfPtrJIi8/BjuVhYk6iGqY9J9W/sxDDKAutEYAMo6+vh8GPB1WUh/nn2wvIlVXtoqFoAUiWBGKk30il1DMjS6RJS8m9nVuLG5igwtOPtH5E7H9y6hNOCGFUDh2DdCwSM1rPaHBrREVB5+gIvxFif821NUp9r5zMgirlXgY91lrMUQyjLrAAZLQKI2MD0TPY2skMWan52L70AooKSpQS/5eSl4LdUbvF/tSAqVAW8r7AeQ9wAxNPt3u6IiHk18u/Km1MDFMXVl1aJSV+mDk3uji6opCfq1QShs5hZUBzzvalF8UcRHOR6GNuzOVeGPWCBSCjdZhZGWP0s+1gamGEpMgs7PrxEkpKSutk/atP/N+G6xtQXFqMdk7tEOgQCGVh1lESpDknTj7wuRRc/3Knl8X+jxd/RFx2nNLGxTC1QcfeT2E/if1XOr+iksSP6mjt0BrBTsHi3N14Y6PCX5/mGppzkqOyxBxEcxHNSQyjbrAAZLQSWxdzjJgXDAMjfUReSsWB36/VGvRdX/cvLR7rr69XuvWPsOjRQ1gmC8LDa40DlDPcdzg6uXRCfkk+vgj9QqljY5ia+Pz05+IYpGORemOrE9MCpHJNdA7TuazQWn+/XxNzjqGRvqj1R3MRw6gjLAAZrcWtuY1UI1BfD9dOJFSUYVCEAKTA9sTcRNiZ2FU0m1cWhnZ2oig0kVOHXtUiIaTr/yo6hByNParU8THMvRyJPVLR8YOORXVrdUat4ejcpb7ElKCiKE5sviXmGppzhsxpA1c/5fY5ZpjGwAKQ0Wp8gx3Rb3pARSHWC/vur5FXlJgo9f/V169z/N/acKnzxwT/CTA2UL57x6JnT3Gbc/RonTsfPBz4sNj/4MQHovcqwzQFdKx9eOJDsU/HIB2L6oaJgQnG+4+v0sWnsVzYG42zu6RSY/0fCRBzD8OoMywAGa2ndU93dB0jZR8eWX/jvkLRuafqV/+PEiyOxx8XfX8ntZyEpkAuALOPHqtz/bJn2j8DF3MXxGbHYsXFFUoeIcNI/HDhB3HMuVq44tn2z0JdmdxysrilczkmK6bRhZ5pbiG6jvVDYA93hYyRYZQJC0BGJ+g43Btt+3oAZcCelVcQdTm1we5feeB4D/ce8LRqmqKuZiHtoWdujpKUFBRcv16n/6Gge3K/ybMxb6bfVPIoGV2HamLKs8+pLqW5kfrGv9G5S+cw0ZhkEJpLqPg8QUWeOw7zVtgYGUaZsABkdAKKQeo1tSVadHRGaUkZ/v0hDPG3Mu8RgJ0f+DpFpUXYdGOT2J/YciKaCn1jY5h37iT2c47UPaZvQLMBGOA1AMVlxXj/xPsoLas9G5phGgodW+8ff18cawObDUT/Zv2h7kz0l87hTTc3iXO7vsTfzMC/34eJOYXmll5T/NUu3pFhaoIFIKMzUBHWQbNbo1mQPYoLS0WNwIQLkXfj/8rLrdTGoehDSM1PhYOpA/p59UNTYlnPOEA51H3B3NBcdC1RRtkLhiE23NggumvQsfZGlzegCfT36g97U3tRD7C+3XNSYrKwbelFFBeVijmF5hYu9MxoEiwAGZ3CwFAfw55sKzKEqUL/9p9vINfMqc7xf+tvSKVfxrUYByN9IzQl8jjA3NBQlObn1/n/RCxWiBSL9dWZr5RW/JbRXeiYWnxmsdh/LuQ5ccxpAkYGRuJcJv6+/ned/y8jMRdbvzmPwrxiMZcMe6qtmFsYRpPgI5bROYxMDER9LgdPS+QX6uN8u+eg17nPA/+PAtuPxR6r4jpqSoz9/GDo6oqywkLkhj64K0hlHmr1EALtA5FVmIXPTn2mtDEyugkdU3RsUZFlOtY0Cfm5TOWS6lI4PTs9X4i/vKwiOHpZirmEu3wwmggLQEYnMTE3wui5QTDPT0a+qQOOpAc/sG8wxf6VoQxd3brCy9oLTQ3FFln07NEgN7ChviHe7f4u9PX08e+df0V9QKYGCrKA3LSqGz3GVMt/d/4TxxQdW+90fwcG+polhppZN0NX167i3KZYwNqgOWLL1+eRlZYPG2czjH6uvZhLGEYTMVT1ABhGZdwIQ7tzS3Cu48vIzLTFlq/PYdxLITCzvL+uH3ULkCd/NFXpl5riADM3bKy3ACSCHIPwWJvHRHuuD45/gBDnEDia6WitsuJCICEMiDkFJF0BMmMBWax0W1iD2DO2Amw8AGsP6da5NeDZBXBtCxga66zrl+pMEo+3eRxBDkHQROicPplwUsTIPhX8lLhgupe8bBJ/54T719LeBGPmt4e5tW7+7ox2wAKQ0Vmy9++HWUEaejtexlG9/kiLyxGunXEvhtx3VX845jCS8pJEwPhAr4EqG7N59+5SW7jr11GUlAQjZ+d6/f/cdnNFsPv19OtCBH7d/2vdyFosLQViQ4Fr24Hok0DcOaC47nGUAhKGydekrTKGpoB7CODVFWg1EvDoJJKKtB2qR/ne8feQUZCBlnYtxbGlqVC2PHUGScpNEl1M7k3wys8pEnMDzRHmNsYY+0IIrB3MVDZehlEELAAZnYQWr6x9+8W+66CuGNs2BJu/OouU6Gz88+0FcXVvbGpYJcORGNN8jAgcVxWiLVxQEPIvXULOsWOwHScFsNcV6lryca+PMW37NOyL3od/Iv4Rn0lrRV/MaeDKZuDKFsnCVxkze8CrC+DWHrD1KrfseQLW7oDhPYs7dVKRxQGZMdLrZEQD8eclMZmXDkQdl7ajX0uv03os0Hoc4NlZa8Xg1ltbcSD6gLCW0TGlyvOisdB5QefBr1d+xYbrG6oIwML8Ymz77oKYG8ysjIT4s3VW3/qGDFNXWAAyOknhrVsoio6GnpGRcKvqW1gI0bf5q3NIvC3D9qUXMerZdiJhhPqFHo49rLLkj+qygYUAPFp/AUgE2AdgXrt5WHJuCT45+Qm6uHbRmKzNOpGXAZz/Ezi1Aki/U9WFGzAM8OsvWescmgtrap0wtgAc/aWtMtSVJfWWJAQj9gPhOyWBeGKZtNn5AF2eBEIeAUy1py8snROfnPqkouMMHVOaDtX1JAF4KPaQ+Hx0ThQVlAjxR3OCiYUhxswPgb2bhaqHyjAKQTsvTRnmAWTtl6x/5t26CfFHOHpalVv+DBB3I0PUCaQFgKx/VOS2s2tn+Nj4qIEALE8EOXYMZWTlagCz28xGsFMwsoqy8M7Rd+rcXk6tSbkBbH8F+Ko1sOt/kvgj0dd2CjBtDfDqTWDiT0DIdMCxRd3FX23Qa9Br0WvSa9N7TFstvSe9N42BxvJloDS2FM3vxkLnwttH30Z2UbY4hmYFzYI24Gvji04uncTno1hAufiLv5kp5oQxz7eHo6elqofJMAqDBSCjk2SXu3+tBlTtVuDsbY3Rz7eHkakBYq9n4J/vzmPT1S3ib1MDpkIdMG9f3hYuNRX5V6426DXIbfdRz49gamAqeqH+cfUPaLTwWz8L+K4TcPpHoCgHcAoERn8DvHIdmPgj0GoEYGSq/LHQe1AcIL0nvfeor6Wx0JhobN91lMZKY9ZQ/rz6J07EnxDHDh1D1SVMaCpTW0nnOJ3zdO7ThSDNBTQn0NzAMNoEC0BG5yhOS0Pe+fNi37Lf/d08XP1sxNU+TfzxNzLR5dxEuBi7iUBxdUDP2BiWvXqJ/axduxr8OmTNfKnTS2L/q9CvcD5J+k40BorD2/IMsLQLcJkytPWAgBHAzC3AvONAx1mAsQpjtei9O82WxkJjorHRGGmsS7sCW56VPoMGQccIHSvEy51eVguLuCKhBC8617ucmyDOfZoDaC6gOYFhtA0WgIzOkX3wkIjdMmkdCCM3t2qfIxeBJYaF8JD5Y/yN54Ai9TldrIcPE7eynTsb5b6dFjANQ32Giv6trxx8Ben56VB78jOBnf8Dvu0AnPsDoP7GJK7mHgUeWgP49VOMe1dR0FhoTDS2p49IYy0rAc79Ln0G+iz0mdSctPw0cYzQsTLMZ5jaWMQVSrE+xl1/Du4yf3Hus/hjtBn1WdEYponI3rdP3Fr1q71ZfbZdMra2WopCg3wgzkLEA1FGoDpg2bcv9MzMRCJL/qXLDX4dKgHzXo/34GPtg8TcRLxx+A2UlJZALSGhe3E98F1n4MRSoKQQ8OkNPL5HElcuGlCDzrWNNNbHd0tjp89An4U+U9jf0mdUQ+iYWHB4gThG6FhZ2GOh1pUPkmf76sVbiHN+S6vvkGPPbRMZ7YUFIKNTlBYUILu8iLJl/9oF4NrwtUi0uoOkfqHCFUTxQP8sOY+C3CKoGn1zc1j26yv2ZTv/bdRrWRhZ4Kt+X4mYrmNxx7AibAXUjuRw4NfRwMYngOxEwKEF8MgG4NF/AK/O0Dio/AyNnT4DfRb6TBselz4jfVY1Y8XFFeLYMDM0w+J+i8Uxo03QOU11/ugcp4SPxH6nkWQVKeYAhtFWWAAyOkXuqVMoy82FobMzTINa1/i8nKIcUSOPGNtriKj9ZWJuiIQImWgFlZ+tehFoPWy4uM36t3FuYMLfzl+08SKWn18uFnu16dix/2NgeU/gzmGp6PKAt4G5x4AWg9TL1VtfaOz0GeizDHhL+mz0Gemz7l8ElKj+GCOo//XyC8vF/tvd3kYLuxbQJuhcpnNalHoxN8TYF0MwtueQilqHuUW5qh4iwygFFoCMznX/kCd/6NVSoHd7xHYhAsndRX1CXXysRZs4U0sjJEdlYfPisw/sHaxsLPv0FtnARXFxyL94sdGvN7r5aFHnkHqivn7odUTKIqFSEi8DPw0EDn4KlBYBLYcDz5wE+rwCGJpAa6DP0udV6bO1HCZ91oOfAD8OABKvqHRodAy8fvh1cUxQuzQ6RrQJOoc3fXVWnNNU5JnOccr2pX7fdO7THLAtYpuqh8kwSoEFIKMzUM08efcPy3vKv1R5XlkZ/gr/S+xToLs81onqBI5/qYNoBZUam4NNX55Fdno924kpEH0zM1iVu7Fl/+5UyGsu6LoAbRzaiPZe8/bME4H/TQ7FIB5ZDKzoByRcBMzsgEm/AA//JRVW1lbosz28Vvqs9Jnps6/oK30XKojLpN9+7p654ligY+KNLm9Am6Bzl85heXu3cS91EOc4oa+njykBU8Q+uYG1ok4mw9wDC0BGp9y/xQkJ0LeygkW3bjU+71zSOdxIvyFi4sa0qNomzd7dQohASzsT0RR+w+dnxK3Ks4F37WpwUejKmBiY4NuB38LD0gNRWVF4bt9zyK9vz9zGQIWTfxkG7FkoJUiQ1W/eSaCN6juwNBn0WeeVWwPpO6Dvgr6T9KazyNJvTr99dFa0OBbomKBjQ1uofO5a2ptg/Msd7uvwQa3haA6gvtnnkzWsRBLD1AEWgIzOkLFxo7i1HjEC+qY1FwX+65pk/RvhNwLWxvcXf7V1Mcf4VzrAxtkM2WkF2PjFGSRHZ0EVWPTuLTqZFMfHI+/8BYW8pqOZI5YNXCY++8XkiyL7s0kyg6lf7/d9gJhTgIk1MG65lDFr5QKdgz7zQ38BY5dJ3wV9J9/3lr4jJUO/NWWD029Px8CyQcvEMaEtkLuXzlk6d8W5/HKHanv72pjYYLivFGe75toaFYyUYZQLC0BGJyjJykLWf7vFvu2E8TU+Lz47Hv9F/if2a6tzZu1ghgmvdISjlyXysoqw+cuziLuZoYSR146+iQksBw5QSDZwZfxs/fBN/29gpG+EPVF78OWZL6E0ivKBbS8B62YCBZmAZxeppl/7hzU7yaOx0GenFnP0XdB3Qt8NfUfbX5a+MyXxRegX2Bu1V/z2SwYsgZ+NH7QFyvLd/NVZcc7SuUvij87lmpjWapq43X1nt+gPzDDaBAtARicQBZPz82Hs5wfT4OAan/f71d9RUlaCLq5d0Nqh5ixhwtxaihtya2GDwvwS/PPNedwJS1FdNvBOxbiB5XRy7YQPe34o9n+/8jt+ufQLFA61RKNEj9Cfpfu9XgRm7wBsmyn+vTQV+i7oO+n5gnT/9E/AT4OU0k6OfmN5W8CPen2Eji4doS3Qubl1yXlxrtI5S+cuncO1QXMA9QCn4td0DjCMNsECkNEJMjduqrD+1VTANrMgE39f/1vsz24zu06va2JmKPqEerd1QHFRKXYsD8PVY/FoSix69RRxjcVJScg7e1ahr01u8Bc6SMJj8ZnFihWBV/8BVvQHEi8B5o5STbxBCwEDI8W9h7ZA38ng94DpG6TvKjFM+u6uKi5D9eewn8VvTLzY8cUK96c2cPVYnDg3S4pK4dPWQXT4oHO3LswOkuYCmhtkhTIlj5Rhmg4WgIzWUxBxG3nnzgEGBrAeUzWpozLrr69HXnGeqInX071nnV/fyNgAw59ui4CurigrLcO+364idMedJssc1Dc2htXAgWJftkNxbmA5j7d9HPPazRP7JBB+CvupcS9I8YR73gPWPgIUZgHePSU3J9XEY2rHf5DUTq5ZD+m7Wztd+i4bGaNJv+nXZ78W+/Paz8NjbR6DNkDnYOiO29j32zVxbtI5OuzptjA0Nqjza/Ty6IUWti2QW5yLdeHrlDpehmlKWAAyWk/mJsn6Z9mrF4ycnat9TkFJAf68+mfFFX9921wZGOhj4KxAdBjqLe6f3BqBQ39dR2lp04hA6xGStSZz+3aU5uUp/PXntp8rhAHxzdlvGi4Cc1KBPyYCR76S7nd7Bpi5BbByVeBotRxrN+DRrUA36fcQ3yV9p7kNK9nz48UfxW9KPNP+GcxtNxfaAJ17h9Zcx8mtt8X9DsO8xTlK52p9oLlA7hGgOaKQMrMZRgtgAchoNWUlJcjcImVO2oyvOflj261tSMlLgYu5C4b5SqVV6gstFN3HN0fvqS0BPeDSwVjs/CEMxYXKz6C16NkTRh4eKM3MROY25RSuJWHwbPtnxT4Jhh8u/FA/K2c81bXrB0TsB4zMgYk/A8M+ZpdvQ6DvbNgi6Tuk75K+0x/6St9xHaHf7vsL32PJuSXi/nMhz+Hpdk9DG6Bzjs69S4dixblI52T3cc0b3L94uM9wOJs7izmCC0Mz2gILQEaryTl2TMTGGdjY1Fj8ubSsFKsurxL7M1rPENmPjSG4vyeGPtEGBob6uH0hBZsXn1N61xA9AwPYPfyw2E//40+luZ+faveUEArEd+e/w0cnP0JxafGD/5HKl/wyFMiMAuz9gCf2AG0nKWWMOgV9h/Rd2vlK3y19x3UoFUO/2YcnPsTS80vF/edDnseTwU9CG6Bzjc45OvfoHBw2p404JxuDkYERZgTOEPs0V9CcwTCaDgtARjdq/40eLWLlquNA9AHckd2BlZGVaIWmCFp0dMaY+e1Eb1HqMfr3p6Gi44AysZ04AXqmpigID0deaKjS3oeEwqudXoUe9ESXhGf3Povswuzqn0xZydTXlsqXUE9Vv/7AnH2AS5DSxqdz0Hf55H7pu6XvmL7rA59I33010G9Fv9m66+vEb0i/5ZzgOdAG6Byjc0309bUwxJj57dG8Q/VhH/WFWuFZGlniduZtHIw+qJDXZBhVwgKQ0VpKMjKQvWfvA2v/ya1/kwMmw9LYUmHv7+5vh0mvd4KNkxmyUvNF54Hoa8prrWZgawub0VKv1rQ/pHhGZTEzaCYW918MM0MzHI07ihn/zkBcdlzVJxVkA+tnSn1t5fF+0/+W2pwxioW+U/pu5XGBBxYB6x8FCqtedNBvRL8V/Wb029FvSL+lNhB9NU2cY3Su0Tk36bVOcPe3Vdjr09xAc0TlOYNhNBkWgIzWkvnPNpQVFcGkVSuYtm5dY9s32sjtOz1wusLHQJ0GJr7eUaoVmFeMbUsu4MrRe4SSArF75BFxm7VnD4oSlFu4dmCzgVg5bCWczJxwM+MmHt7+MM4nlbfMyoyR2pdRqRdyqY/5rjzer26lN5gGQN8txQXSd03f+dWt5W73WPFn+m3oN6Lfin4z+u3oN9QG6Jza9u0FcY7RuUbnHJ17iuaRwEdgqG+Is0ln7x7rDKOhsABktBISfmkrV4p928nVx5pRnNx3574T+6ObjxZB3srAzNIYY+eHwL+zi8hM3P/7NRxZfwOlJYqPIzINaAnzzp2BkhKk/yW1tFMmQQ5BWD1yNVratURqfipm75yNn4++j9IfB0i16iycgFnbgA5S/BTTBNB3Td851QtMCBO/xU9H38esnbPEbxRgFyB+M/rtNB06h46suyHOKTq3WnZxEecanXPKgOYI6hFMyOcOhtFUtEoALl26FD4+PjA1NUXXrl1x6tSpGp+7atUqkRFWeaP/Y7SDzG3bURQXBwMHB9hOrD6u73j8cZxKOCWsf08FP6XU8RgY6WPwY63ReZSvuH9hbzS2Lb2I/JwipVkBM9atR2lBAZSNq4Urfhv+G4b5DBMdE76+uR5PW5YixaWVFO/XrJvSx8DcA33nc/aJ3+ApyxJ8c3O96HBD2ay/Dv9V/GaaDp072767gAv7osX9LqN9MWh2a3GuKROKgaU542TCSRyPO67U92IYZaI1AnDt2rV46aWX8O677+Ls2bNo164dhg4diqSkpBr/x9raGvHx8RVbZGRkk46ZUV7pl9QVK8S+/axHoV+NsCfr35KzSyp6/rpbuit9XHSR0WWUL4Y92QaGxvqIvpKGDZ+dQXqCYpNDrAYOgKGrK0rS0iD7V/GFoavDwtAcn8EZ7yWnwrS0FMfNzDDRzgRHc6TFmWl6jubGiN/ghJkZzEpL8X5yKj7Vcxa/laZD5wwle0RfTRfnEp1TnUf6NrjMS33wsPTAlIApYp/mkKYq+M4wikZrBOBXX32FOXPmYPbs2WjdujW+//57mJub45dfam5dRZOFq6trxebi4tKkY2aUQ9buPSi8fRv61tawe+ihap+zJ2oPLqdeFoHwT7R9oknHR1mJE17tCEt7E2Qk5uLvT0IV2kNYz9AQdtOmKb0kTAXFhcDmedDb/yEmZOdgrWM/tLT1R1pBOp7e8zTeOvIW0vPTlTsGpgL6ruk7p++efgP6Lf5y7Ifx2TnQ2/eB+K3Eb6ah0LlC50xmUp44hya+1lFhmb51ZU7bOWLuuJR6CXujpEQzhtE0tEIAFhYW4syZMxg06G4rKX19fXH/+PGaTfTZ2dnw9vaGl5cXxo4di8uXLzfRiBllQWInZcUPYt/+kekwsLSstgbat+e+FfszW8+Eg5lDk4/TycsKk9/oDLfmNqI5/fZlF3Fq223RrkoR2E6ZDD1jY+RfuiS1wVMW1H3i9/HAhdVUjBAY+SX8Ri/F6lFr8HArqS7hlltbMGbzGGy5uYWtJUqEvtvNNzdL3/WtLaLEC/0G9FvQb4IRX0i/Ef1W9Js1sHOIqqBz49Q/Edi+9KI4ZyjZg84hR0+rJh8LzRlUM5SguaSkka34GEYVaIUATElJQUlJyX0WPLqfUEMmZEBAgLAObtmyBX/88QdKS0vRo0cPxMTE1Pg+BQUFkMlkVTZGvcg5fBgFV65Cz9wcdjOqTzz459Y/opaXjYkNHg16FKrC3NoYY18MQZu+HkAZcHrbbWxfrpi4QEN7e9iMlYLVk79arBzhlXoL+GkQEHkEMLYCpq8DOkvWVBMDEyzougC/D/9d9FbOKMjAW0ffwuP/PY6b6TcVPxYdh77Tx3Y9hrePvi2+a/rOKS6TfgP6LQRd5gAPr5N+K/rNfh4s/YYaAJ0TdJF0evsdcZ/OmbEvhIhzSFXMCpol5pCIzAj8E/GPysbBMDotABtC9+7dMXPmTLRv3x59+/bFxo0b4eTkhB9+kKxH1bFo0SLY2NhUbGQ5ZNSLlB+k2D+7qVNhaGdXbc/fZReWVbhxrGgxVCHUqaDvQwEY+GigCF6PDEvF+kWnkRJTQ2HleuA4bx70TEyQGxqKnEOHoFAijwE/DQTSbgE2XsDju4AWdy3wcto7t8faUWvxYscXYWpgitMJpzHxn4l488ibiM2WypMwDYe+Q/ou6TsNTQwV3/FLHV8S3zl99/fhP0j6reg3S70p/Yb0W6oxKTFZ4pyIvJQqzhHq50vnDJ07qoTmjifaSBc8y84v4x7BjMahFQLQ0dERBgYGSExMrPI43afYvrpgZGSEkJAQ3LxZs3ViwYIFyKReq+VbdDQHuKsTuadPI+/MGegZGcF+1qxqn7MufB0SchJEOQdK/lAXWnV3w8RXO8LKwRSylHxs+DRU1DZrjOXOyM0N9jOkjOCkL78SyTEK4cJa4LexQF464N4BeGJvrZ09KGPysTaPYdPYTaLuHLXR2nprK0ZtGoVFJxeJ/qpM/aDvjL47+g7pu6TvlL7bzeM2Y3ab2bW3M6Tfin4z+u3oN6Tfkn5TNYOOfToHNnx6RpwTdG7QOdKqmxvUhWmtpom5JD4nXswtDKNJaIUANDY2RseOHbF3791gXHLp0n2y9NUFciGHhYXBza3mycXExERkDlfeGPWz/tlMnAAjl/uDwjPyM7DiovScue3mwtRQvcr+ODWzwpQFndEsyB7FRaWittneVVdRmF+HXrs14DBnjkiGKbh+HZn/NNJNRWJ030fApicBsnYEjgFmbQes6pY85Wnlia/7f43VI1ajq1tXEYu5+tpqjNg4Ah+f/BhRsqjGjU8HiJRF4qMTH4nvjL47+g7pu6TvlL5bylCtE/Sb0W8XOFr6Lek33f+x9BurAXTM07FP5wCdC3ROTPlfZ3GOqBM0hzzd7mmxT3NLZkGmqofEMHVGr0xLorKpDMyjjz4qXLhdunTB119/jXXr1uHatWsiFpDcvR4eHsKNS7z//vvo1q0bWrRogYyMDHz++efYvHmzSCahLOK6QDGA5AomayCLQdWSffQooh9/AjAwQPOd/8K4Gvf8u8fexcYbG9HCtgXWjV5Xu5VExcHuZ/+LxMktEWI9tnM1x9A5beDg0bA2dak//4ykz7+Aobsbmv/7L/RNymPC6kNRPrDlGeDS39L9Xi8CA96hbCs0lBPxJ/DNmW9EJiVBSQv9vPqJxJyOLh2bpKSHJkBTNLl3f7/yu+hbXUYBoxQH59AG8zvORze3RtRZpH7Be98Djn4t3W8zCRi7FDBS3cVRamw2dv14CekJudDT10PXMb7oMMRb7KsjRaVFmPLPFNFhhXqJL+yxUNVDYuqAjNdvaE1fpqlTpyI5ORnvvPOOSPyg2L6dO3dWJIZERUWJzGA56enpomwMPdfOzk5YEI8dO1Zn8ceoD6WFhUh8/wOxbzf94WrF35nEM0L8Ee92f1dtxR9BC13HYT4iQ/i/ny6LhZDKXvSe2hKBPd3qLYzspk9H2u9/oDguHumr18BhdvXu8RrJSQH+ehiIPgnoGwKjFgMdGt8/loRL15FdRUFdEjeHYg5hf/R+sZFIH9t8LEb6jYSTuRN0keTcZGyP2C4yeklcyOnj2UeI5C6uXRovkmlOHPweYO8HbH9JEvjUxm/an4CFI5rc5XskTnT2IKufha0JhjwepNB+vsqA5pJ3ur+Dmf/OxIYbG0RXIbqAYRh1R2ssgKqAryDUg5Tvv0fy19/A0MkJfv/uuK/0S1FJESb9M0lk601qOUkIQE0hL6sQe1ZeQdQVqWSHX4gT+j/SCqYW9ROwGRs2Iv7NN2FgY4Pmu/+DQV2P16SrwOqpQEYkYGoDTPkd8OsLZUC/z59X/hQxbfkl+eIxfT19dHfvjjF+Y9DXqy8sjCygzWQXZgshvDViq+gyQbF9BCV3UAuy6a2nw8/GTzlvHnEAWDsTIDemrbeUMezcCk1BfnYR9v9xDRHnk8V9cvkOmtUaZlaqy/KtLwuPLRQCsLlNc6wfvR5GBup7kcnw+k2wAGwELABVT2FMDCJGjkJZQQHcv/gCNqNG3vecHy/+iCXnlsDe1B5bx20VpRs0CXIJn9sTJVzCpSVlwjJCLa88A+zq/holJbg9bhwKbtwUcYHOL7/04H+6sQf4ezZQIAPsfCRB4BQAZUNxVLvu7BLles4nn69iaens2lm4ift59oObpfokAzSG+Ox4HIg5INy71JqQ4vrktHdqjzEtxmCI95CmOW6Tw4HVU4D0O4CJNTB5ZbXZ3Yok5loa9qy6ipyMAugb6KHrWD+EDGqmti7f2o5bqsGYlp+G+R3mN3mBeaZ+yHj9ZgHYGPgAUj3Rc+che/9+mHftimarVt7nEouWRWP81vGi/Mui3oswym8UNJWkSBl2/3JFdA+BHtBhSDN0GeVX596nWfv2I2bePEp5h+/f62EaUIuYO7kC2Pk6qU/Au6dk+bNwUEnSA1kESRDSfmXI0tLJtRM6uXQSLjdNcRWTa5di+igsITQhFLcyq9bi87b2xlCfocLiR/tNTk4qsPYRIOoYxSMAwz4Fuj6p8LcpKSrFyX8icG53lKiDaetiLly+6pboUR/oouV/R/4nai9uGrMJXtZcKkxdkfH6zQKwMfABpFqy9u1DzLxnhKDx27wJJs2bV/k7HdrUDutY3DERb7Zi8AqNTywoKijBkfU3RKwUQYkhVBeNOos8CPo+Yp59Dtl798KkVSv4rlsruoVUoaQI2PkGcPon6X77R6SYP0PVu+KoeDdZyWgjy6DcPSqnmVUzBDkEIcA+AIH2geJWFV1eKpOal4rwtHBcTbsqbqn9YFRW1WxncnOTpU9YNr36wdfGFyqnuADY9iJw/k/pPhX4HvYJoCC3ZnJ0FvauuoLUWKkPduve7ug1yR9GJgbQZOgcm7N7Dk7Gn0RP955YPmi5xs852oqM128WgI2BDyDVUZqXJ1y/RXFxNbo05VfjxvrGogZdM+tm0BYiziXjwOpryMsqgr6+HjqP8kGHod7QN6jdGlickoKI0WNQkp4Oh6efgvMLL9z9I7UGWzcTuHNY5ORi0EKg53xqmg11g0r6CAtauSXtWtq1iuzYypDb38vKS2wkEKkUDdVtczB1gKOZI6xNrIUAawgkQGUFMlGTLzU/FUm5SYjJihECLzorWmzkDrwXer8AuwBhtZRbL21N1TDRgZaGo98AeyirtQzw7QNM/hUwt2/wS5aUlOLszkiEbr+D0tIymFkZod/0VvBrrxnW27pAluoJWyagsLQQH/f6WCSFMOqHjNdvFoCNgQ8g1ZH46WdIW7lSKm2ybRv0zc3vm4SpNENucS6eC3kOTwYr3oWlanJlhTi4JlyIQcLZ2woDH20Ne/faEyVkO3chloSfvj581qyGWbt2QOIVYM00KdnD2BKYsAJodX88pbqSVZiFi8kXKyxtJAjpGKhOFFbGUM9QxNaZG5nDzNAM5obSrYF+VUsU9XrNK84Tx5O4LcoVMV/FZbXXaKTSNuTGbWXfqsIyGewUrPIONPXi2nZg45NAYbYUC/rQX4BzYL1fJi0uB3t/vYKkyKyKhKZ+DwdoVKJHXfnhwg/47vx34niiklMqceUztSLj9ZsFYGPgA0g1ZO3di5hnnhX7nsuWwWpA/yp/p3i/R3Y8IkQAWVh+GvLTfQu6tkCn7/VTiTi89joKcouhb6iHTsMla2BtrbJiX3kVsm3bYOzrC99PnoL+9nnSAk/Zn7TAu2h+OSQSaSQCK1vkyEJHFjvaZIWK6eVNAlJuUSQLY2WLIy38JC41nsTLwJqH7l4gTPwJCBhep38tKS7FmZ2ROPPvHZHEZGJuiD7TWsK/s4vWukcpkeeJ/54Q1mkS/b+P+P1uT2ZGLZDx+s0CsDHwAdT0FEZH4/aEiSjNyoL9o4/CZcEb9z3nwxMfYm34WtiZ2OHvMX8Ll5+2k51eIFzC1EuYICsglYtx9as+c7QkM1O4gouTkmDXMgeuHTIBn97AlN8a5eLTJKg8ELluyZJXYd0rkm7vjS8kt62wDhrdtRLKhZ/OlPug5JD1j94NEej/JtD75VqLgSdEZIryLmT9I3zaOgiXL2WyazuJOYmY/M9kpBekY1rANLzZ7U1VD4mphIzXbxaAjYEPoKaltKAAdx56CAVXrsIsJATev/0q+v5W5r87/+Hlgy+LfQrA7uXRC7oCnco3Q5NweN11ERtIa3RwP09RVsPY9J6a7/mZyP78YUT/GSHues3pDMsXflZYkD+jpdybJBQwEhi/XKoRWYnCvGKc3BqBiwdiRPggxfpRIfMWHZ211upXHUdij2Dunrli/6t+X2Gw92BVD4kpR8brNwvAxsAHUNMS/867yFi3DgZ2dvDdtBFGrq5V/k4uPor7yy7KxuNtHscLHSslOOgQVFT3yN83EH4iQdy3sDFGz8n+dxffpGvA2ulA6k3En7FHxg1T6FtainhAE39/VQ+f0QTO/gZsf1nqI+zQApj6pygaLS5CziSJTPXczELx1IBuriLD19RSNy8uFp9ZjF8u/QIrIyusHb1WhAcwqkfG6zcLwMbAB1DTkbF5M+LfWCAyUr1++hGWPXtW+Tu58GbtnIUrqVcQ4hyCX4b+AkNqW6bDRF1OxcG/rkOWnCfue7ayQ99O0bA9+DRQlANYe6J0/M+IfnspckNDYeTuDp91a2Ho2LQtwBgNJfYMsHYGIIsVcYHpfZfj0GkvxFxLF3+2djJD34daollr1ZbiUYdewY/tfEyULqIyRSuHrRQhBIxqkfH6zQKwMfAB1DTknj2HqMceQ1l+PhyfexZOzzxzX8D1i/tfFN0UKC7r79F/w9WiqnVQVykuKsHZXVE4u/MOSorLoI8ihFhsQYegBBhPXSH6vRanpyNy2kMojIyEaXAwvH9dBX0zXqCYOpCdjMK1T+LMFTeczxmLUhjBwFAPHYZRIlIzGBppZ/JVQ7q9TN42WcSbUq3Hxf0W6/wFqqqR8fqNhhXAYpgmIu/SZUQ/+aQQfxZ9+8BxrhRPI4euXyjpg8QfZdl9O+BbFn+VoAW4Sy8DPNTqOzQzPiMW6DM5k/DntZdw9UKRaDNnaGcHrx++F32C8y9eRNzrb6CstGoSBMPcCx07Vy8W48/wl3E2Z5I4trxNQsWxRscci7+7UNvCJf2XiDmKCpnTnMW2F0bVsAWwEfAVhHLJv34dUTNmioxV806d4PXjivssU0vPL8X3F74XWZoUZD2w2UCVjVctCf8X2PQ0kJ+BMhMb3A5egaMnbCrcwtR2q9cUf7i3sBVu4KjZj6GsqAj2jz0G51df0amAfabuxN3MwJF1N5AclVXh7u3ZLQO+F5+CXkEmQIWtx/8ABAxT9VDVir1Re/HSgZdElvncdnMxr/08VQ9JZ5Hx+s0CsDHwAaQ8Cm7fRiSJv5QU4ZZs9ssvMLCsWuB4Xfg6fHDiA7H/dre3MSVgiopGq4ZQK6+97wPHv5Pue3QEJq0E7LxFD9aL+2MQuuM2CvNLxJ+pEwNlCxuc3ou4114Xj1GZHec3XmcRyFSQFp+DE5tv4faFFHHf2NQAnUb6imxz0ZM6PRJYPwuIOyv9Q/dngYHvAIbaX/alrvC8pR7IeP1mAdgY+ABSDoUxsYh85BEUJySInrUUk0buycrsurMLrx16TVxJP93uaTzTvmpcoE5DWb4bngASw6T7XecCg9+/r58vdRI5+U8Erh6JE12/SOe16uGGlgXnkPWFtEDZTJwAt/ffh54Bu/N0may0fJzedhvXjsdXHCuBvdzRdbQfzK3v6eRRXAjsfgc4uVy679oWmPgz4BSgkrGrI9+d+w4/XPxBeC4+6/MZhvoMVfWQdA4Zr98sABsDH0CKJy/sEmLmzUNxcjKM/fzg/ftvMHSomkW44foGvH/ifSH+JvpPxLvd32UrFUGnMtVn++8toDgfMHcAxi59YMcGKtJ7Ystdqw5Zclp65MFhzUIYF8hgNXQo3D//DPrG2teyi6kdukg4918kwg7Eio4ehG87R3Qb1xz2brW3HMS1HcDWZ4HcVMDQFBj6EdDpcbXsLd3U0LK78PhCbLyxUYhAmsMm+E9Q9bB0Chmv3ywAGwMfQIpFtus/xL3+ukj4oHp0VO7FyMWlynN+DvsZX5/9WuyT+CMXira2easXWYnAP/OB6/9K95sPAMYtB6zqnhBDXRuObbyJ+JuZ4r6BQRk8IvehWeR/sOvaHp5Lvrmv5zKjvcLv/O4ohB2MQXGhJPzc/W3RfXzzGrvLVEtWArB5LnBrn3S/5XBg9DeAVdXzWheh/tJ0IUsikHix44t4rM1jqh6WziDj9ZsFYGPgA0gx0CGY+sMKJH8tCTuLPr3h8dVXMLC0rPIcKqi68vJKcZ8KPc/vMJ8tf3T6hv0N/PsqkJcOGBhL7t4uT9XaoqvmlytD5KVU4e5LipQC/PVLCuEZexAtjG7Db/EimPj5KuGDMOpATmYBLuyJriL8nL2t0HmUL7zbODTsfKOM8pPfA3velQpHm9kBI74A2kzUeWsgnW90QUuFoonZQbOFENT5ea0JkPH6zQKwMfAB1HhK8/KQsHAhMrdsFfftZs6Ay2uvQc/QsErPVrpS3nxzs7j/SqdX8GjQoyobs1pZ/ba/BFzbJt13DZasfq5tGv3S1QrB0iK4pYSi07QO8JxSu1uZ0SwyEnNxbk8Uwo8nVLh6Gy387iXhErD5aSChPDa11Shg5FdsDQSw6tIqfHnmS7E/vsV44dnQmR7TKkLG6zcLwMbAB1DjyLtwQdScK7xzh/yNcH37LdhNm1blOXHZcXjl4CsISwmDgZ4BFvZYiHEtxkGnoVP24lqpJytZ/fSNgL6vAb1eVHgv3wohuPUGkqKl0jEoK4WHWRq6PTMQrv663eVB00m8IxMxfrfOJYuevYSLrzU6jfBRnPC7t5fwkcXAwc+A0iLJGjjsUyB4is5bAzfd2CTiAim2OdgxGF/0/ULUD2SUg4zXbxaAjYEPoIZRVliI5OXLhduX3EOGzs5w/+xTWHTrVuV5h2MOY8GRBaJ6vrWxNRb1XoQ+nn2g06TcALa9CNw5rHCrX23QNBEXnooTPx5BQs7dY93Z1QjtR7aEXwcnGBhwXXlNoKSkFBFnk3FxfzQSImQVj3u3dUCHId5wa2GjfBeksAbOBRIuSvd9+0jWQEfd7kV9KOYQFhxeAFmhTHQ1WtRrEXp79lb1sLQSGa/fLAAbAx9A9Sc//DriFyxA/pUr4r716NFwfevNKmVeqLXbsvPL8GPYj+J+G4c2+KLfF/Cw9IDOUpQPHPlKsp5QHBVlVfZ5Feg5X+FWvwcRvfUgTv8RigTbtigrb2dlYW2ENv08EdjTHRY2XPNNXeP7rh6Nw6WDscjJLBSP6Rvowb+TC0KGNIODx92Y2yaBrIFHvwEOfS5lrVP8Klmxe70EGJlCV4nNjsXLB17G5dTL4v6ctnNEmStOdlMsMl6/WQA2Bj6A6k5xWhqSlyxBxrr1wupnYGsL14XvwnpY1U4BN9Jv4L3j7+FC8gVxf1rANLza+VUY0+Kgi9DpeX0nsOt/QFqE9FiLwcCIzwF71SVjFCUlIfLjr3D9ahFi3Xuh0EQS8Pr6evAJdkRgTzc0C3IQ9xnVUVpahqjLqbhyJA53wlJF+zaCave16euB1r3UQLCn3QZ2vALc3CPdt/cDhn4MtByms27hwpJCfHb6M6wNXyvut3Nqh4XdF6KFXQtVD01rkPH6zQKwMfAB9GBKCwuR/vvvSFn+PUqzs8VjVkOGwOWtN2Hk7FzxvIKSAvxw4QesvLQSxWXFsDCyELWxhvvqcLIBuclI+N0+KN23cgOGfwoEjlGbhTH70CHEvfchYotcEOPRFzIbv4q/WdqZoFV3NwR0dYWtC5ePaeqkjvCTCaJwc3Z6QcXjVMKlbT8PNO/gDANDNXLZ0zJ0ZYsU15oVLz3m108Sgi5B0FV2ROwQCXA5RTkw1DcUZWKeDH5S9BRmGoeM128WgI2BD6DahZ9s61ak/LACRdHR4jHT1q3hsuANmHfuXOW5pxNOC6tfpCxS3O/v1R//6/o/uFrUvYadVpGdDOz/EDj7m0i4EK6xbvOA3i8DptZqmcmdsmw5UleuRLaxE+LdeiDBqyeKcHeRcvaxRssuLsLdeF/nCEZhtftuhCbi+smEisxtwtTCCAHdXIVV1sG9id289SVfBhz+EjixTAp10NMHOswE+r8FWDpBF0nIScBHJz/CgegD4r63tbe4OO7sWnUeZeqHjNdvFoCNgQ+g+ynNyUH6uvVIW7kSxUlJ4jFK8nB68UXYjB0DvUq16cjdu+TckoqJzcnMSQi/gc0G6mYdLMroPfYdcGI5UJQjPdZ6HDD4PcDOB+pOYXQ0UpYuQ+bWrSgt00eyUzsktxmJ5DIXYeAh9PT14NHSFs1DnODb3kn17kctiOu7fT5ZZPHGXs+ocPHS9+wVaI9W3VxFn2fRp1eTILcw1Q0kqyBhZAF0mwv0eFbKHNYxaJneE7UHi04uQnJesnisn1c/PB/yPPztdDtxpqHIeP1mAdgY+ACquvhnrP8b6WvXojQzs0L42c+eDbupU6p0kIjOihZJHtsjtqMMZaIV0uSWk0VhZytjK+gcBVnAie+BY98CBdJ3B/cQyf3l3QOaRkFEBFK+WwrZjh3ifqGRFdLaj0Kie3ekZlYKZNcD3PxshBD0aesg3MQ6KfzrAU3X5N6leL6Ic8lIuJ1ZUb5FbmkN6OqCFh21xNIaeUwKg4g7J903tQF6PAd0fRow0b25grKDl5xdgvXX14tyMXrQwyi/UZjXfh48rTxVPTyNQsbrNwvAxqDrBxC5ebP37kXG+vXIOXa84nFjb284zHkC1mPGVOkfeyvjFn6/8ju23NoiMn2Jwd6D8WzIs/CrFDumUxY/6t1LFj/ql0o4twb6vwm0Gqk2cX6NyfhOW7UKsm3bUFZUJB4rcG8JWffJSDD2QXK8lIkqx8rBFN5BDmjWxkFYCY1N7xYD12UK84uFdS/qUioiL6ciKzW/yt+pbp9fiJOw9Nk6a2GsJS1R17YD+z8CkqTqAaLPNVkEOz+hkxbBiMwIfHfuO+yO3C3uU3zg2OZjMaP1DDS3ba7q4WkEMh1fvwkWgI1AFw+gspIS5J4OhWznv8ja9R9K0tOlP+jpwaJHD9hOnQKrgQOhZyBZeujwOhp3VAi/Y3HHKl6nh3sPPN/heQQ56GCAtywOOL4UOLMKKJQSY+DQAui3AAia0KAWbupMcWqquEhIX72mIiyAKGvTGbJOY5Fo4IW4yByUFt+diih72NnHCu4t7YQYpOQFXRGEJPgSbmUK0Rd7PR3JkVkim1eOvqEePPxtRbY1iT5LOx0pmVJaAlzeBOz/GEi7JT1mbAl0nAV0fwawdoeuQaViyCJYeW7t6d5TCEGaY9miXjMyHVy/74UFYCPQlQOILH15oaGQ7d6NrP92oyS13FpV7ua1mTgBthMnwdjzbp2+5Nxk7Li9QzQ6p6tVgly9A7wGYGbQTIQ4h0DnIDfWqR+Bi+ukLgiEcxDQ6wVJ+Blot8AhK2DW3n3I3LIF2YcPA8WSFZgEr1FIZ+R2GIIUS3/ERhdBllLVykUxbQ4eFnDxsRYWL3J12rtaiMc1GYrZS0vIQdIdGRJvy0RnjtTYnIpYPjnWjqairA5ZSD0C7GBkosM14UqKgUsbpBqCSVKtPNENh7qJdJkjhU/oGGcTz4qL7H3R+4RrmCCvygT/CRjpNxKOZo6qHqLaIdOR9bs2WAA2Am0+gApjYpBz+DCyDx1GzsmTKMvNrfgbFW22HDwI1kOHwaJ7t4q+vfnF+SKhg1y8dEUqn4iopAv1t5weOF334lSogPOVzZLwiw29+7h3T6nobYtBGu/qbWhdSNm//4qEkfwL5d0gyjH284Ne90GQeYUgpcQecRHZ97k9CUNjfdi7W8LRwwIOnpYiw9XW1VzEvqmb5YOmWcrSzUjIRWpcNlJjspESm4O0uGwUF0rnyb3ucLJ8erS0g7u/LawdzVQybrWGlq4bu4GjXwORR+8+7tFJEoKUQKVjBaUpvnr11dXYdHOTKB1DUAtNsgaOaT5GJI6YUhF5Btq8ftcVFoCNQFsOIDoEiqKikBsaKty7uadPoyg2tspzDJwcYdm3ryT6unWFnpHUfYLatB2OPYx9UftwJPYI8orL+8WWFy+lSWeE7whYkqtGl6CG9+fXABf/uhvfR1aKoHFAl6cALy7hIKcoLg5Z+/Yje98+5Jw6ddcySBgawqxdO+h17IVstyCk6zkiOTYPSZGyaoWT+BcTA9g4mcHWyUwIJwtbE1GTkG5pM7MygqGRYi1oxUUlyMsqQk5Ggdio9h7dylLykJGch8zkPBQXlNQ4XudmVlWsm1b2vEjXi+jTwKkfgMub71rXKU4weBrQ/iHAtS10iazCLPx7+19svbW1oqg+YWZohl4evTCg2QD09ugt2s3pKjItWb8bAwtAHTyASmQy5F+6hLyLYcgLC0PexQsoSU6p+iQDA5iFtIdl7z7/b+9MgKM4zjb8SXvpPkAHCCQOgcE2hzjMYTvGKQjY4BgnKQeTVEyo+IzjwnEu7IrtcqpSxFfsMiHluJLgP1UxOFTZ5DeJ7cLYxj/3IQi3AhhJCHQggW5pd7U7f709u6vdRSskkNDszvsUTc/09Ejbmpmdt7+v+2tJueNr4hg/XllVYNX776X/yq7zu2Tb+W2yv2q/CtzsZ2jyUDUrDcJvZLrxQ5f0Kc01Ioc36MKv+nBnedpwkenLRaYuM20ss57iaWrSLc87dkjrjp1KHIYQHy+OceMksahI3IVF0pJRII0dKVJX2Sp153RLYU++0ay2eElIsYkjCcmq9hEqxWq3qO1w1zJcsh1ur3S4POJB7vaKs7VDnK1uaW92q/0rAaMkLHtYcq0zJUt6ThJXTOnLZ7D4f0T2rRVpDOrE5k7UheDE+0VSOgPQm4HShlIlBDd9tUkqWyo7n4E4q0wbMk1uz7tdZuXNkhsyb1DDdMxCY5S+v/sSCsAYvoE0r1dZ8pwlJdJ+okScJSdU7g/MHILNJokTJ6ogzUnTp0vilCliSUkWj9cjpxtOy8Gag7Knao/sqdwjl5y+iR8+xmSMUcGbEb/vpsE3Gc791q80Vooc/1Dk+P/qbiif21sFbx53t8jkpfrSbTE+vq/fLNNnz0rLzl3Sunu3tB08eLkgxJdYQoIkjBsnjptuFNvYceLOHS1tyUOkqSVOmi62B6xxzfXt0lrvCplQ0ZdAxCVl2CUlIyFgdYQlLz0nUc3Ohfgz1OobsT5O8NRmkYPv6kspIqg0gMDB8IubFouMv0ckbaiY6Xk6VndMtpRvkc/Pfi6n6k+FHM90ZMrMoTNVgOminCIpTC+M6fWHGw3+/r4eUADGwA0Eq4mrrFzc5WXiLC0V1+mvVCw215kzorVfPnYK2PLzleBLmDRREidNUqt0xCckqMkbxy8el6O1R+XghYNy6MIhaXb7Zqr6SLImyfQh02XW0Flyx/A7VGR604DHpfqo/nIp+Ujk7O7Q4xh/BEsDJnUkDRqoTxmzuKurpe3AQWk7cEDajh4R57Hj4g0anxqMNTdXHIWFYh85UuyjRqncNnKEaJk54mr3SnuLW5wtHeJs61AuXLiUdeueJ6Dj/UA3wG2sWwnj1bYj0SqOZKtaacORbBN7gsVcnZ9oofWiPmnkP+tEzu0POhAnkj9D76iNna+HYDLR9cPKS19WfCm7Knep1ZiCh++AFFuKTMqeJEXZRXJz1s1y46AbJTspdjwYjQZ5fw8kFIBRcAN5mluko7pK3OcrlUXPn1znKsRdfrYzFEsXYKyevbBQt5CMHy8J4/Xck5YkZxrOqF4g4vOduHhCjtcdl7r2zhm+wYJvYvZEmZozVWbnzZYJWRPEhvFsZqGlTqRsm75Y/clPRZrCrFDDZ4jcdK++Rm+micSwQazcrrIyaT96TNqPHxPnqVPiPHlSOs53urouw2oV27A8sQ/PF9vw4WIbPkxseXliG5ontryhYs3ODoQxIjHGpVLdYo8VRir2hh5LzRMZO0+fmDXidpHkwWIW3F63HKk9IjvP75TimmLV8Q8XhGBwwmC5cfCNMn7QeBVvEN6fUemjonJt4kYKQApAI95ACJPR8OEmXfRVVom3OdQC1xWWrCyxFxSoIMyOwtFqJqVl5Aipy7TK2bZzUt5Yrnp85U3lakxIRXNFYJZuMBgDgvABeMAxiQOuADzkCDRqKrfu2V0ipdtFSreJXDgeetyaKDLqa7prFwGb0zvD3xBj4GluVkLQ9dUZcZUilfpSWSAodUQsFiUCrbk5YsvJEWtOrgp3ZM3KEmt2lsotg7PEOigzMBmKRCEN5/QA07Dmn0FYojDBA4sg3MUjbxMpmC2Sap61yRGoH8YBDP3BJBIYCBDOK9I7Iz81X3mCClIL9DytQG1jPXejvjsaKQApAI14A1344x+l9s3VIWXxaWliGzJEbMOGqWTNGyru7AxpyE6UC4MsUiUNUt1SrQb5nm8+r1J1a7V4tK5nHoI0e5oSd+jJYQAwenbIMVPMVO6h6iO6a0il4tDB48Evg1FzdAsBXgo2E/2NYiyQOYJRuysqxHW2QtwVZ1XIo45KdLYqxV1VFToL+QrEp6eLNTNTLIMHK0FoycjwJf92ugqbhOcXuSUtTY1ZpKvYYLjb9DG8sPCf2dq54kgwacNEhk3Vh3kgz51gqmEesAhiAiA8RcjhOYJIxPJ0kUAImtykXMlLyVMJkwRzk3NVmT9hJvJAPA+NFIAUgEa8gSqKt0n1gR3SkGGXulSRmhSPXJAm5Z6ta6tTi4HXttUGllPrDrhqEXtvRKreK/P3ziD8YM43zYsI6+3WnRKpPSlSc1wXfRjL15XYw4CvQO//dn093mQGUjWNQKytlY7qal0oIq+uUdtY0QTHPDiOYOjeK8/87RKbTSypqSopYZiaIvHJKRKfkiLxqSliQZ6cHJqSkCepNbXjExNVHodks5nnGb6etNTq6xDDAwBhCEHYhfVLiUIIwdybRXJuFMkaq6/qY5J1iiEf8F6CEAx4mZA3lUlFU4VyLV8JWAgRqDo7MVsGJw5W76VBCYMCKTMhU7mZYU3sSxopAGNLAK5Zs0ZeeeUVqaqqksmTJ8vq1atlxowZEetv2LBBnnvuOSktLZWxY8fKSy+9JAsXLhzwG+iN/W/IX478pUd18YCgF5WTlKP3qJJzZVjKMJXQ48KDZYqp/VgmCiEgGs6KXCoTqS/Vc4z5gfBr6mZMWEaBvnqA6tlPExk6WcRhsriFpNdCEeGUsCoOglp7Ll6Sjot14qmv70yX6sXT0CDehga9bmOjiCeyRf6qsFh0QZiYKHFJiRKfgJQgcYm+PCFB4h0OPffvJzgkzo4yh37MkSBxDrvE2e2+fYfE2fz7eh6SIDrNNkbS2SxS+R89mDs8BVjVp748cv3UoboQzBypjwvO8OXp+XoYmhieXesH7mIYKuCNOtd8TiV4qeCZqmmtUfnF9os9+lkPTXxIVkxd0aefr5ECUIzpnL8K3nvvPXn66aflrbfekpkzZ8obb7whCxYskJKSEsnJuTzu044dO2Tp0qWyatUqueeee+Tdd9+V++67T4qLi2XChAkykAxLHaYsdP7ejz9Hz8jfU0KO3pId4UZiWdS11Yu0XdRdta21ushruaDnzdW6sMPauk1VeCt3//OSs0WybtB76ei1Izgseu0J5g2GSq4OCCC4fpF6OvwdfW1vS4t4m5rE09gk3iaIwibxtjSrmfzeZv0Y9lHPg7oqtep5W6to2G5t7RzH6PGoMcI9GSfcp1gsnWKwu2S16uMkbXoeZ/WVqXKrmpDTWWbx7VslzqIfV6sMYdt/XG1bdAHq21afxb8db/Hl8fq5vjwO62ujjiUoR1217/t5wfuqftCsbnQIMRYQyU97g+5NQNB3eBTgXaj9r/79hO8lpNL/u/xvF2fRxxNi7WIIxZRcXRTi+wl5UpbuWk5EyohasQjDAwwTSBhL3hUuj0t5tSAU/Z4tWBQvtV9S4tCfw5hB+p6YsQBC9N1yyy3yhz/8Qe17vV7Jz8+XJ598UlauXHlZ/SVLlkhLS4ts2rQpUDZr1iwpKipSIrInmL4HgVsHbmjE2FLJLdLh9KX2zhzja9ytQXmriKtFd8siV9uNIu2NIs4G/YvVn3oDLJ2Yyad63CM6c79bBl+mhMQAEIDetjY9QRD6t9vbVegnbxty7Ds7c2e7b79dNJezc9vtEq/TJZoTdZzidTlFc7n1fZcrkEwJBGC4IPTvRyqLwz+PWpEkDkHy4QbFttelb8dpqKJyva4ekUZpTV+Z/1erfQssrjbEIdK3fbleDhFt9+1D2Oo5ygLbKvnq+pMSuzb980Jg4vdjGxuqLE5vF75TVR6nB0fXP1RnO8PqdJ7nr+c7N7xe4NzQupeV+eoinBNSX9Jo9vd3rFgAXS6X7N+/X5555plAWXx8vMybN0927tzZ5Tkoh8UwGFgMN27cGPH3OJ1OlYJvoH4BIQoQqiCgzX252g/bDsl95Wqsiha27e3cD0+wtMF6pnKtcxviTiX/tlsPsKpy/UvtuoDliiDe0ENWvWTkOXpvGT1ojMNBQFeUMeAyMQGwplmQrtOLS9kJIDohDN0+Ueju8G2jzK2Xdfi2fQkTavRtX479Dl85Es71eDrLUA85vmc6UK7v4ztIw74q99XDGExVF3EbPSLhZXC3d5V7vYHtK47jRLvx8/y71/yXvNpZ4/jNEOHmFOJZS+ZJ9ouhEyPJtRMTb8taDMz2eCQ3NzekHPsnTpzo8hyME+yqPsojAXfxiy++KP1O9TF9SbFoBPGgsNi41Z/bRWxJvpTYmcOlgvWB7cl6cqSJJKTpYg8uWWwrF0gmRR0hA4yyzNjtYrFjyEmyxApK2AYJQs2jd4jVPo75BONluf8cfx2cpwWVqeNBZVh9Jvy47+dgX9/21/GVezpEw9jD9iblPdFc8JzAgwILbqtIh0v3sridormdPg8MBLWvg97h0oWx+v0dgVzZH4PtCGoD/+nlajPc1uA3S3Z5HvaDJiJdVkc/FuJrDPu9gd8ZfH7Qts3RdbB3cm3wzdoLYGEMthrCAgg3c58zZq4ugEJ9ARG2g8oCeXyYCR0mfn+5b0KIMvvHByV9DIzaVjnG1sBFoLsL9OO6K6Ez97kiIPYwFhHlnJFICIkSAu5bs0xqCR62A/Ho9+SovKMzD/YCoSzgIQryGIV7kdTP95f5PEnBHqpgz1S410rfiLyNYPukz4kJAZiFwKwWi1RXV4eUY3/IkK6njqO8N/WBw+FQqd/B8kRIhBBCSF+hBK+v4w7PCzE1MREfxG63y7Rp02TLli2BMkwCwf7s2bO7PAflwfXB5s2bI9YnhBBCCIkVYsICCOCaXbZsmUyfPl3F/kMYGMzyXb58uTr+4IMPyrBhw9Q4PrBixQqZM2eOvPbaa7Jo0SJZv3697Nu3T95+++0BbgkhhBBCSP8SMwIQYV0uXLggzz//vJrIgXAuH3/8cWCiR3l5uZoZ7OfWW29Vsf9+/etfy7PPPqsCQWMG8EDHACSEEEII6W9iJg7gQMA4QoQQQkj00cj3d2yMASSEEEIIIT2HApAQQgghxGRQABJCCCGEmAwKQEIIIYQQk0EBSAghhBBiMigACSGEEEJMBgUgIYQQQojJoAAkhBBCCDEZFICEEEIIISYjZpaCGwj8i6ggojghhBBCooNG33vbzIuhUQBeA01NTSrPz88f6I9CCCGEkKt4j6enp4sZ4VrA14DX65Xz589LamqqxMXF9XnvBMLy7NmzMblOIdsX/cR6G9m+6CfW28j2XT2apinxl5eXJ/Hx5hwNRwvgNYCbZvjw4f36O3DTx+KD7Yfti35ivY1sX/QT621k+66OdJNa/vyYU/YSQgghhJgYCkBCCCGEEJNBAWhQHA6HvPDCCyqPRdi+6CfW28j2RT+x3ka2j1wLnARCCCGEEGIyaAEkhBBCCDEZFICEEEIIISaDApAQQgghxGRQABJCCCGEmAwKQANQWloqP/rRj2TUqFGSmJgohYWFauaTy+Xq9rz29nZ54oknZPDgwZKSkiLf+c53pLq6WozKb3/7W7n11lslKSlJMjIyenTOD3/4Q7XKSnC66667JFbahzlYzz//vAwdOlRd+3nz5snJkyfFiFy8eFG+//3vq4CsaB/u2ebm5m7PufPOOy+7fo899pgYhTVr1sjIkSMlISFBZs6cKXv27Om2/oYNG2T8+PGq/sSJE+Xf//63GJnetO+dd9657FrhPKPy5Zdfyje/+U21kgM+68aNG694zhdffCFTp05Vs0rHjBmj2mxkettGtC/8GiJVVVWJEVm1apXccsstajWtnJwcue+++6SkpOSK50Xbc2hUKAANwIkTJ9Sycn/605/k6NGj8vrrr8tbb70lzz77bLfn/fSnP5UPP/xQPQxbt25Vy9J9+9vfFqMCQXv//ffL448/3qvzIPgqKysDad26dRIr7Xv55ZflzTffVNd79+7dkpycLAsWLFDi3mhA/OH+3Lx5s2zatEm9nB555JErnvfwww+HXD+02Qi899578vTTT6vOVnFxsUyePFn97Wtqarqsv2PHDlm6dKkSvgcOHFAvK6QjR46IEelt+wDEffC1KisrE6PS0tKi2gSR2xPOnDkjixYtkq9//ety8OBBeeqpp+Shhx6STz75RGKljX4gooKvI8SVEcF7C0aMXbt2qe8Vt9st8+fPV+2ORLQ9h4YGYWCI8Xj55Ze1UaNGRTxeX1+v2Ww2bcOGDYGy48ePI6SPtnPnTs3IrF27VktPT+9R3WXLlmmLFy/Woomets/r9WpDhgzRXnnllZDr6nA4tHXr1mlG4tixY+re2rt3b6Dso48+0uLi4rRz585FPG/OnDnaihUrNCMyY8YM7YknngjsezweLS8vT1u1alWX9b/73e9qixYtCimbOXOm9uijj2qx0L7ePJdGA/fmBx980G2dX/7yl9rNN98cUrZkyRJtwYIFWqy08fPPP1f1Ll26pEUjNTU16vNv3bo1Yp1oew6NDC2ABqWhoUEGDRoU8fj+/ftVbwkuQz8wiRcUFMjOnTslloBbAz3YcePGKetaXV2dxAKwSMA1E3wNsTYlXHVGu4b4PHD7Tp8+PVCGz431sGG57I6///3vkpWVJRMmTJBnnnlGWltbxQjWWjxDwX97tAX7kf72KA+uD2BRM9q1utr2Abj0R4wYIfn5+bJ48WJl8Y0Voun6XStFRUVqWMk3vvEN2b59u0TTew909+4z03Xsb6z9/htIrzl16pSsXr1aXn311Yh1IBzsdvtlY81yc3MNO97jaoD7F25tjI88ffq0covffffd6mG3WCwSzfivE66Z0a8hPk+4G8lqtaov6u4+6/e+9z0lKDCG6dChQ/KrX/1Kuafef/99GUhqa2vF4/F0+bfHkIyuQDuj4VpdbfvQwfrrX/8qkyZNUi9ifP9gTCtE4PDhwyXaiXT9Ghsbpa2tTY3BjXYg+jCcBB01p9Mpf/7zn9U4XHTSMPbRyGAYFNzyt912m+osRiKankOjQwtgP7Jy5couB+QGp/Av43PnzinRg7FkGDsVi23sDQ888IDce++9aqAvxnlg7NnevXuVVTAW2jfQ9Hf7MEYQvXNcP4wh/Nvf/iYffPCBEvPEWMyePVsefPBBZT2aM2eOEunZ2dlqbDKJDiDiH330UZk2bZoS7xD0yDGu3OhgLCDG8a1fv36gP4ppoAWwH/nZz36mZrF2x+jRowPbmMSBAcp4YN9+++1uzxsyZIhy89TX14dYATELGMeM2sZrBT8L7kRYSefOnSvR3D7/dcI1Q8/dD/bxEr4e9LR9+Kzhkwc6OjrUzODe3G9wbwNcP8x2HyhwD8GCHD5rvrvnB+W9qT+QXE37wrHZbDJlyhR1rWKBSNcPE19iwfoXiRkzZsi2bdvEyPzkJz8JTCy7krU5mp5Do0MB2I+g94zUE2D5g/hDz23t2rVqvE53oB6+oLds2aLCvwC41srLy1VP3oht7AsqKirUGMBgwRSt7YNbG19auIZ+wQd3FNw1vZ0p3d/twz2FzgbGleHeA5999ply2/hFXU/A7Etwva5fJDB8Au3A3x6WZYC2YB8vo0h/AxyHm8oPZi5ez+etP9sXDlzIhw8floULF0osgOsUHi7EqNevL8EzN9DPWyQwt+XJJ59UXgF4dfCdeCWi6Tk0PAM9C4VoWkVFhTZmzBht7ty5aruysjKQguuMGzdO2717d6Dsscce0woKCrTPPvtM27dvnzZ79myVjEpZWZl24MAB7cUXX9RSUlLUNlJTU1OgDtr4/vvvq22U//znP1ezms+cOaN9+umn2tSpU7WxY8dq7e3tWrS3D/zud7/TMjIytH/+85/aoUOH1IxnzP5ua2vTjMZdd92lTZkyRd2D27ZtU9dh6dKlEe/RU6dOab/5zW/UvYnrhzaOHj1au+OOOzQjsH79ejXj+p133lGznB955BF1LaqqqtTxH/zgB9rKlSsD9bdv365ZrVbt1VdfVTPuX3jhBTUT//Dhw5oR6W37cN9+8skn2unTp7X9+/drDzzwgJaQkKAdPXpUMyJ4rvzPGF5lv//979U2nkOAtqGNfr766istKSlJ+8UvfqGu35o1azSLxaJ9/PHHmlHpbRtff/11bePGjdrJkyfVfYkZ+PHx8eq704g8/vjjaub5F198EfLea21tDdSJ9ufQyFAAGgCEX8DD3VXygxco9jHN3w9Ewo9//GMtMzNTfbF961vfChGNRgMhXbpqY3CbsI+/B8CXwPz587Xs7Gz1gI8YMUJ7+OGHAy+waG+fPxTMc889p+Xm5qqXNToBJSUlmhGpq6tTgg/iNi0tTVu+fHmIuA2/R8vLy5XYGzRokGobOjl4+TY0NGhGYfXq1aoTZbfbVdiUXbt2hYSwwTUN5h//+Id2ww03qPoIKfKvf/1LMzK9ad9TTz0VqIv7ceHChVpxcbFmVPwhT8KTv03I0cbwc4qKilQb0RkJfhaNSG/b+NJLL2mFhYVKuOO5u/POO5WBwKhEeu8FX5dYeA6NShz+G2grJCGEEEIIuX5wFjAhhBBCiMmgACSEEEIIMRkUgIQQQgghJoMCkBBCCCHEZFAAEkIIIYSYDApAQgghhBCTQQFICCGEEGIyKAAJIYQQQkwGBSAhhBBCiMmgACSEEEIIMRkUgIQQQgghJoMCkBBCCCHEZFAAEkIIIYSYDApAQgghhBCTQQFICCGEEGIyKAAJIYQQQkwGBSAhhBBCiMmgACSEEEIIMRkUgIQQQgghJoMCkBBCCCHEZFAAEkIIIYSYDApAQgghhBCTQQFICCGEEGIyKAAJIYQQQkwGBSAhhBBCiMmgACSEEEIIMRkUgIQQQgghJoMCkBBCCCHEZFAAEkIIIYSYDApAQgghhBCTQQFICCGEECLm4v8BcKdXHPT0xB0AAAAASUVORK5CYII=", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sample_model=SampleModel(name='sample_model')\n", "\n", @@ -86,36 +60,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "ac7061fd", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f1ca548a33f442258664aaff8e549814", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sample_model=SampleModel(name='sample_model')\n", "sample_model.temperature=5\n", @@ -148,134 +96,6 @@ "plt.title('Sample model at 5 K with detailed balance')\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "bd1e57cd", - "metadata": {}, - "outputs": [], - "source": [ - "sample_model['Gaussian'].fix_all_parameters()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "115f672d", - "metadata": {}, - "outputs": [], - "source": [ - "sample_mode=SampleModel(name=\"TestSampleModel\")\n", - "component1 = Gaussian(\n", - " name=\"TestGaussian\", area=1.0, center=0.0, width=1.0, unit=\"meV\"\n", - ")\n", - "component2 = Lorentzian(\n", - " name=\"TestLorentzian\", area=2.0, center=1.0, width=0.5, unit=\"meV\"\n", - ")\n", - "sample_model.add_component(component1)\n", - "sample_model.add_component(component2)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "f4e1fb01", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sample_mode=SampleModel(name=\"TestSampleModel\")\n", - "not sample_mode.components" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "f8cec9a3", - "metadata": {}, - "outputs": [ - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mAssertionError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 26\u001b[39m\n\u001b[32m 24\u001b[39m copied_comp = model_copy.components[name]\n\u001b[32m 25\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m copied_comp \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m comp\n\u001b[32m---> \u001b[39m\u001b[32m26\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m copied_comp.name == comp.name\n\u001b[32m 27\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m param_orig, param_copy \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\n\u001b[32m 28\u001b[39m comp.get_parameters(), copied_comp.get_parameters()\n\u001b[32m 29\u001b[39m ):\n\u001b[32m 30\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m param_copy \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m param_orig\n", - "\u001b[31mAssertionError\u001b[39m: " - ] - } - ], - "source": [ - "from copy import copy\n", - "model = SampleModel(name=\"TwoComponentModel\")\n", - "component1 = Gaussian(\n", - " name=\"TestGaussian1\", area=1.0, center=0.0, width=1.0, unit=\"meV\"\n", - ")\n", - "component2 = Lorentzian(\n", - " name=\"TestLorentzian1\", area=2.0, center=1.0, width=0.5, unit=\"meV\"\n", - ")\n", - "model.add_component(component1)\n", - "model.add_component(component2)\n", - "\n", - "sample_model_with_components=model\n", - "\n", - "model_copy = copy(sample_model_with_components)\n", - "\n", - "\n", - "\n", - "assert model_copy is not sample_model_with_components\n", - "assert model_copy.name == \"copy of \" + sample_model_with_components.name\n", - "assert len(model_copy.components) == len(\n", - " sample_model_with_components.components\n", - ")\n", - "for name, comp in sample_model_with_components.components.items():\n", - " copied_comp = model_copy.components[name]\n", - " assert copied_comp is not comp\n", - " assert copied_comp.name == comp.name\n", - " for param_orig, param_copy in zip(\n", - " comp.get_parameters(), copied_comp.get_parameters()\n", - " ):\n", - " assert param_copy is not param_orig\n", - " assert param_copy.name == param_orig.name\n", - " assert param_copy.value == param_orig.value\n", - " assert param_copy.fixed == param_orig.fixed" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c660f129", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Gaussian(name = copy of TestGaussian1, unit = meV,\n", - " area = ,\n", - " center = ,\n", - " width = )" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model_copy['TestGaussian1']" - ] } ], "metadata": { diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 62c33f4..a955e33 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -13,11 +13,7 @@ class TestSampleModel: @pytest.fixture def sample_model(self): - return SampleModel(name="TestSampleModel") - - @pytest.fixture - def sample_model_with_components(self): - model = SampleModel(name="TwoComponentModel") + model = SampleModel(name="TestSampleModel") component1 = Gaussian( name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) @@ -32,7 +28,7 @@ def test_init_no_temperature(self, sample_model): # WHEN THEN EXPECT assert sample_model.name == "TestSampleModel" assert isinstance(sample_model.components, dict) - assert len(sample_model.components) == 0 + assert len(sample_model.components) == 2 assert not sample_model.use_detailed_balance def test_init_with_temperature(self): @@ -59,27 +55,27 @@ def test_add_component(self, sample_model): # EXPECT assert "TestComponent" in sample_model.components - def test_add_duplicate_component_raises(self, sample_model_with_components): + def test_add_duplicate_component_raises(self, sample_model): # WHEN THEN component = Gaussian( name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) # EXPECT with pytest.raises(ValueError, match="already exists"): - sample_model_with_components.add_component(component) + sample_model.add_component(component) - def test_remove_component(self, sample_model_with_components): + def test_remove_component(self, sample_model): # WHEN THEN - sample_model_with_components.remove_component("TestGaussian1") + sample_model.remove_component("TestGaussian1") # EXPECT - assert "TestGaussian1" not in sample_model_with_components.components + assert "TestGaussian1" not in sample_model.components - def test_remove_nonexistent_component_raises(self, sample_model_with_components): + def test_remove_nonexistent_component_raises(self, sample_model): # WHEN THEN EXPECT with pytest.raises( KeyError, match="No component named 'NonExistentComponent' exists" ): - sample_model_with_components.remove_component("NonExistentComponent") + sample_model.remove_component("NonExistentComponent") def test_getitem(self, sample_model): # WHEN @@ -99,25 +95,24 @@ def test_setitem(self, sample_model): # EXPECT assert sample_model["TestComponent"] is component - def test_contains_component(self, sample_model_with_components): + def test_contains_component(self, sample_model): # WHEN THEN EXPECT - # EXPECT - assert "TestGaussian1" in sample_model_with_components - assert "NonExistentComponent" not in sample_model_with_components + assert "TestGaussian1" in sample_model + assert "NonExistentComponent" not in sample_model - def test_list_components(self, sample_model_with_components): + def test_list_components(self, sample_model): # WHEN THEN - components = sample_model_with_components.list_components() + components = sample_model.list_components() # EXPECT assert len(components) == 2 assert components[0] == "TestGaussian1" assert components[1] == "TestLorentzian1" - def test_clear_components(self, sample_model_with_components): + def test_clear_components(self, sample_model): # WHEN THEN - sample_model_with_components.clear_components() + sample_model.clear_components() # EXPECT - assert len(sample_model_with_components.components) == 0 + assert len(sample_model.components) == 0 # ───── Temperature and Detailed Balance ───── @@ -166,92 +161,84 @@ def test_use_detailed_balance(self, sample_model): # ───── Evaluation ───── - def test_evaluate(self, sample_model_with_components): + def test_evaluate(self, sample_model): # WHEN x = np.linspace(-5, 5, 100) - result = sample_model_with_components.evaluate(x) + result = sample_model.evaluate(x) # EXPECT - expected_result = sample_model_with_components["TestGaussian1"].evaluate( - x - ) + sample_model_with_components["TestLorentzian1"].evaluate(x) + expected_result = sample_model["TestGaussian1"].evaluate(x) + sample_model[ + "TestLorentzian1" + ].evaluate(x) np.testing.assert_allclose(result, expected_result, rtol=1e-5) @pytest.mark.parametrize( "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] ) - def test_evaluate_with_detailed_balance( - self, sample_model_with_components, normalise_db - ): + def test_evaluate_with_detailed_balance(self, sample_model, normalise_db): # WHEN - sample_model_with_components.temperature = 300 - sample_model_with_components.use_detailed_balance = True - sample_model_with_components.normalise_detailed_balance = normalise_db + sample_model.temperature = 300 + sample_model.use_detailed_balance = True + sample_model.normalise_detailed_balance = normalise_db x = np.linspace(-5, 5, 100) # THEN - result = sample_model_with_components.evaluate(x) + result = sample_model.evaluate(x) # EXPECT - expected_result = sample_model_with_components["TestGaussian1"].evaluate( - x - ) + sample_model_with_components["TestLorentzian1"].evaluate(x) + expected_result = sample_model["TestGaussian1"].evaluate(x) + sample_model[ + "TestLorentzian1" + ].evaluate(x) expected_result *= detailed_balance_factor( energy=x, - temperature=sample_model_with_components.temperature, + temperature=sample_model.temperature, divide_by_temperature=normalise_db, ) np.testing.assert_allclose(result, expected_result, rtol=1e-5) - def test_evaluate_component(self, sample_model_with_components): + def test_evaluate_component(self, sample_model): # WHEN THEN x = np.linspace(-5, 5, 100) - result1 = sample_model_with_components.evaluate_component(x, "TestGaussian1") - result2 = sample_model_with_components.evaluate_component(x, "TestLorentzian1") + result1 = sample_model.evaluate_component(x, "TestGaussian1") + result2 = sample_model.evaluate_component(x, "TestLorentzian1") # EXPECT - expected_result1 = sample_model_with_components["TestGaussian1"].evaluate(x) - expected_result2 = sample_model_with_components["TestLorentzian1"].evaluate(x) + expected_result1 = sample_model["TestGaussian1"].evaluate(x) + expected_result2 = sample_model["TestLorentzian1"].evaluate(x) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) @pytest.mark.parametrize( "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] ) - def test_evaluate_component_with_detailed_balance( - self, sample_model_with_components, normalise_db - ): + def test_evaluate_component_with_detailed_balance(self, sample_model, normalise_db): # WHEN - sample_model_with_components.temperature = 300 - sample_model_with_components.use_detailed_balance = True - sample_model_with_components.normalise_detailed_balance = normalise_db + sample_model.temperature = 300 + sample_model.use_detailed_balance = True + sample_model.normalise_detailed_balance = normalise_db # THEN x = np.linspace(-5, 5, 100) - result1 = sample_model_with_components.evaluate_component( - x, name="TestGaussian1" - ) - result2 = sample_model_with_components.evaluate_component( - x, name="TestLorentzian1" - ) + result1 = sample_model.evaluate_component(x, name="TestGaussian1") + result2 = sample_model.evaluate_component(x, name="TestLorentzian1") # EXPECT - expected_result1 = sample_model_with_components["TestGaussian1"].evaluate(x) - expected_result2 = sample_model_with_components["TestLorentzian1"].evaluate(x) + expected_result1 = sample_model["TestGaussian1"].evaluate(x) + expected_result2 = sample_model["TestLorentzian1"].evaluate(x) expected_result1 *= detailed_balance_factor( energy=x, - temperature=sample_model_with_components.temperature, + temperature=sample_model.temperature, divide_by_temperature=normalise_db, ) expected_result2 *= detailed_balance_factor( energy=x, - temperature=sample_model_with_components.temperature, + temperature=sample_model.temperature, divide_by_temperature=normalise_db, ) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) - def test_evaluate_nonexistent_component_raises(self, sample_model_with_components): + def test_evaluate_nonexistent_component_raises(self, sample_model): # WHEN x = np.linspace(-5, 5, 100) @@ -259,51 +246,51 @@ def test_evaluate_nonexistent_component_raises(self, sample_model_with_component with pytest.raises( KeyError, match="No component named 'NonExistentComponent' exists" ): - sample_model_with_components.evaluate_component(x, "NonExistentComponent") + sample_model.evaluate_component(x, "NonExistentComponent") # ───── Utilities ───── - def test_normalize_area(self, sample_model_with_components): + def test_normalize_area(self, sample_model): # WHEN THEN - sample_model_with_components.normalize_area() + sample_model.normalize_area() # EXPECT x = np.linspace(-10000, 10000, 1000000) # Lorentzians have long tails - result = sample_model_with_components.evaluate(x) + result = sample_model.evaluate(x) numerical_area = simpson(result, x) assert np.isclose(numerical_area, 1.0, rtol=1e-4) - def test_normalize_area_no_components_raises(self, sample_model): - # WHEN THEN EXPECT + def test_normalize_area_no_components_raises(self): + # WHEN THEN + sample_model = SampleModel(name="EmptyModel") + # EXPECT with pytest.raises( ValueError, match="No components in the model to normalize." ): sample_model.normalize_area() - def test_normalize_area_zero_total_raises(self, sample_model_with_components): + def test_normalize_area_zero_total_raises(self, sample_model): # WHEN THEN - sample_model_with_components["TestGaussian1"].area = 0.0 - sample_model_with_components["TestLorentzian1"].area = 0.0 + sample_model["TestGaussian1"].area = 0.0 + sample_model["TestLorentzian1"].area = 0.0 # EXPECT with pytest.raises(ValueError, match="Total area is zero; cannot normalize."): - sample_model_with_components.normalize_area() + sample_model.normalize_area() - def test_normalize_area_non_area_component_warns( - self, sample_model_with_components - ): + def test_normalize_area_non_area_component_warns(self, sample_model): # WHEN component1 = Polynomial( name="TestPolynomial", coefficients=[1, 2, 3], unit="meV" ) - sample_model_with_components.add_component(component1) + sample_model.add_component(component1) # THEN EXPECT with pytest.warns(UserWarning, match="does not have an 'area' "): - sample_model_with_components.normalize_area() + sample_model.normalize_area() - def test_get_parameters(self, sample_model_with_components): + def test_get_parameters(self, sample_model): # WHEN THEN - parameters = sample_model_with_components.get_parameters() + parameters = sample_model.get_parameters() # EXPECT assert len(parameters) == 6 @@ -320,16 +307,17 @@ def test_get_parameters(self, sample_model_with_components): assert all(isinstance(param, Parameter) for param in parameters) # WHEN - sample_model_with_components.temperature = 300 + sample_model.temperature = 300 # THEN - parameters = sample_model_with_components.get_parameters() + parameters = sample_model.get_parameters() # EXPECT assert len(parameters) == 7 expected_names.add("temperature") actual_names = {param.name for param in parameters} assert actual_names == expected_names - def test_get_parameters_no_components(self, sample_model): + def test_get_parameters_no_components(self): + sample_model = SampleModel(name="EmptyModel") # WHEN THEN parameters = sample_model.get_parameters() # EXPECT @@ -342,18 +330,19 @@ def test_get_parameters_no_components(self, sample_model): assert len(parameters) == 1 assert parameters[0].name == "temperature" - def test_get_fit_parameters(self, sample_model_with_components): + def test_get_fit_parameters(self, sample_model): # WHEN # Fix one parameter and make another dependent - sample_model_with_components["TestGaussian1"].area.fixed = True - sample_model_with_components["TestLorentzian1"].width.make_dependent_on( + sample_model["TestGaussian1"].area.fixed = True + sample_model["TestLorentzian1"].width.make_dependent_on( "comp1_width", - {"comp1_width": sample_model_with_components["TestGaussian1"].width}, + {"comp1_width": sample_model["TestGaussian1"].width}, ) # THEN - fit_parameters = sample_model_with_components.get_fit_parameters() + fit_parameters = sample_model.get_fit_parameters() + # EXPECT assert len(fit_parameters) == 4 @@ -367,36 +356,36 @@ def test_get_fit_parameters(self, sample_model_with_components): assert actual_names == expected_names assert all(isinstance(param, Parameter) for param in fit_parameters) - def test_fix_and_free_all_parameters(self, sample_model_with_components): + def test_fix_and_free_all_parameters(self, sample_model): # WHEN THEN - sample_model_with_components.fix_all_parameters() + sample_model.fix_all_parameters() + # EXPECT - for param in sample_model_with_components.get_parameters(): + for param in sample_model.get_parameters(): assert param.fixed is True # WHEN - sample_model_with_components.free_all_parameters() + sample_model.free_all_parameters() + # THEN - for param in sample_model_with_components.get_parameters(): + for param in sample_model.get_parameters(): assert param.fixed is False - def test_repr_contains_name_and_components(self, sample_model_with_components): + def test_repr_contains_name_and_components(self, sample_model): # WHEN THEN - rep = repr(sample_model_with_components) + rep = repr(sample_model) # EXPECT assert "SampleModel" in rep assert "TestGaussian" in rep - def test_copy(self, sample_model_with_components): + def test_copy(self, sample_model): # WHEN THEN - model_copy = copy(sample_model_with_components) + model_copy = copy(sample_model) # EXPECT - assert model_copy is not sample_model_with_components - assert model_copy.name == "copy of " + sample_model_with_components.name - assert len(model_copy.components) == len( - sample_model_with_components.components - ) - for name, comp in sample_model_with_components.components.items(): + assert model_copy is not sample_model + assert model_copy.name == "copy of " + sample_model.name + assert len(model_copy.components) == len(sample_model.components) + for name, comp in sample_model.components.items(): copied_comp = model_copy.components[name] assert copied_comp is not comp assert copied_comp.name == comp.name From cde9b4ba9ad54fea58187da9b05f6cb8ca98758c Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 17 Oct 2025 11:14:20 +0200 Subject: [PATCH 05/44] Add one more test --- tests/unit_tests/sample_model/test_sample_model.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index a955e33..315fe93 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -371,6 +371,12 @@ def test_fix_and_free_all_parameters(self, sample_model): for param in sample_model.get_parameters(): assert param.fixed is False + def test_delitem(self, sample_model): + # WHEN THEN + del sample_model["TestGaussian1"] + # EXPECT + assert "TestGaussian1" not in sample_model.components + def test_repr_contains_name_and_components(self, sample_model): # WHEN THEN rep = repr(sample_model) From 6f797f85aa61a8d5d08f1ac3c4b681f2b58053fd Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 17 Oct 2025 11:21:39 +0200 Subject: [PATCH 06/44] Added a few tests --- src/easydynamics/sample_model/sample_model.py | 28 +++++------ .../sample_model/test_sample_model.py | 50 ++++++++++++++----- 2 files changed, 51 insertions(+), 27 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 19bf4f1..5bd2d52 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -29,8 +29,8 @@ class SampleModel(ObjBase, MutableMapping): Temperature parameter for detailed balance. use_detailed_balance : bool Whether to apply detailed balance. - normalise_detailed_balance : bool - Whether to normalise the detailed balance by temperature. + normalize_detailed_balance : bool + Whether to normalize the detailed balance by temperature. name : str Name of the SampleModel. """ @@ -66,8 +66,8 @@ def __init__( self._temperature = None self._use_detailed_balance = False - self._normalise_detailed_balance = ( - True # Whether to normalise by temperature when using detailed balance. + self._normalize_detailed_balance = ( + True # Whether to normalize by temperature when using detailed balance. ) ############################################## @@ -248,24 +248,24 @@ def use_detailed_balance(self, value: bool) -> None: self._use_detailed_balance = value @property - def normalise_detailed_balance(self) -> bool: + def normalize_detailed_balance(self) -> bool: """ - If True, detailed balance will be normalised by temperature. If False, it will not be normalised. + If True, detailed balance will be normalized by temperature. If False, it will not be normalized. """ - return self._normalise_detailed_balance + return self._normalize_detailed_balance - @normalise_detailed_balance.setter - def normalise_detailed_balance(self, value: bool) -> None: + @normalize_detailed_balance.setter + def normalize_detailed_balance(self, value: bool) -> None: """ - If True, normalises the detailed balance by temperature. + If True, normalizes the detailed balance by temperature. Parameters ---------- value : bool - True to normalise, False otherwise. + True to normalize, False otherwise. """ - self._normalise_detailed_balance = value + self._normalize_detailed_balance = value ########################################################## # Evaluate # @@ -303,7 +303,7 @@ def evaluate( result *= detailed_balance_factor( energy=x, temperature=self._temperature, - divide_by_temperature=self._normalise_detailed_balance, + divide_by_temperature=self._normalize_detailed_balance, ) return result @@ -340,7 +340,7 @@ def evaluate_component( result *= detailed_balance_factor( energy=x, temperature=self._temperature, - divide_by_temperature=self._normalise_detailed_balance, + divide_by_temperature=self._normalize_detailed_balance, ) return result diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 315fe93..5d0b377 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -124,6 +124,12 @@ def test_set_temperature(self, sample_model): assert sample_model.temperature.value == 300 assert sample_model.temperature.unit == "K" + # WHEN THEN + sample_model.temperature = 150.0 + # EXPECT + assert sample_model.temperature.value == 150.0 + assert sample_model.temperature.unit == "K" + # Set temperature to None # WHEN THEN sample_model.temperature = None @@ -150,6 +156,11 @@ def test_convert_temperature_unit(self, sample_model): assert np.isclose(sample_model.temperature.value, 300000.0) assert sample_model.temperature.unit == "mK" + def test_convert_temperature_unit_no_temperature_raises(self, sample_model): + # WHEN THEN EXPECT + with pytest.raises(ValueError, match="cannot convert units"): + sample_model.convert_temperature_unit("mK") + def test_use_detailed_balance(self, sample_model): sample_model.temperature = 300 # WHEN THEN EXPECT @@ -172,13 +183,13 @@ def test_evaluate(self, sample_model): np.testing.assert_allclose(result, expected_result, rtol=1e-5) @pytest.mark.parametrize( - "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] + "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] ) - def test_evaluate_with_detailed_balance(self, sample_model, normalise_db): + def test_evaluate_with_detailed_balance(self, sample_model, normalize_db): # WHEN sample_model.temperature = 300 sample_model.use_detailed_balance = True - sample_model.normalise_detailed_balance = normalise_db + sample_model.normalize_detailed_balance = normalize_db x = np.linspace(-5, 5, 100) @@ -192,10 +203,18 @@ def test_evaluate_with_detailed_balance(self, sample_model, normalise_db): expected_result *= detailed_balance_factor( energy=x, temperature=sample_model.temperature, - divide_by_temperature=normalise_db, + divide_by_temperature=normalize_db, ) np.testing.assert_allclose(result, expected_result, rtol=1e-5) + def test_evaluate_no_components_raises(self): + # WHEN THEN + sample_model = SampleModel(name="EmptyModel") + x = np.linspace(-5, 5, 100) + # EXPECT + with pytest.raises(ValueError, match="No components in the model to evaluate."): + sample_model.evaluate(x) + def test_evaluate_component(self, sample_model): # WHEN THEN x = np.linspace(-5, 5, 100) @@ -209,13 +228,13 @@ def test_evaluate_component(self, sample_model): np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) @pytest.mark.parametrize( - "normalise_db", [True, False], ids=["Normalise DB", "Don't normalise DB"] + "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] ) - def test_evaluate_component_with_detailed_balance(self, sample_model, normalise_db): + def test_evaluate_component_with_detailed_balance(self, sample_model, normalize_db): # WHEN sample_model.temperature = 300 sample_model.use_detailed_balance = True - sample_model.normalise_detailed_balance = normalise_db + sample_model.normalize_detailed_balance = normalize_db # THEN x = np.linspace(-5, 5, 100) @@ -228,12 +247,12 @@ def test_evaluate_component_with_detailed_balance(self, sample_model, normalise_ expected_result1 *= detailed_balance_factor( energy=x, temperature=sample_model.temperature, - divide_by_temperature=normalise_db, + divide_by_temperature=normalize_db, ) expected_result2 *= detailed_balance_factor( energy=x, temperature=sample_model.temperature, - divide_by_temperature=normalise_db, + divide_by_temperature=normalize_db, ) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) @@ -268,13 +287,18 @@ def test_normalize_area_no_components_raises(self): ): sample_model.normalize_area() - def test_normalize_area_zero_total_raises(self, sample_model): + @pytest.mark.parametrize( + "area_value", + [np.nan, 0.0, np.inf], + ids=["NaN area", "Zero area", "Infinite area"], + ) + def test_normalize_area_not_finite_area_raises(self, sample_model, area_value): # WHEN THEN - sample_model["TestGaussian1"].area = 0.0 - sample_model["TestLorentzian1"].area = 0.0 + sample_model["TestGaussian1"].area = area_value + sample_model["TestLorentzian1"].area = area_value # EXPECT - with pytest.raises(ValueError, match="Total area is zero; cannot normalize."): + with pytest.raises(ValueError, match="cannot normalize."): sample_model.normalize_area() def test_normalize_area_non_area_component_warns(self, sample_model): From 3435da56be1160f0ac527d62a681d77f06ec2896 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 17 Oct 2025 11:28:07 +0200 Subject: [PATCH 07/44] a few more tests --- .../sample_model/test_sample_model.py | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 5d0b377..ba22154 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -64,6 +64,13 @@ def test_add_duplicate_component_raises(self, sample_model): with pytest.raises(ValueError, match="already exists"): sample_model.add_component(component) + def test_add_invalid_component_raises(self, sample_model): + # WHEN THEN EXPECT + with pytest.raises( + TypeError, match="component must be an instance of ModelComponent." + ): + sample_model.add_component("NotAComponent") + def test_remove_component(self, sample_model): # WHEN THEN sample_model.remove_component("TestGaussian1") @@ -156,6 +163,13 @@ def test_convert_temperature_unit(self, sample_model): assert np.isclose(sample_model.temperature.value, 300000.0) assert sample_model.temperature.unit == "mK" + def test_convert_temperature_unit_incompatible_unit_raises(self, sample_model): + # WHEN + sample_model.temperature = 300 # Kelvin + # THEN EXPECT + with pytest.raises(ValueError, match="Failed to convert temperature"): + sample_model.convert_temperature_unit("m") + def test_convert_temperature_unit_no_temperature_raises(self, sample_model): # WHEN THEN EXPECT with pytest.raises(ValueError, match="cannot convert units"): @@ -170,6 +184,14 @@ def test_use_detailed_balance(self, sample_model): sample_model.use_detailed_balance = False assert sample_model.use_detailed_balance is False + def test_use_detailed_balance_no_temperature_raises(self, sample_model): + # WHEN THEN EXPECT + with pytest.raises( + ValueError, + match="Temperature must be set to use detailed balance.", + ): + sample_model.use_detailed_balance = True + # ───── Evaluation ───── def test_evaluate(self, sample_model): @@ -410,11 +432,21 @@ def test_repr_contains_name_and_components(self, sample_model): def test_copy(self, sample_model): # WHEN THEN + sample_model.temperature = 300 model_copy = copy(sample_model) # EXPECT assert model_copy is not sample_model assert model_copy.name == "copy of " + sample_model.name assert len(model_copy.components) == len(sample_model.components) + assert model_copy.temperature is not sample_model.temperature + assert model_copy.temperature.name == sample_model.temperature.name + assert model_copy.temperature.value == sample_model.temperature.value + assert model_copy.temperature.unit == sample_model.temperature.unit + assert model_copy.use_detailed_balance == sample_model.use_detailed_balance + assert ( + model_copy.normalize_detailed_balance + == sample_model.normalize_detailed_balance + ) for name, comp in sample_model.components.items(): copied_comp = model_copy.components[name] assert copied_comp is not comp From c0a4f2c24c138fc5fe5fb7d19f2d85b1c41673b2 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 17 Oct 2025 11:31:18 +0200 Subject: [PATCH 08/44] fix a test --- src/easydynamics/sample_model/sample_model.py | 6 +++--- tests/unit_tests/sample_model/test_sample_model.py | 3 ++- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 5bd2d52..c49e508 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -86,14 +86,14 @@ def add_component( name : str, optional Name to assign to the component. If None, uses the component's own name. """ + if not isinstance(component, ModelComponent): + raise TypeError("component must be an instance of ModelComponent.") + if name is None: name = component.name if name in self.components: raise ValueError(f"Component with name '{name}' already exists.") - if not isinstance(component, ModelComponent): - raise TypeError("component must be an instance of ModelComponent.") - self.components[name] = component def remove_component(self, name: str): diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index ba22154..13e1924 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -3,6 +3,7 @@ import numpy as np import pytest from easyscience.variable import Parameter +from scipp import UnitError from scipy.integrate import simpson from easydynamics.sample_model import Gaussian, Lorentzian, Polynomial, SampleModel @@ -167,7 +168,7 @@ def test_convert_temperature_unit_incompatible_unit_raises(self, sample_model): # WHEN sample_model.temperature = 300 # Kelvin # THEN EXPECT - with pytest.raises(ValueError, match="Failed to convert temperature"): + with pytest.raises(UnitError, match="Failed to convert temperature"): sample_model.convert_temperature_unit("m") def test_convert_temperature_unit_no_temperature_raises(self, sample_model): From a4ba7945aa5bdc5cda721faa663f7c2a9e2d9641 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 17 Oct 2025 20:33:12 +0200 Subject: [PATCH 09/44] respond to PR comments --- src/easydynamics/sample_model/sample_model.py | 105 +++++++++++++----- .../sample_model/test_sample_model.py | 7 ++ 2 files changed, 87 insertions(+), 25 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index c49e508..af8fcf2 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -1,11 +1,14 @@ import warnings from collections.abc import MutableMapping from copy import copy +from itertools import chain from typing import Dict, List, Optional, Union import numpy as np import scipp as sc -from easyscience.base_classes import ObjBase + +# from easyscience.base_classes import ObjBase +from easyscience.job.theoreticalmodel import TheoreticalModelBase from easyscience.variable import Parameter from scipp import UnitError @@ -16,7 +19,7 @@ Numeric = Union[float, int] -class SampleModel(ObjBase, MutableMapping): +class SampleModel(TheoreticalModelBase, MutableMapping): """ A model of the scattering from a sample, combining multiple model components. Optionally applies detailed balancing. @@ -38,7 +41,8 @@ class SampleModel(ObjBase, MutableMapping): def __init__( self, name: str = "MySampleModel", - temperature: Optional[Union[Numeric, None]] = None, + unit: Optional[Union[str, sc.Unit]] = "meV", + temperature: Optional[Union[Numeric, sc.Variable]] = None, temperature_unit: Optional[str] = "K", ): """ @@ -48,7 +52,7 @@ def __init__( ---------- name : str Name of the sample model. - temperature : Number or None, optional + temperature : Number, sc.Variable or None, optional Temperature for detailed balance. temperature_unit : str, default 'K' Unit of the temperature. @@ -57,18 +61,26 @@ def __init__( self.components: Dict[str, ModelComponent] = {} super().__init__(name=name) # If temperature is given, create a Parameter and enable detailed balance. - if temperature is not None: + if temperature is None: + self._temperature = None + self._use_detailed_balance = False + elif isinstance(temperature, sc.Variable): + self._temperature = Parameter( + name="temperature", + value=temperature.value, + unit=temperature.unit, + fixed=True, + ) + else: self._temperature = Parameter( name="temperature", value=temperature, unit=temperature_unit, fixed=True ) self._use_detailed_balance = True - else: - self._temperature = None - self._use_detailed_balance = False self._normalize_detailed_balance = ( True # Whether to normalize by temperature when using detailed balance. ) + self._unit = unit ############################################## # Methods for managing components # @@ -158,12 +170,40 @@ def normalize_area(self) -> None: for param in area_params: param.value /= total_area + def convert_unit(self, unit: Union[str, sc.Unit]): + """ + Convert the unit of the SampleModel and all its components. + """ + self._unit = unit + for component in self.components.values(): + component.convert_unit(unit) + + @property + def unit(self) -> Optional[Union[str, sc.Unit]]: + """ + Get the unit of the SampleModel. + + Returns + ------- + str or sc.Unit or None + """ + return self._unit + + @unit.setter + def unit(self, unit_str: str) -> None: + raise AttributeError( + ( + f"Unit is read-only. Use convert_unit to change the unit between allowed types " + f"or create a new {self.__class__.__name__} with the desired unit." + ) + ) # noqa: E501 + ########################################################## # Methods for temperature and detailed balance # ########################################################## @property - def temperature(self) -> Union[Parameter, None]: + def temperature(self) -> Optional[Parameter]: """ Get the temperature. @@ -174,7 +214,7 @@ def temperature(self) -> Union[Parameter, None]: return self._temperature @temperature.setter - def temperature(self, value: Union[Numeric, None]) -> None: + def temperature(self, value: Optional[Numeric]) -> None: """ Set the temperature. @@ -357,13 +397,18 @@ def get_parameters(self) -> List[Parameter]: ------- List[Parameter] """ - if isinstance(self._temperature, Parameter): - params = [self._temperature] - else: - params = [] - for comp in self.components.values(): - params.extend(comp.get_parameters()) - return params + # Create generator for temperature parameter + temp_params = (self._temperature,) if self._temperature is not None else () + + # Create generator for component parameters + comp_params = ( + param + for comp in self.components.values() + for param in comp.get_parameters() + ) + + # Chain them together and return as list + return list(chain(temp_params, comp_params)) def get_fit_parameters(self) -> List[Parameter]: """ @@ -373,17 +418,25 @@ def get_fit_parameters(self) -> List[Parameter]: List[Parameter]: A list of fit parameters. """ - parameters = self.get_parameters() - fit_parameters = [] + # parameters = self.get_parameters() + # fit_parameters = [] - for parameter in parameters: - is_not_fixed = not getattr(parameter, "fixed", False) - is_independent = getattr(parameter, "_independent", True) + # for parameter in parameters: + # is_not_fixed = not getattr(parameter, "fixed", False) + # is_independent = getattr(parameter, "_independent", True) + + # if is_not_fixed and is_independent: + # fit_parameters.append(parameter) + + def is_fit_parameter(param: Parameter) -> bool: + """Check if a parameter can be used for fitting.""" + return not getattr(param, "fixed", False) and getattr( + param, "_independent", True + ) - if is_not_fixed and is_independent: - fit_parameters.append(parameter) + return [param for param in self.get_parameters() if is_fit_parameter(param)] - return fit_parameters + # return fit_parameters def fix_all_parameters(self) -> None: """ @@ -417,10 +470,12 @@ def __copy__(self) -> "SampleModel": new_model = SampleModel( name=name, temperature=self._temperature.value if self._temperature else None, + unit=self.unit, ) if self._temperature: new_model.use_detailed_balance = self.use_detailed_balance + new_model.normalize_detailed_balance = self.normalize_detailed_balance for comp in self.components.values(): new_model.add_component(component=copy(comp), name=comp.name) diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 13e1924..137707b 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -122,6 +122,13 @@ def test_clear_components(self, sample_model): # EXPECT assert len(sample_model.components) == 0 + def test_convert_unit(self, sample_model): + # WHEN THEN + sample_model.convert_unit("eV") + # EXPECT + for component in sample_model.components.values(): + assert component.unit == "eV" + # ───── Temperature and Detailed Balance ───── def test_set_temperature(self, sample_model): From d1d28d2097771b4fce0f4b9571e6678ccd1fa896 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Mon, 20 Oct 2025 12:56:35 +0200 Subject: [PATCH 10/44] Use CollectionBase --- examples/sample_model.ipynb | 148 +++++++++++++- src/easydynamics/sample_model/sample_model.py | 188 ++++++------------ .../sample_model/test_sample_model.py | 36 +--- 3 files changed, 214 insertions(+), 158 deletions(-) diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb index 1753444..8534aec 100644 --- a/examples/sample_model.ipynb +++ b/examples/sample_model.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "64deaa41", "metadata": {}, "outputs": [], @@ -25,10 +25,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, + "id": "07a18846", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NotarizedDict({})" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_model=SampleModel(name='sample_model')\n", + "\n", + "\n", + "type(sample_model._kwargs)\n", + "sample_model._kwargs" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "id": "784d9e82", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ed6e6ebe1f3d415683cec11efc6c527f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sample_model=SampleModel(name='sample_model')\n", "\n", @@ -50,7 +101,7 @@ "y=sample_model.evaluate(x)\n", "plt.plot(x, y, label='Sample Model')\n", "\n", - "for component in sample_model.components.values():\n", + "for component in list(sample_model):\n", " y = component.evaluate(x)\n", " plt.plot(x, y, label=component.name)\n", "\n", @@ -63,7 +114,33 @@ "execution_count": null, "id": "ac7061fd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c248ebdeb8444ea6a3cd89a8e29b6f1a", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sample_model=SampleModel(name='sample_model')\n", "sample_model.temperature=5\n", @@ -88,14 +165,71 @@ "y=sample_model.evaluate(x)\n", "plt.plot(x, y, label='Sample Model')\n", "\n", - "for component in sample_model.values():\n", - " y=sample_model.evaluate_component(x,component.name)\n", + "for component in list(sample_model):\n", + " y = sample_model.evaluate_component(x, component.name)\n", " plt.plot(x, y, label=component.name)\n", "\n", "plt.legend()\n", "plt.title('Sample model at 5 K with detailed balance')\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f43ec31", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Gaussian(name = Gaussian, unit = meV,\n", + " area = ,\n", + " center = ,\n", + " width = ),\n", + " DampedHarmonicOscillator(name = DHO, unit = meV,\n", + " area = ,\n", + " center = ,\n", + " width = ),\n", + " Lorentzian(name = Lorentzian, unit = meV,\n", + " area = ,\n", + " center = ,\n", + " width = ),\n", + " Polynomial(name = Polynomial, unit = meV,\n", + " coefficients = [Polynomial_c0=0.1, Polynomial_c1=0.0, Polynomial_c2=0.5])]" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(sample_model)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "2e6c7f35", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "list" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# sample_model.remove_component('Polynomial')\n", + "type(list(sample_model))" + ] } ], "metadata": { diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index af8fcf2..b16dbd3 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -1,13 +1,12 @@ import warnings -from collections.abc import MutableMapping from copy import copy from itertools import chain -from typing import Dict, List, Optional, Union +from typing import List, Optional, Union import numpy as np import scipp as sc - -# from easyscience.base_classes import ObjBase +from easyscience.base_classes import CollectionBase +from easyscience.global_object.undo_redo import NotarizedDict from easyscience.job.theoreticalmodel import TheoreticalModelBase from easyscience.variable import Parameter from scipp import UnitError @@ -19,15 +18,13 @@ Numeric = Union[float, int] -class SampleModel(TheoreticalModelBase, MutableMapping): +class SampleModel(CollectionBase, TheoreticalModelBase): """ A model of the scattering from a sample, combining multiple model components. Optionally applies detailed balancing. Attributes ---------- - components : dict - Dictionary of model components keyed by name. temperature : Parameter Temperature parameter for detailed balance. use_detailed_balance : bool @@ -36,6 +33,11 @@ class SampleModel(TheoreticalModelBase, MutableMapping): Whether to normalize the detailed balance by temperature. name : str Name of the SampleModel. + unit : str or sc.Unit + Unit of the SampleModel. + components : List[ModelComponent] + List of model components in the SampleModel. + """ def __init__( @@ -58,8 +60,11 @@ def __init__( Unit of the temperature. """ - self.components: Dict[str, ModelComponent] = {} - super().__init__(name=name) + CollectionBase.__init__(self, name=name) + TheoreticalModelBase.__init__(self, name=name) + if not isinstance(self._kwargs, NotarizedDict): + self._kwargs = NotarizedDict() + # If temperature is given, create a Parameter and enable detailed balance. if temperature is None: self._temperature = None @@ -103,26 +108,24 @@ def add_component( if name is None: name = component.name - if name in self.components: + if name in self.list_component_names(): raise ValueError(f"Component with name '{name}' already exists.") - self.components[name] = component + component.name = name + + self.insert(index=len(self), value=component) def remove_component(self, name: str): """ Remove a model component by name. - - Parameters - ---------- - name : str - Name of the component to remove. """ - - if name not in self.components: + # Find index where item.name == name + indices = [i for i, item in enumerate(list(self)) if item.name == name] + if not indices: raise KeyError(f"No component named '{name}' exists in the model.") - del self.components[name] + del self[indices[0]] - def list_components(self) -> List[str]: + def list_component_names(self) -> List[str]: """ List the names of all components in the model. @@ -132,14 +135,15 @@ def list_components(self) -> List[str]: Component names. """ - return list(self.components.keys()) + return [item.name for item in list(self)] def clear_components(self): """ Remove all components from the model. """ - self.components.clear() + for _ in range(len(self)): + del self[0] def normalize_area(self) -> None: # Useful for convolutions. @@ -152,7 +156,7 @@ def normalize_area(self) -> None: area_params = [] total_area = 0.0 - for component in self.components.values(): + for component in list(self): if hasattr(component, "area"): area_params.append(component.area) total_area += component.area.value @@ -175,9 +179,21 @@ def convert_unit(self, unit: Union[str, sc.Unit]): Convert the unit of the SampleModel and all its components. """ self._unit = unit - for component in self.components.values(): + # for component in self.components.values(): + for component in list(self): component.convert_unit(unit) + @property + def components(self) -> List[ModelComponent]: + """ + Get the list of components in the SampleModel. + + Returns + ------- + List[ModelComponent] + """ + return list(self) + @property def unit(self) -> Optional[Union[str, sc.Unit]]: """ @@ -331,7 +347,7 @@ def evaluate( if not self.components: raise ValueError("No components in the model to evaluate.") result = None - for component in self.components.values(): + for component in list(self): value = component.evaluate(x) result = value if result is None else result + value @@ -368,10 +384,21 @@ def evaluate_component( np.ndarray Evaluated values for the specified component. """ - if name not in self.components: + if not self.components: + raise ValueError("No components in the model to evaluate.") + + if not isinstance(name, str): + raise TypeError( + (f"Component name must be a string, got {type(name)} instead.") + ) + + matches = [comp for comp in list(self) if comp.name == name] + if not matches: raise KeyError(f"No component named '{name}' exists.") - result = self.components[name].evaluate(x) + component = matches[0] + + result = component.evaluate(x) if ( self.use_detailed_balance and self._temperature is not None @@ -401,11 +428,7 @@ def get_parameters(self) -> List[Parameter]: temp_params = (self._temperature,) if self._temperature is not None else () # Create generator for component parameters - comp_params = ( - param - for comp in self.components.values() - for param in comp.get_parameters() - ) + comp_params = (param for comp in list(self) for param in comp.get_parameters()) # Chain them together and return as list return list(chain(temp_params, comp_params)) @@ -418,16 +441,6 @@ def get_fit_parameters(self) -> List[Parameter]: List[Parameter]: A list of fit parameters. """ - # parameters = self.get_parameters() - # fit_parameters = [] - - # for parameter in parameters: - # is_not_fixed = not getattr(parameter, "fixed", False) - # is_independent = getattr(parameter, "_independent", True) - - # if is_not_fixed and is_independent: - # fit_parameters.append(parameter) - def is_fit_parameter(param: Parameter) -> bool: """Check if a parameter can be used for fitting.""" return not getattr(param, "fixed", False) and getattr( @@ -477,7 +490,7 @@ def __copy__(self) -> "SampleModel": new_model.use_detailed_balance = self.use_detailed_balance new_model.normalize_detailed_balance = self.normalize_detailed_balance - for comp in self.components.values(): + for comp in list(self): new_model.add_component(component=copy(comp), name=comp.name) new_model[comp.name].name = comp.name # Remove 'copy of ' prefix for par in new_model[comp.name].get_parameters(): @@ -485,79 +498,6 @@ def __copy__(self) -> "SampleModel": return new_model - ############################################## - # dict-like behaviour # - ############################################## - - def __getitem__(self, key: str) -> ModelComponent: - """ - Access a component by name. - - Parameters - ---------- - key : str - Name of the component. - - Returns - ------- - ModelComponent - """ - return self.components[key] - - def __setitem__(self, key: str, value: ModelComponent) -> None: - """ - Set or replace a component. - - Parameters - ---------- - key : str - Name of the component. - value : ModelComponent - The component to assign. - """ - if not isinstance(value, ModelComponent): - raise TypeError("Value must be an instance of ModelComponent.") - self.components[key] = value - - def __delitem__(self, key: str) -> None: - """ - Remove a component by name. - Parameters - ---------- - key : str - Name of the component to remove. - """ - if not isinstance(key, str): - raise TypeError("Key must be a string.") - - if key not in self.components: - raise KeyError(f"No component named '{key}' exists in the model.") - - self.remove_component(key) - - def __contains__(self, name: str) -> bool: - """ - Check if a component exists in the model. - - Parameters - ---------- - name : str - Name of the component. - - Returns - ------- - bool - """ - return name in self.components - - def __iter__(self) -> iter: - """Iterate over component names.""" - return iter(self.components) - - def __len__(self) -> int: - """Return the number of components in the model.""" - return len(self.components) - def __repr__(self) -> str: """ Return a string representation of the SampleModel. @@ -566,10 +506,14 @@ def __repr__(self) -> str: ------- str """ - comp_names = ", ".join(self.components.keys()) or "No components" - temp_str = ( - f" | Temperature: {self._temperature.value} {self._temperature.unit}" - if self._use_detailed_balance - else "" - ) + comp_names = ", ".join(c.name for c in self) or "No components" + + temp_str = "" + if ( + getattr(self, "_use_detailed_balance", False) + and getattr(self, "_temperature", None) is not None + ): + temp = self._temperature + temp_str = f" | Temperature: {temp.value} {temp.unit}" + return f"" diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 137707b..26a946a 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -7,7 +7,6 @@ from scipy.integrate import simpson from easydynamics.sample_model import Gaussian, Lorentzian, Polynomial, SampleModel -from easydynamics.sample_model.components.model_component import ModelComponent from easydynamics.utils import _detailed_balance_factor as detailed_balance_factor @@ -28,7 +27,6 @@ def sample_model(self): def test_init_no_temperature(self, sample_model): # WHEN THEN EXPECT assert sample_model.name == "TestSampleModel" - assert isinstance(sample_model.components, dict) assert len(sample_model.components) == 2 assert not sample_model.use_detailed_balance @@ -38,7 +36,6 @@ def test_init_with_temperature(self): # EXPECT assert sample_model.name == "TempModel" - assert isinstance(sample_model.components, dict) assert len(sample_model.components) == 0 assert sample_model.use_detailed_balance assert isinstance(sample_model.temperature, Parameter) @@ -54,7 +51,7 @@ def test_add_component(self, sample_model): # THEN sample_model.add_component(component) # EXPECT - assert "TestComponent" in sample_model.components + assert sample_model["TestComponent"] is component def test_add_duplicate_component_raises(self, sample_model): # WHEN THEN @@ -95,22 +92,9 @@ def test_getitem(self, sample_model): # EXPECT assert sample_model["TestComponent"] is component - def test_setitem(self, sample_model): - # WHEN - component = ModelComponent(name="TestComponent") - # THEN - sample_model["TestComponent"] = component - # EXPECT - assert sample_model["TestComponent"] is component - - def test_contains_component(self, sample_model): - # WHEN THEN EXPECT - assert "TestGaussian1" in sample_model - assert "NonExistentComponent" not in sample_model - - def test_list_components(self, sample_model): + def test_list_component_names(self, sample_model): # WHEN THEN - components = sample_model.list_components() + components = sample_model.list_component_names() # EXPECT assert len(components) == 2 assert components[0] == "TestGaussian1" @@ -126,7 +110,7 @@ def test_convert_unit(self, sample_model): # WHEN THEN sample_model.convert_unit("eV") # EXPECT - for component in sample_model.components.values(): + for component in list(sample_model): assert component.unit == "eV" # ───── Temperature and Detailed Balance ───── @@ -425,12 +409,6 @@ def test_fix_and_free_all_parameters(self, sample_model): for param in sample_model.get_parameters(): assert param.fixed is False - def test_delitem(self, sample_model): - # WHEN THEN - del sample_model["TestGaussian1"] - # EXPECT - assert "TestGaussian1" not in sample_model.components - def test_repr_contains_name_and_components(self, sample_model): # WHEN THEN rep = repr(sample_model) @@ -445,7 +423,7 @@ def test_copy(self, sample_model): # EXPECT assert model_copy is not sample_model assert model_copy.name == "copy of " + sample_model.name - assert len(model_copy.components) == len(sample_model.components) + assert len(list(model_copy)) == len(list(sample_model)) assert model_copy.temperature is not sample_model.temperature assert model_copy.temperature.name == sample_model.temperature.name assert model_copy.temperature.value == sample_model.temperature.value @@ -455,8 +433,8 @@ def test_copy(self, sample_model): model_copy.normalize_detailed_balance == sample_model.normalize_detailed_balance ) - for name, comp in sample_model.components.items(): - copied_comp = model_copy.components[name] + for comp in list(sample_model): + copied_comp = model_copy[comp.name] assert copied_comp is not comp assert copied_comp.name == comp.name for param_orig, param_copy in zip( From ce49f0527087b9fc7699e68934769b009d120254 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Mon, 20 Oct 2025 13:08:10 +0200 Subject: [PATCH 11/44] Update example --- examples/sample_model.ipynb | 142 +----------------------------------- 1 file changed, 4 insertions(+), 138 deletions(-) diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb index 8534aec..5808e53 100644 --- a/examples/sample_model.ipynb +++ b/examples/sample_model.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "64deaa41", "metadata": {}, "outputs": [], @@ -25,61 +25,10 @@ }, { "cell_type": "code", - "execution_count": 10, - "id": "07a18846", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "NotarizedDict({})" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sample_model=SampleModel(name='sample_model')\n", - "\n", - "\n", - "type(sample_model._kwargs)\n", - "sample_model._kwargs" - ] - }, - { - "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "784d9e82", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ed6e6ebe1f3d415683cec11efc6c527f", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sample_model=SampleModel(name='sample_model')\n", "\n", @@ -114,33 +63,7 @@ "execution_count": null, "id": "ac7061fd", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c248ebdeb8444ea6a3cd89a8e29b6f1a", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sample_model=SampleModel(name='sample_model')\n", "sample_model.temperature=5\n", @@ -173,63 +96,6 @@ "plt.title('Sample model at 5 K with detailed balance')\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3f43ec31", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[Gaussian(name = Gaussian, unit = meV,\n", - " area = ,\n", - " center = ,\n", - " width = ),\n", - " DampedHarmonicOscillator(name = DHO, unit = meV,\n", - " area = ,\n", - " center = ,\n", - " width = ),\n", - " Lorentzian(name = Lorentzian, unit = meV,\n", - " area = ,\n", - " center = ,\n", - " width = ),\n", - " Polynomial(name = Polynomial, unit = meV,\n", - " coefficients = [Polynomial_c0=0.1, Polynomial_c1=0.0, Polynomial_c2=0.5])]" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "list(sample_model)\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "2e6c7f35", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "list" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# sample_model.remove_component('Polynomial')\n", - "type(list(sample_model))" - ] } ], "metadata": { From 07c070ae49823fb8ccb2a787f799937e38073441 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Tue, 28 Oct 2025 15:07:38 +0100 Subject: [PATCH 12/44] Update to new ModelComponent --- examples/sample_model.ipynb | 39 --- src/easydynamics/sample_model/sample_model.py | 281 ++-------------- .../sample_model/test_sample_model.py | 308 ++++++++---------- 3 files changed, 165 insertions(+), 463 deletions(-) diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb index 5808e53..1b86e7d 100644 --- a/examples/sample_model.ipynb +++ b/examples/sample_model.ipynb @@ -57,45 +57,6 @@ "plt.legend()\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ac7061fd", - "metadata": {}, - "outputs": [], - "source": [ - "sample_model=SampleModel(name='sample_model')\n", - "sample_model.temperature=5\n", - "sample_model.use_detailed_balance=True\n", - "sample_model.normalise_detailed_balance=True\n", - "\n", - "# Creating components\n", - "gaussian=Gaussian(name='Gaussian',width=0.5,area=1)\n", - "dho = DampedHarmonicOscillator(name='DHO',center=1.0,width=0.3,area=2.0)\n", - "lorentzian = Lorentzian(name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", - "polynomial = Polynomial(name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", - "\n", - "sample_model.add_component(gaussian)\n", - "sample_model.add_component(dho)\n", - "sample_model.add_component(lorentzian)\n", - "sample_model.add_component(polynomial)\n", - "\n", - "\n", - "x=np.linspace(-2, 2, 100)\n", - "\n", - "plt.figure()\n", - "y=sample_model.evaluate(x)\n", - "plt.plot(x, y, label='Sample Model')\n", - "\n", - "for component in list(sample_model):\n", - " y = sample_model.evaluate_component(x, component.name)\n", - " plt.plot(x, y, label=component.name)\n", - "\n", - "plt.legend()\n", - "plt.title('Sample model at 5 K with detailed balance')\n", - "plt.show()" - ] } ], "metadata": { diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index b16dbd3..aa8ba04 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -1,6 +1,4 @@ import warnings -from copy import copy -from itertools import chain from typing import List, Optional, Union import numpy as np @@ -8,10 +6,6 @@ from easyscience.base_classes import CollectionBase from easyscience.global_object.undo_redo import NotarizedDict from easyscience.job.theoreticalmodel import TheoreticalModelBase -from easyscience.variable import Parameter -from scipp import UnitError - -from easydynamics.utils import _detailed_balance_factor as detailed_balance_factor from .components.model_component import ModelComponent @@ -21,16 +15,9 @@ class SampleModel(CollectionBase, TheoreticalModelBase): """ A model of the scattering from a sample, combining multiple model components. - Optionally applies detailed balancing. Attributes ---------- - temperature : Parameter - Temperature parameter for detailed balance. - use_detailed_balance : bool - Whether to apply detailed balance. - normalize_detailed_balance : bool - Whether to normalize the detailed balance by temperature. name : str Name of the SampleModel. unit : str or sc.Unit @@ -44,8 +31,7 @@ def __init__( self, name: str = "MySampleModel", unit: Optional[Union[str, sc.Unit]] = "meV", - temperature: Optional[Union[Numeric, sc.Variable]] = None, - temperature_unit: Optional[str] = "K", + data: Optional[List] = None, ): """ Initialize a new SampleModel. @@ -54,10 +40,10 @@ def __init__( ---------- name : str Name of the sample model. - temperature : Number, sc.Variable or None, optional - Temperature for detailed balance. - temperature_unit : str, default 'K' - Unit of the temperature. + unit : str or sc.Unit, optional + Unit of the sample model. Defaults to "meV". + data : List[ModelComponent], optional + Initial list of model components to include in the sample model. """ CollectionBase.__init__(self, name=name) @@ -65,28 +51,17 @@ def __init__( if not isinstance(self._kwargs, NotarizedDict): self._kwargs = NotarizedDict() - # If temperature is given, create a Parameter and enable detailed balance. - if temperature is None: - self._temperature = None - self._use_detailed_balance = False - elif isinstance(temperature, sc.Variable): - self._temperature = Parameter( - name="temperature", - value=temperature.value, - unit=temperature.unit, - fixed=True, - ) - else: - self._temperature = Parameter( - name="temperature", value=temperature, unit=temperature_unit, fixed=True - ) - self._use_detailed_balance = True - - self._normalize_detailed_balance = ( - True # Whether to normalize by temperature when using detailed balance. - ) self._unit = unit + if data: + # clear any accidental pre-populated items (defensive) + self.clear_components() + for item in data: + # ensure item is a ModelComponent + if not isinstance(item, ModelComponent): + raise TypeError("Data items must be instances of ModelComponent.") + self.insert(index=len(self), value=item) + ############################################## # Methods for managing components # ############################################## @@ -174,15 +149,6 @@ def normalize_area(self) -> None: for param in area_params: param.value /= total_area - def convert_unit(self, unit: Union[str, sc.Unit]): - """ - Convert the unit of the SampleModel and all its components. - """ - self._unit = unit - # for component in self.components.values(): - for component in list(self): - component.convert_unit(unit) - @property def components(self) -> List[ModelComponent]: """ @@ -214,118 +180,14 @@ def unit(self, unit_str: str) -> None: ) ) # noqa: E501 - ########################################################## - # Methods for temperature and detailed balance # - ########################################################## - - @property - def temperature(self) -> Optional[Parameter]: - """ - Get the temperature. - - Returns - ------- - Parameter - """ - return self._temperature - - @temperature.setter - def temperature(self, value: Optional[Numeric]) -> None: - """ - Set the temperature. - - Parameters - ---------- - value : Number - Temperature value. If None, removes temperature and disables detailed balance. - """ - # If None, disable detailed balance and remove temperature parameter. - if value is None: - self._use_detailed_balance = False - self._temperature = None - return - - if not isinstance(value, Numeric): - raise TypeError("Temperature must be a number or None.") - value = float(value) - - if value < 0: - raise ValueError("Temperature must be non-negative.") - - if isinstance(self._temperature, Parameter): - self._temperature.value = value - else: - self._temperature = Parameter( - name="temperature", value=value, unit="K", fixed=True - ) - - def convert_temperature_unit(self, new_unit: Union[str, sc.Unit]) -> None: - """ - Convert the temperature parameter to a new unit. - - Parameters - ---------- - new_unit : str or sc.Unit - The new unit for the temperature. - """ - if self._temperature is None: - raise ValueError("Temperature is not set; cannot convert units.") - - try: - self._temperature.convert_unit(new_unit) - except UnitError as e: - raise UnitError(f"Failed to convert temperature to unit '{new_unit}': {e}") - except Exception as e: - raise RuntimeError(f"An error occurred during unit conversion: {e}") - - @property - def use_detailed_balance(self) -> bool: - """ - True if detailed balance is enabled, otherwise False. - - Returns - ------- - bool - """ - return self._use_detailed_balance - - @use_detailed_balance.setter - def use_detailed_balance(self, value: bool) -> None: - """ - If True, enables the use of detailed balance. Otherwise disables it. - - Parameters - ---------- - value : bool - True to enable, False to disable. - """ - if self._temperature is None: - raise ValueError("Temperature must be set to use detailed balance.") - self._use_detailed_balance = value - - @property - def normalize_detailed_balance(self) -> bool: - """ - If True, detailed balance will be normalized by temperature. If False, it will not be normalized. - - """ - return self._normalize_detailed_balance - - @normalize_detailed_balance.setter - def normalize_detailed_balance(self, value: bool) -> None: + def convert_unit(self, unit: Union[str, sc.Unit]) -> None: """ - If True, normalizes the detailed balance by temperature. - - Parameters - ---------- - value : bool - True to normalize, False otherwise. + Convert the unit of the SampleModel and all its components. """ - self._normalize_detailed_balance = value - - ########################################################## - # Evaluate # - ########################################################## + self._unit = unit + # for component in self.components.values(): + for component in list(self): + component.convert_unit(unit) def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] @@ -351,17 +213,6 @@ def evaluate( value = component.evaluate(x) result = value if result is None else result + value - if ( - self.use_detailed_balance - and self._temperature is not None - and self._temperature.value >= 0 - ): - result *= detailed_balance_factor( - energy=x, - temperature=self._temperature, - divide_by_temperature=self._normalize_detailed_balance, - ) - return result def evaluate_component( @@ -399,58 +250,9 @@ def evaluate_component( component = matches[0] result = component.evaluate(x) - if ( - self.use_detailed_balance - and self._temperature is not None - and self._temperature.value >= 0 - ): - result *= detailed_balance_factor( - energy=x, - temperature=self._temperature, - divide_by_temperature=self._normalize_detailed_balance, - ) return result - ############################################## - # Methods for managing parameters # - ############################################## - - def get_parameters(self) -> List[Parameter]: - """ - Return all parameters in the SampleModel. - - Returns - ------- - List[Parameter] - """ - # Create generator for temperature parameter - temp_params = (self._temperature,) if self._temperature is not None else () - - # Create generator for component parameters - comp_params = (param for comp in list(self) for param in comp.get_parameters()) - - # Chain them together and return as list - return list(chain(temp_params, comp_params)) - - def get_fit_parameters(self) -> List[Parameter]: - """ - Get all fit parameters, removing fixed and dependent parameters. - - Returns: - List[Parameter]: A list of fit parameters. - """ - - def is_fit_parameter(param: Parameter) -> bool: - """Check if a parameter can be used for fitting.""" - return not getattr(param, "fixed", False) and getattr( - param, "_independent", True - ) - - return [param for param in self.get_parameters() if is_fit_parameter(param)] - - # return fit_parameters - def fix_all_parameters(self) -> None: """ Fix all free parameters in the model. @@ -465,39 +267,6 @@ def free_all_parameters(self) -> None: for param in self.get_parameters(): param.fixed = False - ############################################## - # dunder methods # - ############################################## - - def __copy__(self) -> "SampleModel": - """ - Create a deep copy of the SampleModel with independent parameters. - - Returns - ------- - SampleModel - A new instance with copied components and parameters. - """ - name = "copy of " + self.name - - new_model = SampleModel( - name=name, - temperature=self._temperature.value if self._temperature else None, - unit=self.unit, - ) - - if self._temperature: - new_model.use_detailed_balance = self.use_detailed_balance - new_model.normalize_detailed_balance = self.normalize_detailed_balance - - for comp in list(self): - new_model.add_component(component=copy(comp), name=comp.name) - new_model[comp.name].name = comp.name # Remove 'copy of ' prefix - for par in new_model[comp.name].get_parameters(): - par.name = par.name.removeprefix("copy of ") - - return new_model - def __repr__(self) -> str: """ Return a string representation of the SampleModel. @@ -508,12 +277,4 @@ def __repr__(self) -> str: """ comp_names = ", ".join(c.name for c in self) or "No components" - temp_str = "" - if ( - getattr(self, "_use_detailed_balance", False) - and getattr(self, "_temperature", None) is not None - ): - temp = self._temperature - temp_str = f" | Temperature: {temp.value} {temp.unit}" - - return f"" + return f"" diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 26a946a..cfc1458 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -3,11 +3,9 @@ import numpy as np import pytest from easyscience.variable import Parameter -from scipp import UnitError from scipy.integrate import simpson from easydynamics.sample_model import Gaussian, Lorentzian, Polynomial, SampleModel -from easydynamics.utils import _detailed_balance_factor as detailed_balance_factor class TestSampleModel: @@ -24,22 +22,30 @@ def sample_model(self): model.add_component(component2) return model - def test_init_no_temperature(self, sample_model): - # WHEN THEN EXPECT - assert sample_model.name == "TestSampleModel" - assert len(sample_model.components) == 2 - assert not sample_model.use_detailed_balance - - def test_init_with_temperature(self): + def test_init(self): # WHEN THEN - sample_model = SampleModel(name="TempModel", temperature=100) + sample_model = SampleModel(name="InitModel") # EXPECT - assert sample_model.name == "TempModel" + assert sample_model.name == "InitModel" assert len(sample_model.components) == 0 - assert sample_model.use_detailed_balance - assert isinstance(sample_model.temperature, Parameter) - assert sample_model.temperature.value == 100 + + # def test_init_no_temperature(self, sample_model): + # # WHEN THEN EXPECT + # assert sample_model.name == "TestSampleModel" + # assert len(sample_model.components) == 2 + # assert not sample_model.use_detailed_balance + + # def test_init_with_temperature(self): + # # WHEN THEN + # sample_model = SampleModel(name="TempModel", temperature=100) + + # # EXPECT + # assert sample_model.name == "TempModel" + # assert len(sample_model.components) == 0 + # assert sample_model.use_detailed_balance + # assert isinstance(sample_model.temperature, Parameter) + # assert sample_model.temperature.value == 100 # ───── Component Management ───── @@ -113,76 +119,76 @@ def test_convert_unit(self, sample_model): for component in list(sample_model): assert component.unit == "eV" - # ───── Temperature and Detailed Balance ───── - - def test_set_temperature(self, sample_model): - # Set valid temperature - # WHEN THEN - sample_model.temperature = 300 - # EXPECT - assert sample_model.temperature.value == 300 - assert sample_model.temperature.unit == "K" - - # WHEN THEN - sample_model.temperature = 150.0 - # EXPECT - assert sample_model.temperature.value == 150.0 - assert sample_model.temperature.unit == "K" - - # Set temperature to None - # WHEN THEN - sample_model.temperature = None - # EXPECT - assert sample_model.temperature is None - assert not sample_model.use_detailed_balance - - def test_invalid_temperature_raises(self, sample_model): - # WHEN THEN EXPECT - with pytest.raises(TypeError, match="Temperature must be a number or None."): - sample_model.temperature = "invalid" - - def test_negative_temperature_raises(self, sample_model): - # WHEN THEN EXPECT - with pytest.raises(ValueError, match="Temperature must be non-negative"): - sample_model.temperature = -50 - - def test_convert_temperature_unit(self, sample_model): - # WHEN - sample_model.temperature = 300 # Kelvin - # THEN - sample_model.convert_temperature_unit("mK") - # EXPECT - assert np.isclose(sample_model.temperature.value, 300000.0) - assert sample_model.temperature.unit == "mK" - - def test_convert_temperature_unit_incompatible_unit_raises(self, sample_model): - # WHEN - sample_model.temperature = 300 # Kelvin - # THEN EXPECT - with pytest.raises(UnitError, match="Failed to convert temperature"): - sample_model.convert_temperature_unit("m") - - def test_convert_temperature_unit_no_temperature_raises(self, sample_model): - # WHEN THEN EXPECT - with pytest.raises(ValueError, match="cannot convert units"): - sample_model.convert_temperature_unit("mK") - - def test_use_detailed_balance(self, sample_model): - sample_model.temperature = 300 - # WHEN THEN EXPECT - assert sample_model.use_detailed_balance is False - sample_model.use_detailed_balance = True - assert sample_model.use_detailed_balance is True - sample_model.use_detailed_balance = False - assert sample_model.use_detailed_balance is False - - def test_use_detailed_balance_no_temperature_raises(self, sample_model): - # WHEN THEN EXPECT - with pytest.raises( - ValueError, - match="Temperature must be set to use detailed balance.", - ): - sample_model.use_detailed_balance = True + # # ───── Temperature and Detailed Balance ───── + + # def test_set_temperature(self, sample_model): + # # Set valid temperature + # # WHEN THEN + # sample_model.temperature = 300 + # # EXPECT + # assert sample_model.temperature.value == 300 + # assert sample_model.temperature.unit == "K" + + # # WHEN THEN + # sample_model.temperature = 150.0 + # # EXPECT + # assert sample_model.temperature.value == 150.0 + # assert sample_model.temperature.unit == "K" + + # # Set temperature to None + # # WHEN THEN + # sample_model.temperature = None + # # EXPECT + # assert sample_model.temperature is None + # assert not sample_model.use_detailed_balance + + # def test_invalid_temperature_raises(self, sample_model): + # # WHEN THEN EXPECT + # with pytest.raises(TypeError, match="Temperature must be a number or None."): + # sample_model.temperature = "invalid" + + # def test_negative_temperature_raises(self, sample_model): + # # WHEN THEN EXPECT + # with pytest.raises(ValueError, match="Temperature must be non-negative"): + # sample_model.temperature = -50 + + # def test_convert_temperature_unit(self, sample_model): + # # WHEN + # sample_model.temperature = 300 # Kelvin + # # THEN + # sample_model.convert_temperature_unit("mK") + # # EXPECT + # assert np.isclose(sample_model.temperature.value, 300000.0) + # assert sample_model.temperature.unit == "mK" + + # def test_convert_temperature_unit_incompatible_unit_raises(self, sample_model): + # # WHEN + # sample_model.temperature = 300 # Kelvin + # # THEN EXPECT + # with pytest.raises(UnitError, match="Failed to convert temperature"): + # sample_model.convert_temperature_unit("m") + + # def test_convert_temperature_unit_no_temperature_raises(self, sample_model): + # # WHEN THEN EXPECT + # with pytest.raises(ValueError, match="cannot convert units"): + # sample_model.convert_temperature_unit("mK") + + # def test_use_detailed_balance(self, sample_model): + # sample_model.temperature = 300 + # # WHEN THEN EXPECT + # assert sample_model.use_detailed_balance is False + # sample_model.use_detailed_balance = True + # assert sample_model.use_detailed_balance is True + # sample_model.use_detailed_balance = False + # assert sample_model.use_detailed_balance is False + + # def test_use_detailed_balance_no_temperature_raises(self, sample_model): + # # WHEN THEN EXPECT + # with pytest.raises( + # ValueError, + # match="Temperature must be set to use detailed balance.", + # ): + # sample_model.use_detailed_balance = True # ───── Evaluation ───── @@ -196,30 +202,30 @@ def test_evaluate(self, sample_model): ].evaluate(x) np.testing.assert_allclose(result, expected_result, rtol=1e-5) - @pytest.mark.parametrize( - "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] - ) - def test_evaluate_with_detailed_balance(self, sample_model, normalize_db): - # WHEN - sample_model.temperature = 300 - sample_model.use_detailed_balance = True - sample_model.normalize_detailed_balance = normalize_db - - x = np.linspace(-5, 5, 100) - - # THEN - result = sample_model.evaluate(x) - - # EXPECT - expected_result = sample_model["TestGaussian1"].evaluate(x) + sample_model[ - "TestLorentzian1" - ].evaluate(x) - expected_result *= detailed_balance_factor( - energy=x, - temperature=sample_model.temperature, - divide_by_temperature=normalize_db, - ) - np.testing.assert_allclose(result, expected_result, rtol=1e-5) + # @pytest.mark.parametrize( + # "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] + # ) + # def test_evaluate_with_detailed_balance(self, sample_model, normalize_db): + # # WHEN + # sample_model.temperature = 300 + # sample_model.use_detailed_balance = True + # sample_model.normalize_detailed_balance = normalize_db + + # x = np.linspace(-5, 5, 100) + + # # THEN + # result = sample_model.evaluate(x) + + # # EXPECT + # expected_result = sample_model["TestGaussian1"].evaluate(x) + sample_model[ + # "TestLorentzian1" + # ].evaluate(x) + # expected_result *= detailed_balance_factor( + # energy=x, + # temperature=sample_model.temperature, + # divide_by_temperature=normalize_db, + # ) + # np.testing.assert_allclose(result, expected_result, rtol=1e-5) def test_evaluate_no_components_raises(self): # WHEN THEN @@ -241,35 +247,35 @@ def test_evaluate_component(self, sample_model): np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) - @pytest.mark.parametrize( - "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] - ) - def test_evaluate_component_with_detailed_balance(self, sample_model, normalize_db): - # WHEN - sample_model.temperature = 300 - sample_model.use_detailed_balance = True - sample_model.normalize_detailed_balance = normalize_db - - # THEN - x = np.linspace(-5, 5, 100) - result1 = sample_model.evaluate_component(x, name="TestGaussian1") - result2 = sample_model.evaluate_component(x, name="TestLorentzian1") - - # EXPECT - expected_result1 = sample_model["TestGaussian1"].evaluate(x) - expected_result2 = sample_model["TestLorentzian1"].evaluate(x) - expected_result1 *= detailed_balance_factor( - energy=x, - temperature=sample_model.temperature, - divide_by_temperature=normalize_db, - ) - expected_result2 *= detailed_balance_factor( - energy=x, - temperature=sample_model.temperature, - divide_by_temperature=normalize_db, - ) - np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) - np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) + # @pytest.mark.parametrize( + # "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] + # ) + # def test_evaluate_component_with_detailed_balance(self, sample_model, normalize_db): + # # WHEN + # sample_model.temperature = 300 + # sample_model.use_detailed_balance = True + # sample_model.normalize_detailed_balance = normalize_db + + # # THEN + # x = np.linspace(-5, 5, 100) + # result1 = sample_model.evaluate_component(x, name="TestGaussian1") + # result2 = sample_model.evaluate_component(x, name="TestLorentzian1") + + # # EXPECT + # expected_result1 = sample_model["TestGaussian1"].evaluate(x) + # expected_result2 = sample_model["TestLorentzian1"].evaluate(x) + # expected_result1 *= detailed_balance_factor( + # energy=x, + # temperature=sample_model.temperature, + # divide_by_temperature=normalize_db, + # ) + # expected_result2 *= detailed_balance_factor( + # energy=x, + # temperature=sample_model.temperature, + # divide_by_temperature=normalize_db, + # ) + # np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) + # np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) def test_evaluate_nonexistent_component_raises(self, sample_model): # WHEN @@ -344,16 +350,6 @@ def test_get_parameters(self, sample_model): assert actual_names == expected_names assert all(isinstance(param, Parameter) for param in parameters) - # WHEN - sample_model.temperature = 300 - # THEN - parameters = sample_model.get_parameters() - # EXPECT - assert len(parameters) == 7 - expected_names.add("temperature") - actual_names = {param.name for param in parameters} - assert actual_names == expected_names - def test_get_parameters_no_components(self): sample_model = SampleModel(name="EmptyModel") # WHEN THEN @@ -361,13 +357,6 @@ def test_get_parameters_no_components(self): # EXPECT assert len(parameters) == 0 - # WHEN THEN - sample_model.temperature = 300 - parameters = sample_model.get_parameters() - # EXPECT - assert len(parameters) == 1 - assert parameters[0].name == "temperature" - def test_get_fit_parameters(self, sample_model): # WHEN @@ -422,17 +411,8 @@ def test_copy(self, sample_model): model_copy = copy(sample_model) # EXPECT assert model_copy is not sample_model - assert model_copy.name == "copy of " + sample_model.name + assert model_copy.name == sample_model.name assert len(list(model_copy)) == len(list(sample_model)) - assert model_copy.temperature is not sample_model.temperature - assert model_copy.temperature.name == sample_model.temperature.name - assert model_copy.temperature.value == sample_model.temperature.value - assert model_copy.temperature.unit == sample_model.temperature.unit - assert model_copy.use_detailed_balance == sample_model.use_detailed_balance - assert ( - model_copy.normalize_detailed_balance - == sample_model.normalize_detailed_balance - ) for comp in list(sample_model): copied_comp = model_copy[comp.name] assert copied_comp is not comp From 3a7187c4df1bcf6ca15faa8cdefcf677db368e32 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Tue, 28 Oct 2025 20:19:56 +0100 Subject: [PATCH 13/44] Cleanup and a few tests --- examples/sample_model.ipynb | 65 ++++++- src/easydynamics/sample_model/sample_model.py | 9 +- .../sample_model/test_sample_model.py | 180 ++++-------------- 3 files changed, 102 insertions(+), 152 deletions(-) diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb index 1b86e7d..732fa86 100644 --- a/examples/sample_model.ipynb +++ b/examples/sample_model.ipynb @@ -25,10 +25,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "784d9e82", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d473593b3aa14baf8f8c4dd432169d44", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "sample_model=SampleModel(name='sample_model')\n", "\n", @@ -57,6 +83,41 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d35179d8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[Gaussian(name = Gaussian, unit = meV,\n", + " area = ,\n", + " center = ,\n", + " width = ),\n", + " DampedHarmonicOscillator(name = DHO, unit = meV,\n", + " area = ,\n", + " center = ,\n", + " width = ),\n", + " Lorentzian(name = Lorentzian, unit = meV,\n", + " area = ,\n", + " center = ,\n", + " width = ),\n", + " Polynomial(name = Polynomial, unit = meV,\n", + " coefficients = [Polynomial_c0=0.1, Polynomial_c1=0.0, Polynomial_c2=0.5])]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# sample_model=SampleModel(name='sample_model')\n", + "sample_model.components" + ] } ], "metadata": { diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index aa8ba04..8a9dd13 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -53,8 +53,9 @@ def __init__( self._unit = unit + # Add initial components if provided. Mostly used for serialization. if data: - # clear any accidental pre-populated items (defensive) + # Just to be safe self.clear_components() for item in data: # ensure item is a ModelComponent @@ -62,10 +63,6 @@ def __init__( raise TypeError("Data items must be instances of ModelComponent.") self.insert(index=len(self), value=item) - ############################################## - # Methods for managing components # - ############################################## - def add_component( self, component: ModelComponent, name: Optional[str] = None ) -> None: @@ -221,7 +218,7 @@ def evaluate_component( name: str, ) -> np.ndarray: """ - Evaluate a single component by name, optionally applying detailed balance. + Evaluate a single component by name. Parameters ---------- diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index cfc1458..19d1042 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -30,22 +30,23 @@ def test_init(self): assert sample_model.name == "InitModel" assert len(sample_model.components) == 0 - # def test_init_no_temperature(self, sample_model): - # # WHEN THEN EXPECT - # assert sample_model.name == "TestSampleModel" - # assert len(sample_model.components) == 2 - # assert not sample_model.use_detailed_balance - - # def test_init_with_temperature(self): - # # WHEN THEN - # sample_model = SampleModel(name="TempModel", temperature=100) - - # # EXPECT - # assert sample_model.name == "TempModel" - # assert len(sample_model.components) == 0 - # assert sample_model.use_detailed_balance - # assert isinstance(sample_model.temperature, Parameter) - # assert sample_model.temperature.value == 100 + def test_initialization_with_components(self): + # WHEN THEN + component1 = Gaussian( + name="InitGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + name="InitLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" + ) + sample_model = SampleModel( + name="InitModelWithComponents", data=[component1, component2] + ) + + # EXPECT + assert sample_model.name == "InitModelWithComponents" + assert len(sample_model.components) == 2 + assert sample_model["InitGaussian"] is component1 + assert sample_model["InitLorentzian"] is component2 # ───── Component Management ───── @@ -119,79 +120,6 @@ def test_convert_unit(self, sample_model): for component in list(sample_model): assert component.unit == "eV" - # # ───── Temperature and Detailed Balance ───── - - # def test_set_temperature(self, sample_model): - # # Set valid temperature - # # WHEN THEN - # sample_model.temperature = 300 - # # EXPECT - # assert sample_model.temperature.value == 300 - # assert sample_model.temperature.unit == "K" - - # # WHEN THEN - # sample_model.temperature = 150.0 - # # EXPECT - # assert sample_model.temperature.value == 150.0 - # assert sample_model.temperature.unit == "K" - - # # Set temperature to None - # # WHEN THEN - # sample_model.temperature = None - # # EXPECT - # assert sample_model.temperature is None - # assert not sample_model.use_detailed_balance - - # def test_invalid_temperature_raises(self, sample_model): - # # WHEN THEN EXPECT - # with pytest.raises(TypeError, match="Temperature must be a number or None."): - # sample_model.temperature = "invalid" - - # def test_negative_temperature_raises(self, sample_model): - # # WHEN THEN EXPECT - # with pytest.raises(ValueError, match="Temperature must be non-negative"): - # sample_model.temperature = -50 - - # def test_convert_temperature_unit(self, sample_model): - # # WHEN - # sample_model.temperature = 300 # Kelvin - # # THEN - # sample_model.convert_temperature_unit("mK") - # # EXPECT - # assert np.isclose(sample_model.temperature.value, 300000.0) - # assert sample_model.temperature.unit == "mK" - - # def test_convert_temperature_unit_incompatible_unit_raises(self, sample_model): - # # WHEN - # sample_model.temperature = 300 # Kelvin - # # THEN EXPECT - # with pytest.raises(UnitError, match="Failed to convert temperature"): - # sample_model.convert_temperature_unit("m") - - # def test_convert_temperature_unit_no_temperature_raises(self, sample_model): - # # WHEN THEN EXPECT - # with pytest.raises(ValueError, match="cannot convert units"): - # sample_model.convert_temperature_unit("mK") - - # def test_use_detailed_balance(self, sample_model): - # sample_model.temperature = 300 - # # WHEN THEN EXPECT - # assert sample_model.use_detailed_balance is False - # sample_model.use_detailed_balance = True - # assert sample_model.use_detailed_balance is True - # sample_model.use_detailed_balance = False - # assert sample_model.use_detailed_balance is False - - # def test_use_detailed_balance_no_temperature_raises(self, sample_model): - # # WHEN THEN EXPECT - # with pytest.raises( - # ValueError, - # match="Temperature must be set to use detailed balance.", - # ): - # sample_model.use_detailed_balance = True - - # ───── Evaluation ───── - def test_evaluate(self, sample_model): # WHEN x = np.linspace(-5, 5, 100) @@ -202,31 +130,6 @@ def test_evaluate(self, sample_model): ].evaluate(x) np.testing.assert_allclose(result, expected_result, rtol=1e-5) - # @pytest.mark.parametrize( - # "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] - # ) - # def test_evaluate_with_detailed_balance(self, sample_model, normalize_db): - # # WHEN - # sample_model.temperature = 300 - # sample_model.use_detailed_balance = True - # sample_model.normalize_detailed_balance = normalize_db - - # x = np.linspace(-5, 5, 100) - - # # THEN - # result = sample_model.evaluate(x) - - # # EXPECT - # expected_result = sample_model["TestGaussian1"].evaluate(x) + sample_model[ - # "TestLorentzian1" - # ].evaluate(x) - # expected_result *= detailed_balance_factor( - # energy=x, - # temperature=sample_model.temperature, - # divide_by_temperature=normalize_db, - # ) - # np.testing.assert_allclose(result, expected_result, rtol=1e-5) - def test_evaluate_no_components_raises(self): # WHEN THEN sample_model = SampleModel(name="EmptyModel") @@ -247,36 +150,6 @@ def test_evaluate_component(self, sample_model): np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) - # @pytest.mark.parametrize( - # "normalize_db", [True, False], ids=["normalize DB", "Don't normalize DB"] - # ) - # def test_evaluate_component_with_detailed_balance(self, sample_model, normalize_db): - # # WHEN - # sample_model.temperature = 300 - # sample_model.use_detailed_balance = True - # sample_model.normalize_detailed_balance = normalize_db - - # # THEN - # x = np.linspace(-5, 5, 100) - # result1 = sample_model.evaluate_component(x, name="TestGaussian1") - # result2 = sample_model.evaluate_component(x, name="TestLorentzian1") - - # # EXPECT - # expected_result1 = sample_model["TestGaussian1"].evaluate(x) - # expected_result2 = sample_model["TestLorentzian1"].evaluate(x) - # expected_result1 *= detailed_balance_factor( - # energy=x, - # temperature=sample_model.temperature, - # divide_by_temperature=normalize_db, - # ) - # expected_result2 *= detailed_balance_factor( - # energy=x, - # temperature=sample_model.temperature, - # divide_by_temperature=normalize_db, - # ) - # np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) - # np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) - def test_evaluate_nonexistent_component_raises(self, sample_model): # WHEN x = np.linspace(-5, 5, 100) @@ -287,6 +160,25 @@ def test_evaluate_nonexistent_component_raises(self, sample_model): ): sample_model.evaluate_component(x, "NonExistentComponent") + def test_evaluate_component_no_components_raises(self): + # WHEN THEN + sample_model = SampleModel(name="EmptyModel") + x = np.linspace(-5, 5, 100) + # EXPECT + with pytest.raises(ValueError, match="No components in the model to evaluate."): + sample_model.evaluate_component(x, "AnyComponent") + + def test_evaluate_component_invalid_name_type_raises(self, sample_model): + # WHEN + x = np.linspace(-5, 5, 100) + + # THEN EXPECT + with pytest.raises( + TypeError, + match="Component name must be a string, got instead.", + ): + sample_model.evaluate_component(x, 123) + # ───── Utilities ───── def test_normalize_area(self, sample_model): From 8aa43c04d7aa0205410560fc5809e10f124fbc32 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Sat, 1 Nov 2025 20:23:29 +0100 Subject: [PATCH 14/44] Respond to reviewer comments --- examples/sample_model.ipynb | 66 +-------------- src/easydynamics/sample_model/sample_model.py | 84 +++++++++++-------- .../sample_model/test_sample_model.py | 10 +-- 3 files changed, 56 insertions(+), 104 deletions(-) diff --git a/examples/sample_model.ipynb b/examples/sample_model.ipynb index 732fa86..bffd235 100644 --- a/examples/sample_model.ipynb +++ b/examples/sample_model.ipynb @@ -25,36 +25,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "784d9e82", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d473593b3aa14baf8f8c4dd432169d44", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "sample_model=SampleModel(name='sample_model')\n", "\n", @@ -64,6 +38,7 @@ "lorentzian = Lorentzian(name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", "polynomial = Polynomial(name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", "\n", + "# Adding components to the sample model\n", "sample_model.add_component(gaussian)\n", "sample_model.add_component(dho)\n", "sample_model.add_component(lorentzian)\n", @@ -83,41 +58,6 @@ "plt.legend()\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "d35179d8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[Gaussian(name = Gaussian, unit = meV,\n", - " area = ,\n", - " center = ,\n", - " width = ),\n", - " DampedHarmonicOscillator(name = DHO, unit = meV,\n", - " area = ,\n", - " center = ,\n", - " width = ),\n", - " Lorentzian(name = Lorentzian, unit = meV,\n", - " area = ,\n", - " center = ,\n", - " width = ),\n", - " Polynomial(name = Polynomial, unit = meV,\n", - " coefficients = [Polynomial_c0=0.1, Polynomial_c1=0.0, Polynomial_c2=0.5])]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# sample_model=SampleModel(name='sample_model')\n", - "sample_model.components" - ] } ], "metadata": { diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 8a9dd13..de69f4d 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -22,8 +22,6 @@ class SampleModel(CollectionBase, TheoreticalModelBase): Name of the SampleModel. unit : str or sc.Unit Unit of the SampleModel. - components : List[ModelComponent] - List of model components in the SampleModel. """ @@ -46,8 +44,7 @@ def __init__( Initial list of model components to include in the sample model. """ - CollectionBase.__init__(self, name=name) - TheoreticalModelBase.__init__(self, name=name) + super().__init__(name=name) if not isinstance(self._kwargs, NotarizedDict): self._kwargs = NotarizedDict() @@ -55,8 +52,6 @@ def __init__( # Add initial components if provided. Mostly used for serialization. if data: - # Just to be safe - self.clear_components() for item in data: # ensure item is a ModelComponent if not isinstance(item, ModelComponent): @@ -76,7 +71,7 @@ def add_component( Name to assign to the component. If None, uses the component's own name. """ if not isinstance(component, ModelComponent): - raise TypeError("component must be an instance of ModelComponent.") + raise TypeError("Component must be an instance of ModelComponent.") if name is None: name = component.name @@ -87,15 +82,15 @@ def add_component( self.insert(index=len(self), value=component) - def remove_component(self, name: str): + def remove_component(self, name: str) -> None: """ Remove a model component by name. """ - # Find index where item.name == name - indices = [i for i, item in enumerate(list(self)) if item.name == name] - if not indices: - raise KeyError(f"No component named '{name}' exists in the model.") - del self[indices[0]] + for i, item in enumerate(self): + if item.name == name: + del self[i] + return + raise KeyError(f"No component named '{name}' exists in the model.") def list_component_names(self) -> List[str]: """ @@ -122,7 +117,7 @@ def normalize_area(self) -> None: """ Normalize the areas of all components so they sum to 1. """ - if not self.components: + if not list(self): raise ValueError("No components in the model to normalize.") area_params = [] @@ -146,17 +141,6 @@ def normalize_area(self) -> None: for param in area_params: param.value /= total_area - @property - def components(self) -> List[ModelComponent]: - """ - Get the list of components in the SampleModel. - - Returns - ------- - List[ModelComponent] - """ - return list(self) - @property def unit(self) -> Optional[Union[str, sc.Unit]]: """ @@ -181,10 +165,21 @@ def convert_unit(self, unit: Union[str, sc.Unit]) -> None: """ Convert the unit of the SampleModel and all its components. """ - self._unit = unit - # for component in self.components.values(): + + old_unit = self._unit + for component in list(self): - component.convert_unit(unit) + try: + component.convert_unit(unit) + except Exception as e: + # Attempt to rollback on failure + try: + component.convert_unit(old_unit) + except Exception: + pass # Best effort rollback + raise e + + self._unit = unit def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] @@ -203,14 +198,9 @@ def evaluate( Evaluated model values. """ - if not self.components: + if not list(self): raise ValueError("No components in the model to evaluate.") - result = None - for component in list(self): - value = component.evaluate(x) - result = value if result is None else result + value - - return result + return sum(component.evaluate(x) for component in list(self)) def evaluate_component( self, @@ -232,7 +222,7 @@ def evaluate_component( np.ndarray Evaluated values for the specified component. """ - if not self.components: + if not list(self): raise ValueError("No components in the model to evaluate.") if not isinstance(name, str): @@ -264,6 +254,28 @@ def free_all_parameters(self) -> None: for param in self.get_parameters(): param.fixed = False + def __contains__(self, item: Union[str, ModelComponent]) -> bool: + """ + Check if a component with the given name or instance exists in the SampleModel. + Args: + ---------- + item : str or ModelComponent + The component name or instance to check for. + Returns + ------- + bool + True if the component exists, False otherwise. + """ + + if isinstance(item, str): + # Check by component name + return any(comp.name == item for comp in self) + elif isinstance(item, ModelComponent): + # Check by component instance + return any(comp is item for comp in self) + else: + return False + def __repr__(self) -> str: """ Return a string representation of the SampleModel. diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 19d1042..1c984d8 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -28,7 +28,7 @@ def test_init(self): # EXPECT assert sample_model.name == "InitModel" - assert len(sample_model.components) == 0 + assert list(sample_model) == [] def test_initialization_with_components(self): # WHEN THEN @@ -44,7 +44,7 @@ def test_initialization_with_components(self): # EXPECT assert sample_model.name == "InitModelWithComponents" - assert len(sample_model.components) == 2 + assert len(list(sample_model)) == 2 assert sample_model["InitGaussian"] is component1 assert sample_model["InitLorentzian"] is component2 @@ -72,7 +72,7 @@ def test_add_duplicate_component_raises(self, sample_model): def test_add_invalid_component_raises(self, sample_model): # WHEN THEN EXPECT with pytest.raises( - TypeError, match="component must be an instance of ModelComponent." + TypeError, match="Component must be an instance of ModelComponent." ): sample_model.add_component("NotAComponent") @@ -80,7 +80,7 @@ def test_remove_component(self, sample_model): # WHEN THEN sample_model.remove_component("TestGaussian1") # EXPECT - assert "TestGaussian1" not in sample_model.components + assert "TestGaussian1" not in list(sample_model) def test_remove_nonexistent_component_raises(self, sample_model): # WHEN THEN EXPECT @@ -111,7 +111,7 @@ def test_clear_components(self, sample_model): # WHEN THEN sample_model.clear_components() # EXPECT - assert len(sample_model.components) == 0 + assert len(list(sample_model)) == 0 def test_convert_unit(self, sample_model): # WHEN THEN From 28d0b0e6cdda98102059cbe592e2d7c9b2e3a6ca Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Sat, 1 Nov 2025 20:33:31 +0100 Subject: [PATCH 15/44] Tests :) --- src/easydynamics/sample_model/sample_model.py | 20 ++++----- .../sample_model/test_sample_model.py | 42 +++++++++++++++++++ 2 files changed, 52 insertions(+), 10 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index de69f4d..bbc979c 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -168,18 +168,18 @@ def convert_unit(self, unit: Union[str, sc.Unit]) -> None: old_unit = self._unit - for component in list(self): - try: + try: + for component in list(self): component.convert_unit(unit) - except Exception as e: - # Attempt to rollback on failure - try: + self._unit = unit + except Exception as e: + # Attempt to rollback on failure + try: + for component in list(self): component.convert_unit(old_unit) - except Exception: - pass # Best effort rollback - raise e - - self._unit = unit + except Exception: + pass # Best effort rollback + raise e def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 1c984d8..ec4215d 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -120,6 +120,38 @@ def test_convert_unit(self, sample_model): for component in list(sample_model): assert component.unit == "eV" + def test_convert_unit_failure_rolls_back(self, sample_model): + # WHEN THEN + # Introduce a faulty component that will fail conversion + class FaultyComponent(Gaussian): + def convert_unit(self, unit: str) -> None: + raise RuntimeError("Conversion failed.") + + faulty_component = FaultyComponent( + name="FaultyComponent", area=1.0, center=0.0, width=1.0, unit="meV" + ) + sample_model.add_component(faulty_component) + + original_units = { + component.name: component.unit for component in list(sample_model) + } + + # EXPECT + with pytest.raises(RuntimeError, match="Conversion failed."): + sample_model.convert_unit("eV") + + # Check that all components have their original units + for component in list(sample_model): + assert component.unit == original_units[component.name] + + def test_set_unit(self, sample_model): + # WHEN THEN EXPECT + with pytest.raises( + AttributeError, + match="Unit is read-only. Use convert_unit to change the unit", + ): + sample_model.unit = "eV" + def test_evaluate(self, sample_model): # WHEN x = np.linspace(-5, 5, 100) @@ -290,6 +322,16 @@ def test_fix_and_free_all_parameters(self, sample_model): for param in sample_model.get_parameters(): assert param.fixed is False + def test_contains(self, sample_model): + # WHEN THEN + assert "TestGaussian1" in sample_model + assert "NonExistentComponent" not in sample_model + assert sample_model["TestLorentzian1"] in sample_model + fake_component = Gaussian( + name="FakeGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) + assert fake_component not in sample_model + def test_repr_contains_name_and_components(self, sample_model): # WHEN THEN rep = repr(sample_model) From a41277b4983f55687b282f7c61896741e24a59f1 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 13 Nov 2025 16:48:12 +0100 Subject: [PATCH 16/44] Get rid of CollectionBase --- src/easydynamics/sample_model/sample_model.py | 89 ++++++++++-------- .../sample_model/test_sample_model.py | 90 +++++++++---------- 2 files changed, 94 insertions(+), 85 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index bbc979c..7303ff1 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -3,7 +3,6 @@ import numpy as np import scipp as sc -from easyscience.base_classes import CollectionBase from easyscience.global_object.undo_redo import NotarizedDict from easyscience.job.theoreticalmodel import TheoreticalModelBase @@ -12,7 +11,7 @@ Numeric = Union[float, int] -class SampleModel(CollectionBase, TheoreticalModelBase): +class SampleModel(TheoreticalModelBase): """ A model of the scattering from a sample, combining multiple model components. @@ -29,7 +28,8 @@ def __init__( self, name: str = "MySampleModel", unit: Optional[Union[str, sc.Unit]] = "meV", - data: Optional[List] = None, + # components: Optional[List] = None, + **kwargs, ): """ Initialize a new SampleModel. @@ -40,7 +40,7 @@ def __init__( Name of the sample model. unit : str or sc.Unit, optional Unit of the sample model. Defaults to "meV". - data : List[ModelComponent], optional + components : List[ModelComponent], optional Initial list of model components to include in the sample model. """ @@ -49,14 +49,11 @@ def __init__( self._kwargs = NotarizedDict() self._unit = unit + self._components = [] - # Add initial components if provided. Mostly used for serialization. - if data: - for item in data: - # ensure item is a ModelComponent - if not isinstance(item, ModelComponent): - raise TypeError("Data items must be instances of ModelComponent.") - self.insert(index=len(self), value=item) + # Add initial components if provided. Needed for serialization. + for key, comp in list(kwargs.items()): + self._add_component(key, comp) def add_component( self, component: ModelComponent, name: Optional[str] = None @@ -68,28 +65,40 @@ def add_component( component : ModelComponent The model component to add. name : str, optional - Name to assign to the component. If None, uses the component's own name. + Name to assign to the component. If None, uses the component's own name. Renames the component if a different name is provided. """ + if not isinstance(component, ModelComponent): raise TypeError("Component must be an instance of ModelComponent.") if name is None: name = component.name - if name in self.list_component_names(): - raise ValueError(f"Component with name '{name}' already exists.") - component.name = name + if not isinstance(name, str): + raise TypeError("Component name must be a string.") + if name in getattr(self, "_kwargs", {}): + raise ValueError(f"Component with name '{name}' already exists.") - self.insert(index=len(self), value=component) + # Use ObjBase to add component so Global Object is updated correctly + self._add_component(name, component) def remove_component(self, name: str) -> None: """ - Remove a model component by name. + Remove a model component from the SampleModel by name. + Parameters + ---------- + name : str + Name of the component to remove. """ - for i, item in enumerate(self): + + if not isinstance(name, str): + raise TypeError("Component name must be a string.") + + for key, item in list(self._kwargs.items()): if item.name == name: - del self[i] + del self._kwargs[key] return + raise KeyError(f"No component named '{name}' exists in the model.") def list_component_names(self) -> List[str]: @@ -102,28 +111,25 @@ def list_component_names(self) -> List[str]: Component names. """ - return [item.name for item in list(self)] + return [item.name for item in self.components] - def clear_components(self): - """ - Remove all components from the model. - """ - - for _ in range(len(self)): - del self[0] + def clear_components(self) -> None: + """Remove all components.""" + for key in list(self._kwargs.keys()): + del self._kwargs[key] def normalize_area(self) -> None: # Useful for convolutions. """ Normalize the areas of all components so they sum to 1. """ - if not list(self): + if not self.components: raise ValueError("No components in the model to normalize.") area_params = [] total_area = 0.0 - for component in list(self): + for component in self.components: if hasattr(component, "area"): area_params.append(component.area) total_area += component.area.value @@ -141,6 +147,17 @@ def normalize_area(self) -> None: for param in area_params: param.value /= total_area + @property + def components(self) -> List[ModelComponent]: + """ + Get the list of model components in the SampleModel. + Returns + ------- + List[ModelComponent] + List of model components. + """ + return list(self._kwargs.values()) + @property def unit(self) -> Optional[Union[str, sc.Unit]]: """ @@ -169,13 +186,13 @@ def convert_unit(self, unit: Union[str, sc.Unit]) -> None: old_unit = self._unit try: - for component in list(self): + for component in self.components: component.convert_unit(unit) self._unit = unit except Exception as e: # Attempt to rollback on failure try: - for component in list(self): + for component in self.components: component.convert_unit(old_unit) except Exception: pass # Best effort rollback @@ -198,9 +215,9 @@ def evaluate( Evaluated model values. """ - if not list(self): + if not self.components: raise ValueError("No components in the model to evaluate.") - return sum(component.evaluate(x) for component in list(self)) + return sum(component.evaluate(x) for component in self.components) def evaluate_component( self, @@ -222,7 +239,7 @@ def evaluate_component( np.ndarray Evaluated values for the specified component. """ - if not list(self): + if not self.components: raise ValueError("No components in the model to evaluate.") if not isinstance(name, str): @@ -230,7 +247,7 @@ def evaluate_component( (f"Component name must be a string, got {type(name)} instead.") ) - matches = [comp for comp in list(self) if comp.name == name] + matches = [comp for comp in self.components if comp.name == name] if not matches: raise KeyError(f"No component named '{name}' exists.") @@ -284,6 +301,6 @@ def __repr__(self) -> str: ------- str """ - comp_names = ", ".join(c.name for c in self) or "No components" + comp_names = ", ".join(c.name for c in self.components) or "No components" return f"" diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index ec4215d..91386aa 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -28,25 +28,25 @@ def test_init(self): # EXPECT assert sample_model.name == "InitModel" - assert list(sample_model) == [] - - def test_initialization_with_components(self): - # WHEN THEN - component1 = Gaussian( - name="InitGaussian", area=1.0, center=0.0, width=1.0, unit="meV" - ) - component2 = Lorentzian( - name="InitLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" - ) - sample_model = SampleModel( - name="InitModelWithComponents", data=[component1, component2] - ) - - # EXPECT - assert sample_model.name == "InitModelWithComponents" - assert len(list(sample_model)) == 2 - assert sample_model["InitGaussian"] is component1 - assert sample_model["InitLorentzian"] is component2 + assert sample_model.components == [] + + # def test_initialization_with_components(self): + # # WHEN THEN + # component1 = Gaussian( + # name="InitGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + # ) + # component2 = Lorentzian( + # name="InitLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" + # ) + # sample_model = SampleModel( + # name="InitModelWithComponents", components=[component1, component2] + # ) + + # # EXPECT + # assert sample_model.name == "InitModelWithComponents" + # assert len(sample_model.components) == 2 + # assert sample_model.components[0] is component1 + # assert sample_model.components[1] is component2 # ───── Component Management ───── @@ -58,7 +58,7 @@ def test_add_component(self, sample_model): # THEN sample_model.add_component(component) # EXPECT - assert sample_model["TestComponent"] is component + assert sample_model.components[-1] is component def test_add_duplicate_component_raises(self, sample_model): # WHEN THEN @@ -80,7 +80,7 @@ def test_remove_component(self, sample_model): # WHEN THEN sample_model.remove_component("TestGaussian1") # EXPECT - assert "TestGaussian1" not in list(sample_model) + assert "TestGaussian1" not in sample_model.components def test_remove_nonexistent_component_raises(self, sample_model): # WHEN THEN EXPECT @@ -97,7 +97,7 @@ def test_getitem(self, sample_model): # THEN sample_model.add_component(component) # EXPECT - assert sample_model["TestComponent"] is component + assert sample_model.components[-1] is component def test_list_component_names(self, sample_model): # WHEN THEN @@ -111,13 +111,13 @@ def test_clear_components(self, sample_model): # WHEN THEN sample_model.clear_components() # EXPECT - assert len(list(sample_model)) == 0 + assert len(sample_model.components) == 0 def test_convert_unit(self, sample_model): # WHEN THEN sample_model.convert_unit("eV") # EXPECT - for component in list(sample_model): + for component in sample_model.components: assert component.unit == "eV" def test_convert_unit_failure_rolls_back(self, sample_model): @@ -133,7 +133,7 @@ def convert_unit(self, unit: str) -> None: sample_model.add_component(faulty_component) original_units = { - component.name: component.unit for component in list(sample_model) + component.name: component.unit for component in sample_model.components } # EXPECT @@ -141,7 +141,7 @@ def convert_unit(self, unit: str) -> None: sample_model.convert_unit("eV") # Check that all components have their original units - for component in list(sample_model): + for component in sample_model.components: assert component.unit == original_units[component.name] def test_set_unit(self, sample_model): @@ -157,9 +157,9 @@ def test_evaluate(self, sample_model): x = np.linspace(-5, 5, 100) result = sample_model.evaluate(x) # EXPECT - expected_result = sample_model["TestGaussian1"].evaluate(x) + sample_model[ - "TestLorentzian1" - ].evaluate(x) + expected_result = sample_model.components[0].evaluate( + x + ) + sample_model.components[1].evaluate(x) np.testing.assert_allclose(result, expected_result, rtol=1e-5) def test_evaluate_no_components_raises(self): @@ -177,8 +177,8 @@ def test_evaluate_component(self, sample_model): result2 = sample_model.evaluate_component(x, "TestLorentzian1") # EXPECT - expected_result1 = sample_model["TestGaussian1"].evaluate(x) - expected_result2 = sample_model["TestLorentzian1"].evaluate(x) + expected_result1 = sample_model.components[0].evaluate(x) + expected_result2 = sample_model.components[1].evaluate(x) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) @@ -238,8 +238,8 @@ def test_normalize_area_no_components_raises(self): ) def test_normalize_area_not_finite_area_raises(self, sample_model, area_value): # WHEN THEN - sample_model["TestGaussian1"].area = area_value - sample_model["TestLorentzian1"].area = area_value + sample_model.components[0].area = area_value + sample_model.components[1].area = area_value # EXPECT with pytest.raises(ValueError, match="cannot normalize."): @@ -285,10 +285,10 @@ def test_get_fit_parameters(self, sample_model): # WHEN # Fix one parameter and make another dependent - sample_model["TestGaussian1"].area.fixed = True - sample_model["TestLorentzian1"].width.make_dependent_on( + sample_model.components[0].area.fixed = True + sample_model.components[1].width.make_dependent_on( "comp1_width", - {"comp1_width": sample_model["TestGaussian1"].width}, + {"comp1_width": sample_model.components[0].width}, ) # THEN @@ -322,16 +322,6 @@ def test_fix_and_free_all_parameters(self, sample_model): for param in sample_model.get_parameters(): assert param.fixed is False - def test_contains(self, sample_model): - # WHEN THEN - assert "TestGaussian1" in sample_model - assert "NonExistentComponent" not in sample_model - assert sample_model["TestLorentzian1"] in sample_model - fake_component = Gaussian( - name="FakeGaussian", area=1.0, center=0.0, width=1.0, unit="meV" - ) - assert fake_component not in sample_model - def test_repr_contains_name_and_components(self, sample_model): # WHEN THEN rep = repr(sample_model) @@ -346,9 +336,11 @@ def test_copy(self, sample_model): # EXPECT assert model_copy is not sample_model assert model_copy.name == sample_model.name - assert len(list(model_copy)) == len(list(sample_model)) - for comp in list(sample_model): - copied_comp = model_copy[comp.name] + assert len(model_copy.components) == len(sample_model.components) + for comp in sample_model.components: + copied_comp = model_copy.components[ + model_copy.list_component_names().index(comp.name) + ] assert copied_comp is not comp assert copied_comp.name == comp.name for param_orig, param_copy in zip( From e39a18e236e5c2505deecbbb0b1d335313d2b3ea Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 13 Nov 2025 16:56:03 +0100 Subject: [PATCH 17/44] add test of containts --- src/easydynamics/sample_model/sample_model.py | 4 ++-- .../unit_tests/sample_model/test_sample_model.py | 16 ++++++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 7303ff1..25d135a 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -286,10 +286,10 @@ def __contains__(self, item: Union[str, ModelComponent]) -> bool: if isinstance(item, str): # Check by component name - return any(comp.name == item for comp in self) + return any(comp.name == item for comp in self.components) elif isinstance(item, ModelComponent): # Check by component instance - return any(comp is item for comp in self) + return any(comp is item for comp in self.components) else: return False diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 91386aa..f3de00c 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -322,6 +322,22 @@ def test_fix_and_free_all_parameters(self, sample_model): for param in sample_model.get_parameters(): assert param.fixed is False + def test_contains(self, sample_model): + # WHEN THEN + assert "TestGaussian1" in sample_model + assert "TestLorentzian1" in sample_model + assert "NonExistentComponent" not in sample_model + + gaussian_component = sample_model.components[0] + lorentzian_component = sample_model.components[1] + assert gaussian_component in sample_model + assert lorentzian_component in sample_model + + fake_component = Gaussian( + name="FakeGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + ) + assert fake_component not in sample_model + def test_repr_contains_name_and_components(self, sample_model): # WHEN THEN rep = repr(sample_model) From 8d3ad4d5e403b4a5ebbab2582e1bac1c5f26d16a Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 13 Nov 2025 17:09:26 +0100 Subject: [PATCH 18/44] Remove outcommented code --- src/easydynamics/sample_model/sample_model.py | 7 +++---- .../sample_model/test_sample_model.py | 18 ------------------ 2 files changed, 3 insertions(+), 22 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 25d135a..f49b991 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -28,7 +28,6 @@ def __init__( self, name: str = "MySampleModel", unit: Optional[Union[str, sc.Unit]] = "meV", - # components: Optional[List] = None, **kwargs, ): """ @@ -40,8 +39,8 @@ def __init__( Name of the sample model. unit : str or sc.Unit, optional Unit of the sample model. Defaults to "meV". - components : List[ModelComponent], optional - Initial list of model components to include in the sample model. + **kwargs : ModelComponent + Initial model components to add to the SampleModel. Keys are component names, values are ModelComponent instances. """ super().__init__(name=name) @@ -51,7 +50,7 @@ def __init__( self._unit = unit self._components = [] - # Add initial components if provided. Needed for serialization. + # Add initial components if provided. Used for serialization. for key, comp in list(kwargs.items()): self._add_component(key, comp) diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index f3de00c..e4d0b6b 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -30,24 +30,6 @@ def test_init(self): assert sample_model.name == "InitModel" assert sample_model.components == [] - # def test_initialization_with_components(self): - # # WHEN THEN - # component1 = Gaussian( - # name="InitGaussian", area=1.0, center=0.0, width=1.0, unit="meV" - # ) - # component2 = Lorentzian( - # name="InitLorentzian", area=2.0, center=1.0, width=0.5, unit="meV" - # ) - # sample_model = SampleModel( - # name="InitModelWithComponents", components=[component1, component2] - # ) - - # # EXPECT - # assert sample_model.name == "InitModelWithComponents" - # assert len(sample_model.components) == 2 - # assert sample_model.components[0] is component1 - # assert sample_model.components[1] is component2 - # ───── Component Management ───── def test_add_component(self, sample_model): From 0d3e3eb17f07d21bbd0da9c2f7c56031acf5fc0d Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 13 Nov 2025 17:13:15 +0100 Subject: [PATCH 19/44] update docstring --- src/easydynamics/sample_model/sample_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index f49b991..9e10302 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -201,7 +201,7 @@ def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] ) -> np.ndarray: """ - Evaluate the sum of all components, optionally applying detailed balance. + Evaluate the sum of all components. Parameters ---------- From 4543ef7e08521b8f416cddc1b3ca7df92ca1d9ca Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Wed, 10 Dec 2025 11:32:53 +0100 Subject: [PATCH 20/44] Update model_component to NewBase --- .../sample_model/components/gaussian.py | 24 +++++++++---------- .../components/model_component.py | 13 +++++----- .../components/test_model_component.py | 2 +- 3 files changed, 18 insertions(+), 21 deletions(-) diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index 239f664..c975989 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -28,29 +28,27 @@ class Gaussian(CreateParametersMixin, ModelComponent): def __init__( self, - name: Optional[str] = "Gaussian", + display_name: Optional[str] = "Gaussian", area: Optional[Union[Numeric, Parameter]] = 1.0, center: Optional[Union[Numeric, Parameter, None]] = None, width: Optional[Union[Numeric, Parameter]] = 1.0, unit: Optional[Union[str, sc.Unit]] = "meV", ): # Validate inputs and create Parameters if not given - self.validate_unit(unit) # lives in ModelComponent - self._unit = unit + super().__init__( + display_name=display_name, + unit=unit, + ) # These methods live in ValidationMixin - area = self._create_area_parameter(area=area, name=name, unit=self._unit) + area = self._create_area_parameter( + area=area, name=display_name, unit=self._unit + ) center = self._create_center_parameter( - center=center, name=name, fix_if_none=True, unit=self._unit + center=center, name=display_name, fix_if_none=True, unit=self._unit ) - width = self._create_width_parameter(width=width, name=name, unit=self._unit) - - super().__init__( - name=name, - unit=unit, - area=area, - center=center, - width=width, + width = self._create_width_parameter( + width=width, name=display_name, unit=self._unit ) def evaluate( diff --git a/src/easydynamics/sample_model/components/model_component.py b/src/easydynamics/sample_model/components/model_component.py index d6fecf6..eab9f1e 100644 --- a/src/easydynamics/sample_model/components/model_component.py +++ b/src/easydynamics/sample_model/components/model_component.py @@ -2,29 +2,28 @@ import warnings from abc import abstractmethod -from typing import Any, List, Optional, Union +from typing import List, Optional, Union import numpy as np import scipp as sc -from easyscience.base_classes import ObjBase +from easyscience.base_classes.new_base import NewBase from scipp import UnitError Numeric = Union[float, int] -class ModelComponent(ObjBase): +class ModelComponent(NewBase): """ Abstract base class for all model components. """ def __init__( self, - name="ModelComponent", + display_name="ModelComponent", unit: Optional[Union[str, sc.Unit]] = "meV", - **kwargs: Any, ): self.validate_unit(unit) - super().__init__(name=name, **kwargs) + super().__init__(display_name=display_name) self._unit = unit @property @@ -156,4 +155,4 @@ def evaluate(self, x: Union[Numeric, sc.Variable]) -> np.ndarray: pass def __repr__(self): - return f"{self.__class__.__name__}(name={self.name})" + return f"{self.__class__.__name__}(name={self.display_name})" diff --git a/tests/unit_tests/sample_model/components/test_model_component.py b/tests/unit_tests/sample_model/components/test_model_component.py index cd3776e..69c097f 100644 --- a/tests/unit_tests/sample_model/components/test_model_component.py +++ b/tests/unit_tests/sample_model/components/test_model_component.py @@ -8,7 +8,7 @@ class DummyComponent(ModelComponent): def __init__(self): - super().__init__(name="Dummy") + super().__init__(display_name="Dummy") self.area = Parameter(name="area", value=1.0, unit="meV", fixed=False) self.center = Parameter(name="center", value=2.0, unit="meV", fixed=True) self.width = Parameter(name="width", value=3.0, unit="meV", fixed=True) From 844d414f841485cb6be661d9c68ad662e37c2111 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Wed, 10 Dec 2025 13:34:04 +0100 Subject: [PATCH 21/44] Update model_component and tests --- examples/components.ipynb | 18 ++++---- .../sample_model/components/gaussian.py | 42 ++++++++++++++++++- .../components/model_component.py | 10 ++--- .../sample_model/components/test_gaussian.py | 38 +++++++++++------ .../components/test_model_component.py | 10 +++-- 5 files changed, 87 insertions(+), 31 deletions(-) diff --git a/examples/components.ipynb b/examples/components.ipynb index bdda8cf..26bb47c 100644 --- a/examples/components.ipynb +++ b/examples/components.ipynb @@ -19,7 +19,7 @@ "import matplotlib.pyplot as plt\n", "\n", "\n", - "%matplotlib widget" + "%matplotlib widget\n" ] }, { @@ -30,10 +30,10 @@ "outputs": [], "source": [ "# Creating a component\n", - "gaussian=Gaussian(name='Gaussian',width=0.5,area=1)\n", - "dho = DampedHarmonicOscillator(name='DHO',center=1.0,width=0.3,area=2.0)\n", - "lorentzian = Lorentzian(name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", - "polynomial = Polynomial(name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", + "gaussian=Gaussian(display_name='Gaussian',width=0.5,area=1)\n", + "dho = DampedHarmonicOscillator(display_name='DHO',center=1.0,width=0.3,area=2.0)\n", + "lorentzian = Lorentzian(display_name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", + "polynomial = Polynomial(display_name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", "\n", "x=np.linspace(-2, 2, 100)\n", "\n", @@ -72,7 +72,7 @@ "metadata": {}, "outputs": [], "source": [ - "delta = DeltaFunction(name='Delta', center=0.0, area=1.0)\n", + "delta = DeltaFunction(display_name='Delta', center=0.0, area=1.0)\n", "x1=np.linspace(-2, 2, 100)\n", "y=delta.evaluate(x1)\n", "x2=np.linspace(-2,2,51)\n", @@ -100,7 +100,7 @@ "x1=sc.linspace(dim='x', start=-2.0, stop=2.0, num=100, unit='meV')\n", "x2=sc.linspace(dim='x', start=-2.0*1e3, stop=2.0*1e3, num=101, unit='microeV')\n", "\n", - "polynomial = Polynomial(name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", + "polynomial = Polynomial(display_name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", "y1=polynomial.evaluate(x1)\n", "y2=polynomial.evaluate(x2)\n", "\n", @@ -114,7 +114,7 @@ ], "metadata": { "kernelspec": { - "display_name": "newdynamics", + "display_name": "easydynamics_newbase", "language": "python", "name": "python3" }, @@ -128,7 +128,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.13" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index c975989..23297a4 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -51,6 +51,46 @@ def __init__( width=width, name=display_name, unit=self._unit ) + self._area = area + self._center = center + self._width = width + + @property + def area(self) -> Parameter: + """Get the area parameter.""" + return self._area + + @area.setter + def area(self, value: Numeric) -> None: + """Set the area parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("area must be a number") + self._area.value = value + + @property + def center(self) -> Parameter: + """Get the center parameter.""" + return self._center + + @center.setter + def center(self, value: Numeric) -> None: + """Set the center parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("center must be a number") + self._center.value = value + + @property + def width(self) -> Parameter: + """Get the width parameter.""" + return self._width + + @width.setter + def width(self, value: Numeric) -> None: + """Set the width parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("width must be a number") + self._width.value = value + def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] ) -> np.ndarray: @@ -66,4 +106,4 @@ def evaluate( return self.area.value * normalization * np.exp(exponent) def __repr__(self): - return f"Gaussian(name = {self.name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" + return f"Gaussian(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" diff --git a/src/easydynamics/sample_model/components/model_component.py b/src/easydynamics/sample_model/components/model_component.py index eab9f1e..fac0ccc 100644 --- a/src/easydynamics/sample_model/components/model_component.py +++ b/src/easydynamics/sample_model/components/model_component.py @@ -6,13 +6,13 @@ import numpy as np import scipp as sc -from easyscience.base_classes.new_base import NewBase +from easyscience.base_classes.model_base import ModelBase from scipp import UnitError Numeric = Union[float, int] -class ModelComponent(NewBase): +class ModelComponent(ModelBase): """ Abstract base class for all model components. """ @@ -47,13 +47,13 @@ def unit(self, unit_str: str) -> None: def fix_all_parameters(self): """Fix all parameters in the model component.""" - pars = self.get_parameters() + pars = self.get_all_parameters() for p in pars: p.fixed = True def free_all_parameters(self): """Free all parameters in the model component.""" - for p in self.get_parameters(): + for p in self.get_all_parameters(): p.fixed = False def _prepare_x_for_evaluate( @@ -126,7 +126,7 @@ def convert_unit(self, unit: Union[str, sc.Unit]): """ old_unit = self._unit - pars = self.get_parameters() + pars = self.get_all_parameters() try: for p in pars: p.convert_unit(unit) diff --git a/tests/unit_tests/sample_model/components/test_gaussian.py b/tests/unit_tests/sample_model/components/test_gaussian.py index faffb31..e705590 100644 --- a/tests/unit_tests/sample_model/components/test_gaussian.py +++ b/tests/unit_tests/sample_model/components/test_gaussian.py @@ -12,7 +12,7 @@ class TestGaussian: @pytest.fixture def gaussian(self): return Gaussian( - name="TestGaussian", area=2.0, center=0.5, width=0.6, unit="meV" + display_name="TestGaussian", area=2.0, center=0.5, width=0.6, unit="meV" ) def test_init_no_inputs(self): @@ -20,7 +20,7 @@ def test_init_no_inputs(self): gaussian = Gaussian() # EXPECT - assert gaussian.name == "Gaussian" + assert gaussian.display_name == "Gaussian" assert gaussian.area.value == 1.0 assert gaussian.center.value == 0.0 assert gaussian.width.value == 1.0 @@ -29,7 +29,7 @@ def test_init_no_inputs(self): def test_initialization(self, gaussian: Gaussian): # WHEN THEN EXPECT - assert gaussian.name == "TestGaussian" + assert gaussian.display_name == "TestGaussian" assert gaussian.area.value == 2.0 assert gaussian.center.value == 0.5 assert gaussian.width.value == 0.6 @@ -43,7 +43,7 @@ def test_init_with_parameters(self): # THEN gaussian = Gaussian( - name="ParamGaussian", + display_name="ParamGaussian", area=area_param, center=center_param, width=width_param, @@ -51,7 +51,7 @@ def test_init_with_parameters(self): ) # EXPECT - assert gaussian.name == "ParamGaussian" + assert gaussian.display_name == "ParamGaussian" assert gaussian.area is area_param assert gaussian.center is center_param assert gaussian.width is width_param @@ -80,19 +80,31 @@ def test_init_with_parameters(self): ) def test_input_type_validation_raises(self, kwargs, expected_message): with pytest.raises(TypeError, match=expected_message): - Gaussian(name="TestGaussian", **kwargs) + Gaussian(display_name="TestGaussian", **kwargs) def test_negative_width_raises(self): # WHEN THEN EXPECT with pytest.raises( ValueError, match="The width of a Gaussian must be greater than zero." ): - Gaussian(name="TestGaussian", area=2.0, center=0.5, width=-0.6, unit="meV") + Gaussian( + display_name="TestGaussian", + area=2.0, + center=0.5, + width=-0.6, + unit="meV", + ) def test_negative_area_warns(self): # WHEN THEN EXPECT with pytest.warns(UserWarning, match="may not be physically meaningful"): - Gaussian(name="TestGaussian", area=-2.0, center=0.5, width=0.6, unit="meV") + Gaussian( + display_name="TestGaussian", + area=-2.0, + center=0.5, + width=0.6, + unit="meV", + ) @pytest.mark.parametrize( "prop, valid_value, invalid_value, invalid_message", @@ -129,15 +141,15 @@ def test_evaluate(self, gaussian: Gaussian): def test_center_is_fixed_if_set_to_None(self): # WHEN THEN test_gaussian = Gaussian( - name="TestGaussian", area=2.0, center=None, width=0.6, unit="meV" + display_name="TestGaussian", area=2.0, center=None, width=0.6, unit="meV" ) # EXPECT assert test_gaussian.center.value == 0.0 assert test_gaussian.center.fixed is True - def test_get_parameters(self, gaussian: Gaussian): + def test_get_all_parameters(self, gaussian: Gaussian): # WHEN THEN - params = gaussian.get_parameters() + params = gaussian.get_all_parameters() # EXPECT assert len(params) == 3 @@ -181,7 +193,7 @@ def test_copy(self, gaussian: Gaussian): gaussian_copy = copy(gaussian) # EXPECT assert gaussian_copy is not gaussian - assert gaussian_copy.name == gaussian.name + assert gaussian_copy.display_name == gaussian.display_name assert gaussian_copy.area.value == gaussian.area.value assert gaussian_copy.area.fixed == gaussian.area.fixed @@ -199,7 +211,7 @@ def test_repr(self, gaussian: Gaussian): repr_str = repr(gaussian) # EXPECT assert "Gaussian" in repr_str - assert "name = TestGaussian" in repr_str + assert "display_name = TestGaussian" in repr_str assert "unit = meV" in repr_str assert "area =" in repr_str assert "center =" in repr_str diff --git a/tests/unit_tests/sample_model/components/test_model_component.py b/tests/unit_tests/sample_model/components/test_model_component.py index 69c097f..9213cc5 100644 --- a/tests/unit_tests/sample_model/components/test_model_component.py +++ b/tests/unit_tests/sample_model/components/test_model_component.py @@ -1,3 +1,5 @@ +from typing import Union + import numpy as np import pytest import scipp as sc @@ -5,6 +7,8 @@ from easydynamics.sample_model.components.model_component import ModelComponent +Numeric = Union[float, int] + class DummyComponent(ModelComponent): def __init__(self): @@ -14,7 +18,7 @@ def __init__(self): self.width = Parameter(name="width", value=3.0, unit="meV", fixed=True) self._unit = "meV" - def get_parameters(self): + def get_all_parameters(self): return [self.area, self.center, self.width] def evaluate(self, x): @@ -44,11 +48,11 @@ def test_convert_unit(self, dummy: DummyComponent): def test_free_and_fix_all_parameters(self, dummy): # WHEN THEN EXPECT dummy.free_all_parameters() - assert all(not p.fixed for p in dummy.get_parameters()) + assert all(not p.fixed for p in dummy.get_all_parameters()) # THEN EXPECT dummy.fix_all_parameters() - assert all(p.fixed for p in dummy.get_parameters()) + assert all(p.fixed for p in dummy.get_all_parameters()) def test_repr(self, dummy): # WHEN THEN EXPECT From c155a7dcec884ecd2f2d905e58b8779b248bf15e Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 09:43:36 +0100 Subject: [PATCH 22/44] update model_component --- .../sample_model/components/model_component.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/easydynamics/sample_model/components/model_component.py b/src/easydynamics/sample_model/components/model_component.py index fac0ccc..6e1bc91 100644 --- a/src/easydynamics/sample_model/components/model_component.py +++ b/src/easydynamics/sample_model/components/model_component.py @@ -2,7 +2,7 @@ import warnings from abc import abstractmethod -from typing import List, Optional, Union +from typing import List, Union import numpy as np import scipp as sc @@ -19,8 +19,8 @@ class ModelComponent(ModelBase): def __init__( self, - display_name="ModelComponent", - unit: Optional[Union[str, sc.Unit]] = "meV", + display_name: str = None, + unit: str | sc.Unit = "meV", ): self.validate_unit(unit) super().__init__(display_name=display_name) @@ -47,17 +47,17 @@ def unit(self, unit_str: str) -> None: def fix_all_parameters(self): """Fix all parameters in the model component.""" - pars = self.get_all_parameters() + pars = self.get_fittable_parameters() for p in pars: p.fixed = True def free_all_parameters(self): """Free all parameters in the model component.""" - for p in self.get_all_parameters(): + for p in self.get_fittable_parameters(): p.fixed = False def _prepare_x_for_evaluate( - self, x: Union[Numeric, List[Numeric], np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | List[Numeric] | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """ "Prepare the input x for evaluation by handling units and converting to a numpy array.""" @@ -117,7 +117,7 @@ def validate_unit(unit) -> None: f"unit must be None, a string, or a scipp Unit, got {type(unit).__name__}" ) - def convert_unit(self, unit: Union[str, sc.Unit]): + def convert_unit(self, unit: str | sc.Unit): """ Convert the unit of the Parameters in the component. @@ -142,7 +142,7 @@ def convert_unit(self, unit: Union[str, sc.Unit]): raise e @abstractmethod - def evaluate(self, x: Union[Numeric, sc.Variable]) -> np.ndarray: + def evaluate(self, x: Numeric | sc.Variable) -> np.ndarray: """ Evaluate the model component at input x. From bde91b5e10ae653fc4025fd7230da18f8587048c Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 09:46:30 +0100 Subject: [PATCH 23/44] Update gaussian --- .../sample_model/components/gaussian.py | 16 +++++++--------- .../sample_model/components/model_component.py | 4 ++-- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index 23297a4..c4cc221 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -1,7 +1,5 @@ from __future__ import annotations -from typing import Optional, Union - import numpy as np import scipp as sc from easyscience.variable import Parameter @@ -10,7 +8,7 @@ from .model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int class Gaussian(CreateParametersMixin, ModelComponent): @@ -28,11 +26,11 @@ class Gaussian(CreateParametersMixin, ModelComponent): def __init__( self, - display_name: Optional[str] = "Gaussian", - area: Optional[Union[Numeric, Parameter]] = 1.0, - center: Optional[Union[Numeric, Parameter, None]] = None, - width: Optional[Union[Numeric, Parameter]] = 1.0, - unit: Optional[Union[str, sc.Unit]] = "meV", + display_name: str = "Gaussian", + area: Numeric | Parameter = 1.0, + center: Numeric | Parameter | None = None, + width: Numeric | Parameter = 1.0, + unit: str | sc.Unit = "meV", ): # Validate inputs and create Parameters if not given super().__init__( @@ -92,7 +90,7 @@ def width(self, value: Numeric) -> None: self._width.value = value def evaluate( - self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """Evaluate the Gaussian at the given x values. If x is a scipp Variable, the unit of the Gaussian will be converted to match x. diff --git a/src/easydynamics/sample_model/components/model_component.py b/src/easydynamics/sample_model/components/model_component.py index 6e1bc91..caa95dd 100644 --- a/src/easydynamics/sample_model/components/model_component.py +++ b/src/easydynamics/sample_model/components/model_component.py @@ -2,14 +2,14 @@ import warnings from abc import abstractmethod -from typing import List, Union +from typing import List import numpy as np import scipp as sc from easyscience.base_classes.model_base import ModelBase from scipp import UnitError -Numeric = Union[float, int] +Numeric = float | int class ModelComponent(ModelBase): From fa50c9382b3db3be7a22b3571c4d540447c99c31 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 09:49:56 +0100 Subject: [PATCH 24/44] update Lorentzian --- .../sample_model/components/lorentzian.py | 70 +++++++++++++++---- .../components/test_lorentzian.py | 34 +++++---- .../sample_model/test_sample_model.py | 2 +- 3 files changed, 77 insertions(+), 29 deletions(-) diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index 7551eaf..8b563f0 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Optional, Union +from typing import Union import numpy as np import scipp as sc @@ -28,33 +28,73 @@ class Lorentzian(CreateParametersMixin, ModelComponent): def __init__( self, - name: Optional[str] = "Lorentzian", - area: Optional[Union[Numeric, Parameter]] = 1.0, - center: Optional[Union[Numeric, Parameter, None]] = None, - width: Optional[Union[Numeric, Parameter]] = 1.0, - unit: Optional[Union[str, sc.Unit]] = "meV", + display_name: str = "Lorentzian", + area: Numeric | Parameter = 1.0, + center: Numeric | Parameter | None = None, + width: Numeric | Parameter = 1.0, + unit: str | sc.Unit = "meV", ): # Validate inputs and create Parameters if not given self.validate_unit(unit) self._unit = unit # These methods live in ValidationMixin - area = self._create_area_parameter(area=area, name=name, unit=self._unit) + area = self._create_area_parameter( + area=area, name=display_name, unit=self._unit + ) center = self._create_center_parameter( - center=center, name=name, fix_if_none=True, unit=self._unit + center=center, name=display_name, fix_if_none=True, unit=self._unit + ) + width = self._create_width_parameter( + width=width, name=display_name, unit=self._unit ) - width = self._create_width_parameter(width=width, name=name, unit=self._unit) super().__init__( - name=name, + display_name=display_name, unit=unit, - area=area, - center=center, - width=width, ) + self._area = area + self._center = center + self._width = width + + @property + def area(self) -> Parameter: + """Get the area parameter.""" + return self._area + + @area.setter + def area(self, value: Numeric) -> None: + """Set the area parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("area must be a number") + self._area.value = value + + @property + def center(self) -> Parameter: + """Get the center parameter.""" + return self._center + + @center.setter + def center(self, value: Numeric) -> None: + """Set the center parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("center must be a number") + self._center.value = value + + @property + def width(self) -> Parameter: + """Get the width parameter.""" + return self._width + + @width.setter + def width(self, value: Numeric) -> None: + """Set the width parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("width must be a number") + self._width.value = value def evaluate( - self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """Evaluate the Lorentzian at the given x values. If x is a scipp Variable, the unit of the Lorentzian will be converted to match x. @@ -68,4 +108,4 @@ def evaluate( return self.area.value * normalization / denominator def __repr__(self): - return f"Lorentzian(name = {self.name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" + return f"Lorentzian(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" diff --git a/tests/unit_tests/sample_model/components/test_lorentzian.py b/tests/unit_tests/sample_model/components/test_lorentzian.py index 43c73b8..f42b11b 100644 --- a/tests/unit_tests/sample_model/components/test_lorentzian.py +++ b/tests/unit_tests/sample_model/components/test_lorentzian.py @@ -12,7 +12,7 @@ class TestLorentzian: @pytest.fixture def lorentzian(self): return Lorentzian( - name="TestLorentzian", area=2.0, center=0.5, width=0.6, unit="meV" + display_name="TestLorentzian", area=2.0, center=0.5, width=0.6, unit="meV" ) def test_init_no_inputs(self): @@ -20,7 +20,7 @@ def test_init_no_inputs(self): lorentzian = Lorentzian() # EXPECT - assert lorentzian.name == "Lorentzian" + assert lorentzian.display_name == "Lorentzian" assert lorentzian.area.value == 1.0 assert lorentzian.center.value == 0.0 assert lorentzian.width.value == 1.0 @@ -29,7 +29,7 @@ def test_init_no_inputs(self): def test_initialization(self, lorentzian: Lorentzian): # WHEN THEN EXPECT - assert lorentzian.name == "TestLorentzian" + assert lorentzian.display_name == "TestLorentzian" assert lorentzian.area.value == 2.0 assert lorentzian.center.value == 0.5 assert lorentzian.width.value == 0.6 @@ -43,7 +43,7 @@ def test_init_with_parameters(self): # THEN lorentzian = Lorentzian( - name="ParamLorentzian", + display_name="ParamLorentzian", area=area_param, center=center_param, width=width_param, @@ -51,7 +51,7 @@ def test_init_with_parameters(self): ) # EXPECT - assert lorentzian.name == "ParamLorentzian" + assert lorentzian.display_name == "ParamLorentzian" assert lorentzian.area is area_param assert lorentzian.center is center_param assert lorentzian.width is width_param @@ -80,7 +80,7 @@ def test_init_with_parameters(self): ) def test_input_type_validation_raises(self, kwargs, expected_message): with pytest.raises(TypeError, match=expected_message): - Lorentzian(name="TestLorentzian", **kwargs) + Lorentzian(display_name="TestLorentzian", **kwargs) def test_negative_width_raises(self): # WHEN THEN EXPECT @@ -88,14 +88,22 @@ def test_negative_width_raises(self): ValueError, match="The width of a Lorentzian must be greater than zero." ): Lorentzian( - name="TestLorentzian", area=2.0, center=0.5, width=-0.6, unit="meV" + display_name="TestLorentzian", + area=2.0, + center=0.5, + width=-0.6, + unit="meV", ) def test_negative_area_warns(self): # WHEN THEN EXPECT with pytest.warns(UserWarning, match="may not be physically meaningful"): Lorentzian( - name="TestLorentzian", area=-2.0, center=0.5, width=0.6, unit="meV" + display_name="TestLorentzian", + area=-2.0, + center=0.5, + width=0.6, + unit="meV", ) @pytest.mark.parametrize( @@ -131,16 +139,16 @@ def test_evaluate(self, lorentzian: Lorentzian): def test_center_is_fixed_if_set_to_None(self): # WHEN THEN test_lorentzian = Lorentzian( - name="TestLorentzian", area=2.0, center=None, width=0.6, unit="meV" + display_name="TestLorentzian", area=2.0, center=None, width=0.6, unit="meV" ) # EXPECT assert test_lorentzian.center.value == 0.0 assert test_lorentzian.center.fixed is True - def test_get_parameters(self, lorentzian: Lorentzian): + def test_get_all_parameters(self, lorentzian: Lorentzian): # WHEN THEN - params = lorentzian.get_parameters() + params = lorentzian.get_all_parameters() # EXPECT assert len(params) == 3 @@ -182,7 +190,7 @@ def test_copy(self, lorentzian: Lorentzian): # EXPECT assert lorentzian_copy is not lorentzian - assert lorentzian_copy.name == lorentzian.name + assert lorentzian_copy.display_name == lorentzian.display_name assert lorentzian_copy.area.value == lorentzian.area.value assert lorentzian_copy.area.fixed == lorentzian.area.fixed @@ -201,7 +209,7 @@ def test_repr(self, lorentzian: Lorentzian): # EXPECT assert "Lorentzian" in repr_str - assert "name = TestLorentzian" in repr_str + assert "display_name = TestLorentzian" in repr_str assert "unit = meV" in repr_str assert "area =" in repr_str assert "center =" in repr_str diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index e4d0b6b..5ef4a18 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -16,7 +16,7 @@ def sample_model(self): name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) component2 = Lorentzian( - name="TestLorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" + display_name="TestLorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" ) model.add_component(component1) model.add_component(component2) From ce8df0e11aab347052b4e42484ce16e97d765a3b Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 10:30:44 +0100 Subject: [PATCH 25/44] update DHO --- .../components/damped_harmonic_oscillator.py | 75 ++++++++++++++----- .../test_damped_harmonic_oscillator.py | 22 +++--- 2 files changed, 69 insertions(+), 28 deletions(-) diff --git a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py index d1fd72d..3c6efe4 100644 --- a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py +++ b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Optional, Union +from typing import Union import numpy as np import scipp as sc @@ -27,31 +27,73 @@ class DampedHarmonicOscillator(CreateParametersMixin, ModelComponent): def __init__( self, - name: Optional[str] = "DampedHarmonicOscillator", - area: Optional[Union[Numeric, Parameter]] = 1.0, - center: Optional[Union[Numeric, Parameter]] = 1.0, - width: Optional[Union[Numeric, Parameter]] = 1.0, - unit: Optional[Union[str, sc.Unit]] = "meV", + display_name: str = "DampedHarmonicOscillator", + area: Numeric | Parameter = 1.0, + center: Numeric | Parameter = 1.0, + width: Numeric | Parameter = 1.0, + unit: str | sc.Unit = "meV", ): # Validate inputs and create Parameters if not given self.validate_unit(unit) self._unit = unit # These methods live in ValidationMixin - area = self._create_area_parameter(area=area, name=name, unit=self._unit) + area = self._create_area_parameter( + area=area, name=display_name, unit=self._unit + ) center = self._create_center_parameter( - center=center, name=name, fix_if_none=False, unit=self._unit + center=center, name=display_name, fix_if_none=False, unit=self._unit ) - width = self._create_width_parameter(width=width, name=name, unit=self._unit) + center.min = 0.0 # Enforce center >= 0 for DHO + width = self._create_width_parameter( + width=width, name=display_name, unit=self._unit + ) super().__init__( - name=name, + display_name=display_name, unit=unit, - area=area, - center=center, - width=width, ) + self._area = area + self._center = center + self._width = width + + @property + def area(self) -> Parameter: + """Get the area parameter.""" + return self._area + + @area.setter + def area(self, value: Numeric) -> None: + """Set the area parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("area must be a number") + self._area.value = value + + @property + def center(self) -> Parameter: + """Get the center parameter.""" + return self._center + + @center.setter + def center(self, value: Numeric) -> None: + """Set the center parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("center must be a number") + self._center.value = value + + @property + def width(self) -> Parameter: + """Get the width parameter.""" + return self._width + + @width.setter + def width(self, value: Numeric) -> None: + """Set the width parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("width must be a number") + self._width.value = value + def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] ) -> np.ndarray: @@ -62,13 +104,12 @@ def evaluate( x = self._prepare_x_for_evaluate(x) normalization = 2 * self.center.value**2 * self.width.value / np.pi + # No division by zero here, width>0 enforced in setter denominator = (x**2 - self.center.value**2) ** 2 + ( - 2 - * self.width.value - * x # No division by zero here, width>0 enforced in setter + 2 * self.width.value * x ) ** 2 return self.area.value * normalization / (denominator) def __repr__(self): - return f"DampedHarmonicOscillator(name = {self.name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" + return f"DampedHarmonicOscillator(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" diff --git a/tests/unit_tests/sample_model/components/test_damped_harmonic_oscillator.py b/tests/unit_tests/sample_model/components/test_damped_harmonic_oscillator.py index 6415ce4..2bc8aa4 100644 --- a/tests/unit_tests/sample_model/components/test_damped_harmonic_oscillator.py +++ b/tests/unit_tests/sample_model/components/test_damped_harmonic_oscillator.py @@ -12,7 +12,7 @@ class TestDampedHarmonicOscillator: @pytest.fixture def dho(self): return DampedHarmonicOscillator( - name="TestDHO", area=2.0, center=1.5, width=0.3, unit="meV" + display_name="TestDHO", area=2.0, center=1.5, width=0.3, unit="meV" ) def test_init_no_inputs(self): @@ -20,7 +20,7 @@ def test_init_no_inputs(self): dho = DampedHarmonicOscillator() # EXPECT - assert dho.name == "DampedHarmonicOscillator" + assert dho.display_name == "DampedHarmonicOscillator" assert dho.area.value == 1.0 assert dho.center.value == 1.0 assert dho.width.value == 1.0 @@ -28,7 +28,7 @@ def test_init_no_inputs(self): def test_initialization(self, dho: DampedHarmonicOscillator): # WHEN THEN EXPECT - assert dho.name == "TestDHO" + assert dho.display_name == "TestDHO" assert dho.area.value == 2.0 assert dho.center.value == 1.5 assert dho.width.value == 0.3 @@ -42,7 +42,7 @@ def test_init_with_parameters(self): # THEN dho = DampedHarmonicOscillator( - name="Paramdho", + display_name="Paramdho", area=area_param, center=center_param, width=width_param, @@ -50,7 +50,7 @@ def test_init_with_parameters(self): ) # EXPECT - assert dho.name == "Paramdho" + assert dho.display_name == "Paramdho" assert dho.area is area_param assert dho.center is center_param assert dho.width is width_param @@ -79,7 +79,7 @@ def test_init_with_parameters(self): ) def test_input_type_validation_raises(self, kwargs, expected_message): with pytest.raises(TypeError, match=expected_message): - DampedHarmonicOscillator(name="DampedHarmonicOscillator", **kwargs) + DampedHarmonicOscillator(display_name="DampedHarmonicOscillator", **kwargs) def test_negative_width_raises(self): # WHEN THEN EXPECT @@ -88,7 +88,7 @@ def test_negative_width_raises(self): match="The width of a DampedHarmonicOscillator must be greater than zero.", ): DampedHarmonicOscillator( - name="TestDampedHarmonicOscillator", + display_name="TestDampedHarmonicOscillator", area=2.0, center=0.5, width=-0.6, @@ -99,7 +99,7 @@ def test_negative_area_warns(self): # WHEN THEN EXPECT with pytest.warns(UserWarning, match="may not be physically meaningful"): DampedHarmonicOscillator( - name="TestDampedHarmonicOscillator", + display_name="TestDampedHarmonicOscillator", area=-2.0, center=0.5, width=0.6, @@ -148,9 +148,9 @@ def test_evaluate(self, dho: DampedHarmonicOscillator): ) np.testing.assert_allclose(result, expected_result, rtol=1e-5) - def test_get_parameters(self, dho: DampedHarmonicOscillator): + def test_get_all_parameters(self, dho: DampedHarmonicOscillator): # WHEN THEN - params = dho.get_parameters() + params = dho.get_all_parameters() # EXPECT assert len(params) == 3 @@ -192,7 +192,7 @@ def test_copy(self, dho: DampedHarmonicOscillator): # EXPECT assert dho_copy is not dho - assert dho_copy.name == dho.name + assert dho_copy.display_name == dho.display_name assert dho_copy.area.value == dho.area.value assert dho_copy.area.fixed == dho.area.fixed From 6ade763c711d72206f55d1b8a87d243e49853c0d Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 13:12:29 +0100 Subject: [PATCH 26/44] update delta function --- .../sample_model/components/delta_function.py | 53 ++++++++++++++----- .../sample_model/components/gaussian.py | 2 +- .../components/test_delta_function.py | 22 ++++---- 3 files changed, 54 insertions(+), 23 deletions(-) diff --git a/src/easydynamics/sample_model/components/delta_function.py b/src/easydynamics/sample_model/components/delta_function.py index bb9317a..b8fb7d2 100644 --- a/src/easydynamics/sample_model/components/delta_function.py +++ b/src/easydynamics/sample_model/components/delta_function.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Optional, Union +from typing import Union import numpy as np import scipp as sc @@ -21,7 +21,7 @@ class DeltaFunction(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - name (str): Name of the component. + display_name (str): Name of the component. center (Int or float or None): Center of the delta function. If None, defaults to 0 and is fixed. area (Int or float): Total area under the curve. unit (str or sc.Unit): Unit of the parameters. Defaults to "meV". @@ -29,30 +29,57 @@ class DeltaFunction(CreateParametersMixin, ModelComponent): def __init__( self, - name: Optional[str] = "DeltaFunction", - center: Optional[Union[None, Numeric, Parameter]] = None, - area: Optional[Union[Numeric, Parameter]] = 1.0, - unit: Union[str, sc.Unit] = "meV", + display_name: str = "DeltaFunction", + center: None | Numeric | Parameter = None, + area: Numeric | Parameter = 1.0, + unit: str | sc.Unit = "meV", ): # Validate inputs and create Parameters if not given self.validate_unit(unit) self._unit = unit # These methods live in ValidationMixin - area = self._create_area_parameter(area=area, name=name, unit=self._unit) + area = self._create_area_parameter( + area=area, name=display_name, unit=self._unit + ) center = self._create_center_parameter( - center=center, name=name, fix_if_none=True, unit=self._unit + center=center, name=display_name, fix_if_none=True, unit=self._unit ) super().__init__( - name=name, + display_name=display_name, unit=unit, - area=area, - center=center, ) + self._area = area + self._center = center + + @property + def area(self) -> Parameter: + """Get the area parameter.""" + return self._area + + @area.setter + def area(self, value: Numeric) -> None: + """Set the area parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("area must be a number") + self._area.value = value + + @property + def center(self) -> Parameter: + """Get the center parameter.""" + return self._center + + @center.setter + def center(self, value: Numeric) -> None: + """Set the center parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("center must be a number") + self._center.value = value + def evaluate( - self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """Evaluate the Delta function at the given x values. The Delta function evaluates to zero everywhere, except at the center. Its numerical integral is equal to the area. @@ -88,4 +115,4 @@ def evaluate( return model def __repr__(self): - return f"DeltaFunction(name = {self.name}, unit = {self._unit},\n area = {self.area},\n center = {self.center}" + return f"DeltaFunction(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center}" diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index c4cc221..2805a39 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -17,7 +17,7 @@ class Gaussian(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - name (str): Name of the component. + display_name (str): Name of the component. area (Int, float or Parameter): Area of the Gaussian. center (Int, float, None or Parameter): Center of the Gaussian. If None, defaults to 0 and is fixed width (Int, float or Parameter): Standard deviation. diff --git a/tests/unit_tests/sample_model/components/test_delta_function.py b/tests/unit_tests/sample_model/components/test_delta_function.py index 9a78c06..c14ad38 100644 --- a/tests/unit_tests/sample_model/components/test_delta_function.py +++ b/tests/unit_tests/sample_model/components/test_delta_function.py @@ -12,14 +12,16 @@ class TestDeltaFunction: @pytest.fixture def delta_function(self): - return DeltaFunction(name="TestDeltaFunction", area=2.0, center=0.5, unit="meV") + return DeltaFunction( + display_name="TestDeltaFunction", area=2.0, center=0.5, unit="meV" + ) def test_init_no_inputs(self): # WHEN THEN delta_function = DeltaFunction() # EXPECT - assert delta_function.name == "DeltaFunction" + assert delta_function.display_name == "DeltaFunction" assert delta_function.area.value == 1.0 assert delta_function.center.value == 0.0 assert delta_function.unit == "meV" @@ -27,7 +29,7 @@ def test_init_no_inputs(self): def test_initialization(self, delta_function: DeltaFunction): # WHEN THEN EXPECT - assert delta_function.name == "TestDeltaFunction" + assert delta_function.display_name == "TestDeltaFunction" assert delta_function.area.value == 2.0 assert delta_function.center.value == 0.5 assert delta_function.unit == "meV" @@ -51,12 +53,14 @@ def test_initialization(self, delta_function: DeltaFunction): ) def test_input_type_validation_raises(self, kwargs, expected_message): with pytest.raises(TypeError, match=expected_message): - DeltaFunction(name="TestDeltaFunction", **kwargs) + DeltaFunction(display_name="TestDeltaFunction", **kwargs) def test_negative_area_warns(self): # WHEN THEN EXPECT with pytest.warns(UserWarning, match="may not be physically meaningful"): - DeltaFunction(name="TestDeltaFunction", area=-2.0, center=0.5, unit="meV") + DeltaFunction( + display_name="TestDeltaFunction", area=-2.0, center=0.5, unit="meV" + ) @pytest.mark.parametrize( "prop, valid_value, invalid_value, invalid_message", @@ -163,16 +167,16 @@ def test_evaluate_with_invalid_input_raises( def test_center_is_fixed_if_set_to_None(self): # WHEN THEN test_delta = DeltaFunction( - name="TestDeltaFunction", area=2.0, center=None, unit="meV" + display_name="TestDeltaFunction", area=2.0, center=None, unit="meV" ) # EXPECT assert test_delta.center.value == 0.0 assert test_delta.center.fixed is True - def test_get_parameters(self, delta_function: DeltaFunction): + def test_get_all_parameters(self, delta_function: DeltaFunction): # WHEN THEN - params = delta_function.get_parameters() + params = delta_function.get_all_parameters() # EXPECT assert len(params) == 2 @@ -199,7 +203,7 @@ def test_copy(self, delta_function: DeltaFunction): # EXPECT assert delta_copy is not delta_function - assert delta_copy.name == delta_function.name + assert delta_copy.display_name == delta_function.display_name assert delta_copy.area.value == delta_function.area.value assert delta_copy.area.fixed == delta_function.area.fixed From da2462cbcfdbc1af9868879ae037d1cc7b7bc213 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 13:32:29 +0100 Subject: [PATCH 27/44] Update voigt --- .../sample_model/components/voigt.py | 89 +++++++++++++++---- .../sample_model/components/test_voigt.py | 26 +++--- 2 files changed, 83 insertions(+), 32 deletions(-) diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index 74e1d57..7c62a1b 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Optional, Union +from typing import Union import numpy as np import scipp as sc @@ -11,7 +11,7 @@ from .model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int class Voigt(CreateParametersMixin, ModelComponent): @@ -20,7 +20,7 @@ class Voigt(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - name (str): Name of the component. + display_name (str): Name of the component. center (Int or float or None): Center of the Voigt profile. gaussian_width (Int or float): Standard deviation of the Gaussian part. lorentzian_width (Int or float): Half width at half max (HWHM) of the Lorentzian part. @@ -30,44 +30,95 @@ class Voigt(CreateParametersMixin, ModelComponent): def __init__( self, - name: Optional[str] = "Voigt", - area: Optional[Union[Numeric, Parameter]] = 1.0, - center: Optional[Union[Numeric, Parameter, None]] = None, - gaussian_width: Optional[Union[Numeric, Parameter]] = 1.0, - lorentzian_width: Optional[Union[Numeric, Parameter]] = 1.0, - unit: Optional[Union[str, sc.Unit]] = "meV", + display_name: str = "Voigt", + area: Numeric | Parameter = 1.0, + center: Numeric | Parameter | None = None, + gaussian_width: Numeric | Parameter = 1.0, + lorentzian_width: Numeric | Parameter = 1.0, + unit: str | sc.Unit = "meV", ): # Validate inputs and create Parameters if not given self.validate_unit(unit) self._unit = unit # These methods live in ValidationMixin - area = self._create_area_parameter(area=area, name=name, unit=self._unit) + area = self._create_area_parameter( + area=area, name=display_name, unit=self._unit + ) center = self._create_center_parameter( - center=center, name=name, fix_if_none=True, unit=self._unit + center=center, name=display_name, fix_if_none=True, unit=self._unit ) gaussian_width = self._create_width_parameter( width=gaussian_width, - name=name, + name=display_name, param_name="gaussian_width", unit=self._unit, ) lorentzian_width = self._create_width_parameter( width=lorentzian_width, - name=name, + name=display_name, param_name="lorentzian_width", unit=self._unit, ) super().__init__( - name=name, + display_name=display_name, unit=unit, - area=area, - center=center, - gaussian_width=gaussian_width, - lorentzian_width=lorentzian_width, ) + self._area = area + self._center = center + self._gaussian_width = gaussian_width + self._lorentzian_width = lorentzian_width + + @property + def area(self) -> Parameter: + """Get the area parameter.""" + return self._area + + @area.setter + def area(self, value: Numeric) -> None: + """Set the area parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("area must be a number") + self._area.value = value + + @property + def center(self) -> Parameter: + """Get the center parameter.""" + return self._center + + @center.setter + def center(self, value: Numeric) -> None: + """Set the center parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("center must be a number") + self._center.value = value + + @property + def gaussian_width(self) -> Parameter: + """Get the width parameter.""" + return self._gaussian_width + + @gaussian_width.setter + def gaussian_width(self, value: Numeric) -> None: + """Set the width parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("gaussian_width must be a number") + self._gaussian_width.value = value + + @property + def lorentzian_width(self) -> Parameter: + """Get the width parameter.""" + return self._lorentzian_width + + @lorentzian_width.setter + def lorentzian_width(self, value: Numeric) -> None: + """Set the width parameter value.""" + if not isinstance(value, Numeric): + raise TypeError("lorentzian_width must be a number") + self._lorentzian_width.value = value + def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] ) -> np.ndarray: @@ -84,4 +135,4 @@ def evaluate( ) def __repr__(self): - return f"Voigt(name = {self.name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n gaussian_width = {self.gaussian_width},\n lorentzian_width = {self.lorentzian_width})" + return f"Voigt(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n gaussian_width = {self.gaussian_width},\n lorentzian_width = {self.lorentzian_width})" diff --git a/tests/unit_tests/sample_model/components/test_voigt.py b/tests/unit_tests/sample_model/components/test_voigt.py index 9b59b9d..842adec 100644 --- a/tests/unit_tests/sample_model/components/test_voigt.py +++ b/tests/unit_tests/sample_model/components/test_voigt.py @@ -13,7 +13,7 @@ class TestVoigt: @pytest.fixture def voigt(self): return Voigt( - name="TestVoigt", + display_name="TestVoigt", area=2.0, center=0.5, gaussian_width=0.6, @@ -26,7 +26,7 @@ def test_init_no_inputs(self): voigt = Voigt() # EXPECT - assert voigt.name == "Voigt" + assert voigt.display_name == "Voigt" assert voigt.area.value == 1.0 assert voigt.center.value == 0.0 assert voigt.gaussian_width.value == 1.0 @@ -36,7 +36,7 @@ def test_init_no_inputs(self): def test_initialization(self, voigt: Voigt): # WHEN THEN EXPECT - assert voigt.name == "TestVoigt" + assert voigt.display_name == "TestVoigt" assert voigt.area.value == 2.0 assert voigt.center.value == 0.5 assert voigt.gaussian_width.value == 0.6 @@ -56,7 +56,7 @@ def test_init_with_parameters(self): # THEN voigt = Voigt( - name="ParamVoigt", + display_name="ParamVoigt", area=area_param, center=center_param, gaussian_width=gaussian_width_param, @@ -65,7 +65,7 @@ def test_init_with_parameters(self): ) # EXPECT - assert voigt.name == "ParamVoigt" + assert voigt.display_name == "ParamVoigt" assert voigt.area is area_param assert voigt.center is center_param assert voigt.gaussian_width is gaussian_width_param @@ -129,7 +129,7 @@ def test_init_with_parameters(self): ) def test_input_type_validation_raises(self, kwargs, expected_message): with pytest.raises(TypeError, match=expected_message): - Voigt(name="TestVoigt", **kwargs) + Voigt(display_name="TestVoigt", **kwargs) def test_negative_gaussian_width_raises(self): # WHEN THEN EXPECT @@ -137,7 +137,7 @@ def test_negative_gaussian_width_raises(self): ValueError, match="The gaussian_width of a Voigt must be greater than." ): Voigt( - name="TestVoigt", + display_name="TestVoigt", area=2.0, center=0.5, gaussian_width=-0.6, @@ -152,7 +152,7 @@ def test_negative_lorentzian_width_raises(self): match="The lorentzian_width of a Voigt must be greater than zero.", ): Voigt( - name="TestVoigt", + display_name="TestVoigt", area=2.0, center=0.5, gaussian_width=0.6, @@ -164,7 +164,7 @@ def test_negative_area_warns(self): # WHEN THEN EXPECT with pytest.warns(UserWarning, match="may not be physically meaningful"): Voigt( - name="TestVoigt", + display_name="TestVoigt", area=-2.0, center=0.5, gaussian_width=0.6, @@ -211,7 +211,7 @@ def test_evaluate(self, voigt: Voigt): def test_center_is_fixed_if_set_to_None(self): # WHEN THEN test_voigt = Voigt( - name="TestVoigt", + display_name="TestVoigt", area=2.0, center=None, gaussian_width=0.6, @@ -234,9 +234,9 @@ def test_convert_unit(self, voigt: Voigt): assert voigt.gaussian_width.value == 0.6 * 1e3 assert voigt.lorentzian_width.value == 0.7 * 1e3 - def test_get_parameters(self, voigt: Voigt): + def test_get_all_parameters(self, voigt: Voigt): # WHEN THEN - params = voigt.get_parameters() + params = voigt.get_all_parameters() # EXPECT assert len(params) == 4 @@ -273,7 +273,7 @@ def test_copy(self, voigt: Voigt): # EXPECT assert voigt_copy is not voigt - assert voigt_copy.name == voigt.name + assert voigt_copy.display_name == voigt.display_name assert voigt_copy.area.value == voigt.area.value assert voigt_copy.area.fixed == voigt.area.fixed From 6d5a6af35063cad5f6bbee6b0de690b86cbaf6cd Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 13:53:16 +0100 Subject: [PATCH 28/44] Update Polynomial --- examples/components.ipynb | 143 ++++++++++++++++-- .../sample_model/components/polynomial.py | 53 +++++-- .../components/test_polynomial.py | 25 +-- .../sample_model/test_sample_model.py | 2 +- 4 files changed, 188 insertions(+), 35 deletions(-) diff --git a/examples/components.ipynb b/examples/components.ipynb index 26bb47c..8934b9e 100644 --- a/examples/components.ipynb +++ b/examples/components.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "64deaa41", "metadata": {}, "outputs": [], @@ -24,10 +24,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "784d9e82", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "871dd1cbaf504bb98a49f57058caf93f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Creating a component\n", "gaussian=Gaussian(display_name='Gaussian',width=0.5,area=1)\n", @@ -52,10 +78,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "2f57228c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Area under DHO curve: 1.9999\n" + ] + } + ], "source": [ "# The area under the DHO curve is indeed equal to the area parameter.\n", "xx=np.linspace(-15, 15, 10000)\n", @@ -67,10 +101,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "6c0929ed", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0f77dfda02854ca996138d5a3163e574", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.9999999999999999\n" + ] + } + ], "source": [ "delta = DeltaFunction(display_name='Delta', center=0.0, area=1.0)\n", "x1=np.linspace(-2, 2, 100)\n", @@ -91,10 +158,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "f44b125a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\henrikjacobsen3\\Documents\\easyScience\\dynamics-lib\\src\\easydynamics\\sample_model\\components\\model_component.py:93: UserWarning: Input x has unit µeV, but Polynomial component has unit meV. Converting Polynomial to µeV.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ad1df1c7a6554ee687a91e459e23645f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import scipp as sc\n", "x1=sc.linspace(dim='x', start=-2.0, stop=2.0, num=100, unit='meV')\n", @@ -110,6 +211,30 @@ "plt.legend()\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "74b9c667", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'Polynomial' object has no attribute 'name'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m a=Polynomial(display_name=\u001b[33m'\u001b[39m\u001b[33mPoly1\u001b[39m\u001b[33m'\u001b[39m,coefficients=[-\u001b[32m1.0\u001b[39m])\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[43ma\u001b[49m\u001b[43m.\u001b[49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m2.0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m#\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\Documents\\easyScience\\dynamics-lib\\src\\easydynamics\\sample_model\\components\\polynomial.py:135\u001b[39m, in \u001b[36mPolynomial.evaluate\u001b[39m\u001b[34m(self, x)\u001b[39m\n\u001b[32m 131\u001b[39m result += param.value * np.power(x, i)\n\u001b[32m 133\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(result < \u001b[32m0\u001b[39m):\n\u001b[32m 134\u001b[39m warnings.warn(\n\u001b[32m--> \u001b[39m\u001b[32m135\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mThe Polynomial with name \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m has negative values, \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 136\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mwhich may not be physically meaningful.\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 137\u001b[39m \u001b[38;5;167;01mUserWarning\u001b[39;00m,\n\u001b[32m 138\u001b[39m )\n\u001b[32m 139\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "\u001b[31mAttributeError\u001b[39m: 'Polynomial' object has no attribute 'name'" + ] + } + ], + "source": [ + "a=Polynomial(display_name='Poly1',coefficients=[-1.0])\n", + "a.evaluate(np.array([0.0, 1.0, 2.0])) #" + ] } ], "metadata": { diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 226c4ea..2368340 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -1,16 +1,16 @@ from __future__ import annotations import warnings -from typing import Optional, Sequence, Union +from typing import Sequence, Union import numpy as np import scipp as sc -from easyscience.variable import Parameter +from easyscience.variable import DescriptorBase, Parameter from scipp import UnitError from .model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int class Polynomial(ModelComponent): @@ -24,9 +24,9 @@ class Polynomial(ModelComponent): def __init__( self, - name: Optional[str] = "Polynomial", - coefficients: Optional[Sequence[Union[Numeric, Parameter]]] = (0.0,), - unit: Union[str, sc.Unit] = "meV", + display_name: str = "Polynomial", + coefficients: Sequence[Union[Numeric, Parameter]] = (0.0,), + unit: str | sc.Unit = "meV", ): self.validate_unit(unit) @@ -49,7 +49,7 @@ def __init__( if isinstance(coef, Parameter): param = coef elif isinstance(coef, Numeric): - param = Parameter(name=f"{name}_c{i}", value=float(coef)) + param = Parameter(name=f"{display_name}_c{i}", value=float(coef)) else: raise TypeError( "Each coefficient must be either a numeric value or a Parameter." @@ -60,7 +60,34 @@ def __init__( self._unit_conversion_helper = sc.scalar(value=1.0, unit=unit) # call parent with the Parameters - super().__init__(name=name, unit=unit, coefficients=self._coefficients) + super().__init__(display_name=display_name, unit=unit) + + @property + def coefficients(self) -> list[Parameter]: + """Get the coefficients of the polynomial as a list of Parameters.""" + return self._coefficients + + @coefficients.setter + def coefficients(self, coeffs: Sequence[Union[Numeric, Parameter]]) -> None: + """Replace the coefficients. Length must match current number of coefficients.""" + if not isinstance(coeffs, (list, tuple, np.ndarray)): + raise TypeError( + "coefficients must be a sequence (list/tuple/ndarray) of numbers or Parameter objects." + ) + if len(coeffs) != len(self._coefficients): + raise ValueError( + "Number of coefficients must match the existing number of coefficients." + ) + for i, coef in enumerate(coeffs): + if isinstance(coef, Parameter): + # replace parameter + self._coefficients[i] = coef + elif isinstance(coef, Numeric): + self._coefficients[i].value = float(coef) + else: + raise TypeError( + "Each coefficient must be either a numeric value or a Parameter." + ) @property def coefficient_values(self) -> list[float]: @@ -105,9 +132,9 @@ def evaluate( if any(result < 0): warnings.warn( - "The Polynomial with name {} has negative values, which may not be physically meaningful.".format( - self.name - ) + f"The Polynomial with name {self.display_name} has negative values, " + "which may not be physically meaningful.", + UserWarning, ) return result @@ -122,7 +149,7 @@ def degree(self, value: int) -> None: "The degree of the polynomial is determined by the number of coefficients and cannot be set directly." ) - def get_parameters(self) -> list[Parameter]: + def get_all_variables(self) -> list[DescriptorBase]: """ Get all parameters from the model component. Returns: @@ -156,7 +183,7 @@ def __repr__(self) -> str: coeffs_str = ", ".join( f"{param.name}={param.value}" for param in self._coefficients ) - return f"Polynomial(name = {self.name}, unit = {self._unit},\n coefficients = [{coeffs_str}])" + return f"Polynomial(display_name = {self.display_name}, unit = {self._unit},\n coefficients = [{coeffs_str}])" # from typing import Callable, Dict diff --git a/tests/unit_tests/sample_model/components/test_polynomial.py b/tests/unit_tests/sample_model/components/test_polynomial.py index 14ba18f..ef3c5da 100644 --- a/tests/unit_tests/sample_model/components/test_polynomial.py +++ b/tests/unit_tests/sample_model/components/test_polynomial.py @@ -10,20 +10,20 @@ class TestPolynomial: @pytest.fixture def polynomial(self): - return Polynomial(name="TestPolynomial", coefficients=[1.0, -2.0, 3.0]) + return Polynomial(display_name="TestPolynomial", coefficients=[1.0, -2.0, 3.0]) def test_init_no_inputs(self): # WHEN THEN polynomial = Polynomial() # EXPECT - assert polynomial.name == "Polynomial" + assert polynomial.display_name == "Polynomial" assert polynomial.coefficients[0].value == 0.0 assert polynomial.unit == "meV" def test_initialization(self, polynomial: Polynomial): # WHEN THEN EXPECT - assert polynomial.name == "TestPolynomial" + assert polynomial.display_name == "TestPolynomial" assert polynomial.coefficients[0].value == 1.0 assert polynomial.coefficients[1].value == -2.0 assert polynomial.coefficients[2].value == 3.0 @@ -47,7 +47,7 @@ def test_initialization(self, polynomial: Polynomial): ) def test_input_type_validation_raises(self, kwargs, expected_message): with pytest.raises(TypeError, match=expected_message): - Polynomial(name="TestPolynomial", **kwargs) + Polynomial(display_name="TestPolynomial", **kwargs) @pytest.mark.parametrize("invalid_coeffs", [[], None]) def test_no_coefficients_raises(self, invalid_coeffs): @@ -55,12 +55,13 @@ def test_no_coefficients_raises(self, invalid_coeffs): with pytest.raises( ValueError, match="At least one coefficient must be provided" ): - Polynomial(name="TestPolynomial", coefficients=invalid_coeffs) + Polynomial(display_name="TestPolynomial", coefficients=invalid_coeffs) def test_negative_value_warns_in_evaluate(self): - # WHEN THEN EXPECT + # WHEN THEN + test_polynomial = Polynomial(display_name="TestPolynomial", coefficients=[-1.0]) + # EXPECT with pytest.warns(UserWarning, match="may not be physically meaningful"): - test_polynomial = Polynomial(name="TestPolynomial", coefficients=[-1.0]) test_polynomial.evaluate(np.array([0.0, 1.0, 2.0])) def test_evaluate(self, polynomial: Polynomial): @@ -124,13 +125,13 @@ def test_set_coefficients_invalid_type_raises(self, polynomial: Polynomial): def test_set_coefficient_values_raises(self, invalid_coeffs, expected_message): with pytest.raises(TypeError, match=expected_message): polynomial = Polynomial( - name="TestPolynomial", coefficients=[1.0, -2.0, 3.0] + display_name="TestPolynomial", coefficients=[1.0, -2.0, 3.0] ) polynomial.coefficient_values = invalid_coeffs - def test_get_parameters(self, polynomial: Polynomial): + def test_get_all_parameters(self, polynomial: Polynomial): # WHEN THEN - params = polynomial.get_parameters() + params = polynomial.get_all_parameters() # EXPECT assert len(params) == 3 @@ -159,10 +160,10 @@ def test_copy(self, polynomial: Polynomial): # EXPECT assert polynomial_copy is not polynomial - assert polynomial_copy.name == polynomial.name + assert polynomial_copy.display_name == polynomial.display_name assert len(polynomial_copy.coefficients) == len(polynomial.coefficients) for original_coeff, copied_coeff in zip( - polynomial.get_parameters(), polynomial_copy.get_parameters() + polynomial.get_all_parameters(), polynomial_copy.get_all_parameters() ): assert copied_coeff.value == original_coeff.value assert copied_coeff.fixed == original_coeff.fixed diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 5ef4a18..aca4f86 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -230,7 +230,7 @@ def test_normalize_area_not_finite_area_raises(self, sample_model, area_value): def test_normalize_area_non_area_component_warns(self, sample_model): # WHEN component1 = Polynomial( - name="TestPolynomial", coefficients=[1, 2, 3], unit="meV" + display_name="TestPolynomial", coefficients=[1, 2, 3], unit="meV" ) sample_model.add_component(component1) From 6ccd646265ae51ed785d629d7a6471ed2ce28e73 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 13:57:50 +0100 Subject: [PATCH 29/44] Small updates to component docstrings --- examples/components.ipynb | 143 ++---------------- .../components/damped_harmonic_oscillator.py | 2 +- .../sample_model/components/lorentzian.py | 2 +- .../sample_model/components/polynomial.py | 2 + src/easydynamics/sample_model/sample_model.py | 14 +- .../sample_model/test_sample_model.py | 12 +- 6 files changed, 27 insertions(+), 148 deletions(-) diff --git a/examples/components.ipynb b/examples/components.ipynb index 8934b9e..26bb47c 100644 --- a/examples/components.ipynb +++ b/examples/components.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "64deaa41", "metadata": {}, "outputs": [], @@ -24,36 +24,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "784d9e82", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "871dd1cbaf504bb98a49f57058caf93f", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Creating a component\n", "gaussian=Gaussian(display_name='Gaussian',width=0.5,area=1)\n", @@ -78,18 +52,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "2f57228c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Area under DHO curve: 1.9999\n" - ] - } - ], + "outputs": [], "source": [ "# The area under the DHO curve is indeed equal to the area parameter.\n", "xx=np.linspace(-15, 15, 10000)\n", @@ -101,43 +67,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "6c0929ed", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0f77dfda02854ca996138d5a3163e574", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9999999999999999\n" - ] - } - ], + "outputs": [], "source": [ "delta = DeltaFunction(display_name='Delta', center=0.0, area=1.0)\n", "x1=np.linspace(-2, 2, 100)\n", @@ -158,44 +91,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "f44b125a", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\henrikjacobsen3\\Documents\\easyScience\\dynamics-lib\\src\\easydynamics\\sample_model\\components\\model_component.py:93: UserWarning: Input x has unit µeV, but Polynomial component has unit meV. Converting Polynomial to µeV.\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ad1df1c7a6554ee687a91e459e23645f", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import scipp as sc\n", "x1=sc.linspace(dim='x', start=-2.0, stop=2.0, num=100, unit='meV')\n", @@ -211,30 +110,6 @@ "plt.legend()\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "74b9c667", - "metadata": {}, - "outputs": [ - { - "ename": "AttributeError", - "evalue": "'Polynomial' object has no attribute 'name'", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m a=Polynomial(display_name=\u001b[33m'\u001b[39m\u001b[33mPoly1\u001b[39m\u001b[33m'\u001b[39m,coefficients=[-\u001b[32m1.0\u001b[39m])\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[43ma\u001b[49m\u001b[43m.\u001b[49m\u001b[43mevaluate\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43marray\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[32;43m0.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m2.0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m#\u001b[39;00m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\Documents\\easyScience\\dynamics-lib\\src\\easydynamics\\sample_model\\components\\polynomial.py:135\u001b[39m, in \u001b[36mPolynomial.evaluate\u001b[39m\u001b[34m(self, x)\u001b[39m\n\u001b[32m 131\u001b[39m result += param.value * np.power(x, i)\n\u001b[32m 133\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28many\u001b[39m(result < \u001b[32m0\u001b[39m):\n\u001b[32m 134\u001b[39m warnings.warn(\n\u001b[32m--> \u001b[39m\u001b[32m135\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mThe Polynomial with name \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m has negative values, \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 136\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mwhich may not be physically meaningful.\u001b[39m\u001b[33m\"\u001b[39m,\n\u001b[32m 137\u001b[39m \u001b[38;5;167;01mUserWarning\u001b[39;00m,\n\u001b[32m 138\u001b[39m )\n\u001b[32m 139\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "\u001b[31mAttributeError\u001b[39m: 'Polynomial' object has no attribute 'name'" - ] - } - ], - "source": [ - "a=Polynomial(display_name='Poly1',coefficients=[-1.0])\n", - "a.evaluate(np.array([0.0, 1.0, 2.0])) #" - ] } ], "metadata": { diff --git a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py index 3c6efe4..8099770 100644 --- a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py +++ b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py @@ -18,7 +18,7 @@ class DampedHarmonicOscillator(CreateParametersMixin, ModelComponent): Damped Harmonic Oscillator (DHO). 2*area*center^2*width/pi / ( (x^2 - center^2)^2 + (2*width*x)^2 ) Args: - name (str): Name of the component. + display_name (str): Display name of the component. center (Int or float): Resonance frequency, approximately the peak position. width (Int or float): Damping constant, approximately the half width at half max (HWHM) of the peaks. area (Int or float): Area under the curve. diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index 8b563f0..51aad17 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -19,7 +19,7 @@ class Lorentzian(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - name (str): Name of the component. + display_name (str): Display name of the component. area (Int, float or Parameter): Area of the Lorentzian. center (Int, float, None or Parameter): Peak center. If None, defaults to 0 and is fixed. width (Int, float or Parameter): Half Width at Half Maximum (HWHM) diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 2368340..59bda05 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -18,8 +18,10 @@ class Polynomial(ModelComponent): Polynomial function component. c0 + c1*x + c2*x^2 + ... + cN*x^N Args: + display_name (str): Display name of the Polynomial component. coefficients (list or tuple): Coefficients c0, c1, ..., cN representing f(x) = c0 + c1*x + c2*x^2 + ... + cN*x^N + unit (str or sc.Unit): Unit of the Polynomial component. """ def __init__( diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index 9e10302..c276e3b 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -3,22 +3,24 @@ import numpy as np import scipp as sc + +# from easyscience.job.theoreticalmodel import TheoreticalModelBase +from easyscience.base_classes.model_base import ModelBase from easyscience.global_object.undo_redo import NotarizedDict -from easyscience.job.theoreticalmodel import TheoreticalModelBase from .components.model_component import ModelComponent Numeric = Union[float, int] -class SampleModel(TheoreticalModelBase): +class SampleModel(ModelBase): """ A model of the scattering from a sample, combining multiple model components. Attributes ---------- - name : str - Name of the SampleModel. + display_name : str + Display name of the SampleModel. unit : str or sc.Unit Unit of the SampleModel. @@ -26,7 +28,7 @@ class SampleModel(TheoreticalModelBase): def __init__( self, - name: str = "MySampleModel", + display_name: str = "MySampleModel", unit: Optional[Union[str, sc.Unit]] = "meV", **kwargs, ): @@ -43,7 +45,7 @@ def __init__( Initial model components to add to the SampleModel. Keys are component names, values are ModelComponent instances. """ - super().__init__(name=name) + super().__init__(name=display_name) if not isinstance(self._kwargs, NotarizedDict): self._kwargs = NotarizedDict() diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index aca4f86..26daf05 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -11,7 +11,7 @@ class TestSampleModel: @pytest.fixture def sample_model(self): - model = SampleModel(name="TestSampleModel") + model = SampleModel(display_name="TestSampleModel") component1 = Gaussian( name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) @@ -24,7 +24,7 @@ def sample_model(self): def test_init(self): # WHEN THEN - sample_model = SampleModel(name="InitModel") + sample_model = SampleModel(display_name="InitModel") # EXPECT assert sample_model.name == "InitModel" @@ -146,7 +146,7 @@ def test_evaluate(self, sample_model): def test_evaluate_no_components_raises(self): # WHEN THEN - sample_model = SampleModel(name="EmptyModel") + sample_model = SampleModel(display_name="EmptyModel") x = np.linspace(-5, 5, 100) # EXPECT with pytest.raises(ValueError, match="No components in the model to evaluate."): @@ -176,7 +176,7 @@ def test_evaluate_nonexistent_component_raises(self, sample_model): def test_evaluate_component_no_components_raises(self): # WHEN THEN - sample_model = SampleModel(name="EmptyModel") + sample_model = SampleModel(display_name="EmptyModel") x = np.linspace(-5, 5, 100) # EXPECT with pytest.raises(ValueError, match="No components in the model to evaluate."): @@ -206,7 +206,7 @@ def test_normalize_area(self, sample_model): def test_normalize_area_no_components_raises(self): # WHEN THEN - sample_model = SampleModel(name="EmptyModel") + sample_model = SampleModel(display_name="EmptyModel") # EXPECT with pytest.raises( ValueError, match="No components in the model to normalize." @@ -257,7 +257,7 @@ def test_get_parameters(self, sample_model): assert all(isinstance(param, Parameter) for param in parameters) def test_get_parameters_no_components(self): - sample_model = SampleModel(name="EmptyModel") + sample_model = SampleModel(display_name="EmptyModel") # WHEN THEN parameters = sample_model.get_parameters() # EXPECT From cdd208b6b9d23b71d3878b22f3b2c79bf4f1c698 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Thu, 11 Dec 2025 16:35:06 +0100 Subject: [PATCH 30/44] Update sample_model --- src/easydynamics/sample_model/sample_model.py | 107 ++++++++---------- .../sample_model/test_sample_model.py | 37 +++--- 2 files changed, 66 insertions(+), 78 deletions(-) diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/sample_model.py index c276e3b..80ca577 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/sample_model.py @@ -6,7 +6,7 @@ # from easyscience.job.theoreticalmodel import TheoreticalModelBase from easyscience.base_classes.model_base import ModelBase -from easyscience.global_object.undo_redo import NotarizedDict +from easyscience.variable import DescriptorBase from .components.model_component import ModelComponent @@ -29,8 +29,8 @@ class SampleModel(ModelBase): def __init__( self, display_name: str = "MySampleModel", - unit: Optional[Union[str, sc.Unit]] = "meV", - **kwargs, + unit: str | sc.Unit = "meV", + components: List[ModelComponent] = [], ): """ Initialize a new SampleModel. @@ -45,62 +45,45 @@ def __init__( Initial model components to add to the SampleModel. Keys are component names, values are ModelComponent instances. """ - super().__init__(name=display_name) - if not isinstance(self._kwargs, NotarizedDict): - self._kwargs = NotarizedDict() + super().__init__(display_name=display_name) self._unit = unit self._components = [] # Add initial components if provided. Used for serialization. - for key, comp in list(kwargs.items()): - self._add_component(key, comp) - - def add_component( - self, component: ModelComponent, name: Optional[str] = None - ) -> None: - """ - Add a model component to the SampleModel. Component names must be unique. - Parameters - ---------- - component : ModelComponent - The model component to add. - name : str, optional - Name to assign to the component. If None, uses the component's own name. Renames the component if a different name is provided. - """ + if components: + for comp in components: + self.add_component(comp) + def add_component(self, component: ModelComponent) -> None: if not isinstance(component, ModelComponent): raise TypeError("Component must be an instance of ModelComponent.") - if name is None: - name = component.name + if component in self._components: + raise ValueError(f"Component '{component.display_name}' already added.") - if not isinstance(name, str): - raise TypeError("Component name must be a string.") - if name in getattr(self, "_kwargs", {}): - raise ValueError(f"Component with name '{name}' already exists.") + for comp in self._components: + if comp.display_name == component.display_name: + raise ValueError( + f"A component with the name '{component.display_name}' already exists." + ) - # Use ObjBase to add component so Global Object is updated correctly - self._add_component(name, component) + self._components.append(component) def remove_component(self, name: str) -> None: - """ - Remove a model component from the SampleModel by name. - Parameters - ---------- - name : str - Name of the component to remove. - """ - if not isinstance(name, str): raise TypeError("Component name must be a string.") - for key, item in list(self._kwargs.items()): - if item.name == name: - del self._kwargs[key] + for comp in self._components: + if comp.display_name == name: + self._components.remove(comp) return - raise KeyError(f"No component named '{name}' exists in the model.") + raise KeyError(f"No component named '{name}' exists.") + + @property + def components(self) -> list[ModelComponent]: + return list(self._components) def list_component_names(self) -> List[str]: """ @@ -112,12 +95,11 @@ def list_component_names(self) -> List[str]: Component names. """ - return [item.name for item in self.components] + return [component.display_name for component in self.components] def clear_components(self) -> None: """Remove all components.""" - for key in list(self._kwargs.keys()): - del self._kwargs[key] + self._components.clear() def normalize_area(self) -> None: # Useful for convolutions. @@ -136,7 +118,8 @@ def normalize_area(self) -> None: total_area += component.area.value else: warnings.warn( - f"Component '{component.name}' does not have an 'area' attribute and will be skipped in normalization." + f"Component '{component.display_name}' does not have an 'area' attribute and will be skipped in normalization.", + UserWarning, ) if total_area == 0: @@ -148,16 +131,18 @@ def normalize_area(self) -> None: for param in area_params: param.value /= total_area - @property - def components(self) -> List[ModelComponent]: + def get_all_variables(self) -> list[DescriptorBase]: """ - Get the list of model components in the SampleModel. - Returns - ------- - List[ModelComponent] - List of model components. + Get all parameters from the model component. + Returns: + List[Parameter]: List of parameters in the component. """ - return list(self._kwargs.values()) + + return [ + var + for component in self.components + for var in component.get_all_variables() + ] @property def unit(self) -> Optional[Union[str, sc.Unit]]: @@ -222,7 +207,7 @@ def evaluate( def evaluate_component( self, - x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray], + x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray, name: str, ) -> np.ndarray: """ @@ -248,7 +233,7 @@ def evaluate_component( (f"Component name must be a string, got {type(name)} instead.") ) - matches = [comp for comp in self.components if comp.name == name] + matches = [comp for comp in self.components if comp.display_name == name] if not matches: raise KeyError(f"No component named '{name}' exists.") @@ -262,14 +247,14 @@ def fix_all_parameters(self) -> None: """ Fix all free parameters in the model. """ - for param in self.get_parameters(): + for param in self.get_all_parameters(): param.fixed = True def free_all_parameters(self) -> None: """ Free all fixed parameters in the model. """ - for param in self.get_parameters(): + for param in self.get_all_parameters(): param.fixed = False def __contains__(self, item: Union[str, ModelComponent]) -> bool: @@ -287,7 +272,7 @@ def __contains__(self, item: Union[str, ModelComponent]) -> bool: if isinstance(item, str): # Check by component name - return any(comp.name == item for comp in self.components) + return any(comp.display_name == item for comp in self.components) elif isinstance(item, ModelComponent): # Check by component instance return any(comp is item for comp in self.components) @@ -302,6 +287,8 @@ def __repr__(self) -> str: ------- str """ - comp_names = ", ".join(c.name for c in self.components) or "No components" + comp_names = ( + ", ".join(c.display_name for c in self.components) or "No components" + ) - return f"" + return f"" diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_sample_model.py index 26daf05..ce66c0c 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_sample_model.py @@ -13,7 +13,7 @@ class TestSampleModel: def sample_model(self): model = SampleModel(display_name="TestSampleModel") component1 = Gaussian( - name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" + display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) component2 = Lorentzian( display_name="TestLorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" @@ -27,7 +27,7 @@ def test_init(self): sample_model = SampleModel(display_name="InitModel") # EXPECT - assert sample_model.name == "InitModel" + assert sample_model.display_name == "InitModel" assert sample_model.components == [] # ───── Component Management ───── @@ -35,7 +35,7 @@ def test_init(self): def test_add_component(self, sample_model): # WHEN component = Gaussian( - name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" + display_name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) # THEN sample_model.add_component(component) @@ -45,7 +45,7 @@ def test_add_component(self, sample_model): def test_add_duplicate_component_raises(self, sample_model): # WHEN THEN component = Gaussian( - name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" + display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) # EXPECT with pytest.raises(ValueError, match="already exists"): @@ -74,7 +74,7 @@ def test_remove_nonexistent_component_raises(self, sample_model): def test_getitem(self, sample_model): # WHEN component = Gaussian( - name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" + display_name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) # THEN sample_model.add_component(component) @@ -110,12 +110,13 @@ def convert_unit(self, unit: str) -> None: raise RuntimeError("Conversion failed.") faulty_component = FaultyComponent( - name="FaultyComponent", area=1.0, center=0.0, width=1.0, unit="meV" + display_name="FaultyComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) sample_model.add_component(faulty_component) original_units = { - component.name: component.unit for component in sample_model.components + component.display_name: component.unit + for component in sample_model.components } # EXPECT @@ -124,7 +125,7 @@ def convert_unit(self, unit: str) -> None: # Check that all components have their original units for component in sample_model.components: - assert component.unit == original_units[component.name] + assert component.unit == original_units[component.display_name] def test_set_unit(self, sample_model): # WHEN THEN EXPECT @@ -238,9 +239,9 @@ def test_normalize_area_non_area_component_warns(self, sample_model): with pytest.warns(UserWarning, match="does not have an 'area' "): sample_model.normalize_area() - def test_get_parameters(self, sample_model): + def test_get_all_parameters(self, sample_model): # WHEN THEN - parameters = sample_model.get_parameters() + parameters = sample_model.get_all_parameters() # EXPECT assert len(parameters) == 6 @@ -259,7 +260,7 @@ def test_get_parameters(self, sample_model): def test_get_parameters_no_components(self): sample_model = SampleModel(display_name="EmptyModel") # WHEN THEN - parameters = sample_model.get_parameters() + parameters = sample_model.get_all_parameters() # EXPECT assert len(parameters) == 0 @@ -294,14 +295,14 @@ def test_fix_and_free_all_parameters(self, sample_model): sample_model.fix_all_parameters() # EXPECT - for param in sample_model.get_parameters(): + for param in sample_model.get_all_parameters(): assert param.fixed is True # WHEN sample_model.free_all_parameters() # THEN - for param in sample_model.get_parameters(): + for param in sample_model.get_all_parameters(): assert param.fixed is False def test_contains(self, sample_model): @@ -316,7 +317,7 @@ def test_contains(self, sample_model): assert lorentzian_component in sample_model fake_component = Gaussian( - name="FakeGaussian", area=1.0, center=0.0, width=1.0, unit="meV" + display_name="FakeGaussian", area=1.0, center=0.0, width=1.0, unit="meV" ) assert fake_component not in sample_model @@ -333,16 +334,16 @@ def test_copy(self, sample_model): model_copy = copy(sample_model) # EXPECT assert model_copy is not sample_model - assert model_copy.name == sample_model.name + assert model_copy.display_name == sample_model.display_name assert len(model_copy.components) == len(sample_model.components) for comp in sample_model.components: copied_comp = model_copy.components[ - model_copy.list_component_names().index(comp.name) + model_copy.list_component_names().index(comp.display_name) ] assert copied_comp is not comp - assert copied_comp.name == comp.name + assert copied_comp.display_name == comp.display_name for param_orig, param_copy in zip( - comp.get_parameters(), copied_comp.get_parameters() + comp.get_all_parameters(), copied_comp.get_all_parameters() ): assert param_copy is not param_orig assert param_copy.name == param_orig.name From 7a5dd452ddcfc23fd39bb4b2f0f9084f3b1d7d65 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 12 Dec 2025 05:57:55 +0100 Subject: [PATCH 31/44] rename to ComponentCollection --- src/easydynamics/sample_model/__init__.py | 4 +- ...ample_model.py => component_collection.py} | 22 +- ..._model.py => test_component_collection.py} | 205 +++++++++--------- 3 files changed, 119 insertions(+), 112 deletions(-) rename src/easydynamics/sample_model/{sample_model.py => component_collection.py} (92%) rename tests/unit_tests/sample_model/{test_sample_model.py => test_component_collection.py} (53%) diff --git a/src/easydynamics/sample_model/__init__.py b/src/easydynamics/sample_model/__init__.py index 2b1274f..875020f 100644 --- a/src/easydynamics/sample_model/__init__.py +++ b/src/easydynamics/sample_model/__init__.py @@ -1,3 +1,4 @@ +from .component_collection import ComponentCollection from .components import ( DampedHarmonicOscillator, DeltaFunction, @@ -6,10 +7,9 @@ Polynomial, Voigt, ) -from .sample_model import SampleModel __all__ = [ - "SampleModel", + "ComponentCollection", "Gaussian", "Lorentzian", "Voigt", diff --git a/src/easydynamics/sample_model/sample_model.py b/src/easydynamics/sample_model/component_collection.py similarity index 92% rename from src/easydynamics/sample_model/sample_model.py rename to src/easydynamics/sample_model/component_collection.py index 80ca577..556bbfc 100644 --- a/src/easydynamics/sample_model/sample_model.py +++ b/src/easydynamics/sample_model/component_collection.py @@ -13,27 +13,27 @@ Numeric = Union[float, int] -class SampleModel(ModelBase): +class ComponentCollection(ModelBase): """ A model of the scattering from a sample, combining multiple model components. Attributes ---------- display_name : str - Display name of the SampleModel. + Display name of the ComponentCollection. unit : str or sc.Unit - Unit of the SampleModel. + Unit of the ComponentCollection. """ def __init__( self, - display_name: str = "MySampleModel", + display_name: str = "MyComponentCollection", unit: str | sc.Unit = "meV", components: List[ModelComponent] = [], ): """ - Initialize a new SampleModel. + Initialize a new ComponentCollection. Parameters ---------- @@ -42,7 +42,7 @@ def __init__( unit : str or sc.Unit, optional Unit of the sample model. Defaults to "meV". **kwargs : ModelComponent - Initial model components to add to the SampleModel. Keys are component names, values are ModelComponent instances. + Initial model components to add to the ComponentCollection. Keys are component names, values are ModelComponent instances. """ super().__init__(display_name=display_name) @@ -147,7 +147,7 @@ def get_all_variables(self) -> list[DescriptorBase]: @property def unit(self) -> Optional[Union[str, sc.Unit]]: """ - Get the unit of the SampleModel. + Get the unit of the ComponentCollection. Returns ------- @@ -166,7 +166,7 @@ def unit(self, unit_str: str) -> None: def convert_unit(self, unit: Union[str, sc.Unit]) -> None: """ - Convert the unit of the SampleModel and all its components. + Convert the unit of the ComponentCollection and all its components. """ old_unit = self._unit @@ -259,7 +259,7 @@ def free_all_parameters(self) -> None: def __contains__(self, item: Union[str, ModelComponent]) -> bool: """ - Check if a component with the given name or instance exists in the SampleModel. + Check if a component with the given name or instance exists in the ComponentCollection. Args: ---------- item : str or ModelComponent @@ -281,7 +281,7 @@ def __contains__(self, item: Union[str, ModelComponent]) -> bool: def __repr__(self) -> str: """ - Return a string representation of the SampleModel. + Return a string representation of the ComponentCollection. Returns ------- @@ -291,4 +291,4 @@ def __repr__(self) -> str: ", ".join(c.display_name for c in self.components) or "No components" ) - return f"" + return f"" diff --git a/tests/unit_tests/sample_model/test_sample_model.py b/tests/unit_tests/sample_model/test_component_collection.py similarity index 53% rename from tests/unit_tests/sample_model/test_sample_model.py rename to tests/unit_tests/sample_model/test_component_collection.py index ce66c0c..8171b59 100644 --- a/tests/unit_tests/sample_model/test_sample_model.py +++ b/tests/unit_tests/sample_model/test_component_collection.py @@ -5,13 +5,18 @@ from easyscience.variable import Parameter from scipy.integrate import simpson -from easydynamics.sample_model import Gaussian, Lorentzian, Polynomial, SampleModel +from easydynamics.sample_model import ( + ComponentCollection, + Gaussian, + Lorentzian, + Polynomial, +) -class TestSampleModel: +class TestComponentCollection: @pytest.fixture - def sample_model(self): - model = SampleModel(display_name="TestSampleModel") + def component_collection(self): + model = ComponentCollection(display_name="TestComponentCollection") component1 = Gaussian( display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) @@ -24,85 +29,85 @@ def sample_model(self): def test_init(self): # WHEN THEN - sample_model = SampleModel(display_name="InitModel") + component_collection = ComponentCollection(display_name="InitModel") # EXPECT - assert sample_model.display_name == "InitModel" - assert sample_model.components == [] + assert component_collection.display_name == "InitModel" + assert component_collection.components == [] # ───── Component Management ───── - def test_add_component(self, sample_model): + def test_add_component(self, component_collection): # WHEN component = Gaussian( display_name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) # THEN - sample_model.add_component(component) + component_collection.add_component(component) # EXPECT - assert sample_model.components[-1] is component + assert component_collection.components[-1] is component - def test_add_duplicate_component_raises(self, sample_model): + def test_add_duplicate_component_raises(self, component_collection): # WHEN THEN component = Gaussian( display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) # EXPECT with pytest.raises(ValueError, match="already exists"): - sample_model.add_component(component) + component_collection.add_component(component) - def test_add_invalid_component_raises(self, sample_model): + def test_add_invalid_component_raises(self, component_collection): # WHEN THEN EXPECT with pytest.raises( TypeError, match="Component must be an instance of ModelComponent." ): - sample_model.add_component("NotAComponent") + component_collection.add_component("NotAComponent") - def test_remove_component(self, sample_model): + def test_remove_component(self, component_collection): # WHEN THEN - sample_model.remove_component("TestGaussian1") + component_collection.remove_component("TestGaussian1") # EXPECT - assert "TestGaussian1" not in sample_model.components + assert "TestGaussian1" not in component_collection.components - def test_remove_nonexistent_component_raises(self, sample_model): + def test_remove_nonexistent_component_raises(self, component_collection): # WHEN THEN EXPECT with pytest.raises( KeyError, match="No component named 'NonExistentComponent' exists" ): - sample_model.remove_component("NonExistentComponent") + component_collection.remove_component("NonExistentComponent") - def test_getitem(self, sample_model): + def test_getitem(self, component_collection): # WHEN component = Gaussian( display_name="TestComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) # THEN - sample_model.add_component(component) + component_collection.add_component(component) # EXPECT - assert sample_model.components[-1] is component + assert component_collection.components[-1] is component - def test_list_component_names(self, sample_model): + def test_list_component_names(self, component_collection): # WHEN THEN - components = sample_model.list_component_names() + components = component_collection.list_component_names() # EXPECT assert len(components) == 2 assert components[0] == "TestGaussian1" assert components[1] == "TestLorentzian1" - def test_clear_components(self, sample_model): + def test_clear_components(self, component_collection): # WHEN THEN - sample_model.clear_components() + component_collection.clear_components() # EXPECT - assert len(sample_model.components) == 0 + assert len(component_collection.components) == 0 - def test_convert_unit(self, sample_model): + def test_convert_unit(self, component_collection): # WHEN THEN - sample_model.convert_unit("eV") + component_collection.convert_unit("eV") # EXPECT - for component in sample_model.components: + for component in component_collection.components: assert component.unit == "eV" - def test_convert_unit_failure_rolls_back(self, sample_model): + def test_convert_unit_failure_rolls_back(self, component_collection): # WHEN THEN # Introduce a faulty component that will fail conversion class FaultyComponent(Gaussian): @@ -112,60 +117,60 @@ def convert_unit(self, unit: str) -> None: faulty_component = FaultyComponent( display_name="FaultyComponent", area=1.0, center=0.0, width=1.0, unit="meV" ) - sample_model.add_component(faulty_component) + component_collection.add_component(faulty_component) original_units = { component.display_name: component.unit - for component in sample_model.components + for component in component_collection.components } # EXPECT with pytest.raises(RuntimeError, match="Conversion failed."): - sample_model.convert_unit("eV") + component_collection.convert_unit("eV") # Check that all components have their original units - for component in sample_model.components: + for component in component_collection.components: assert component.unit == original_units[component.display_name] - def test_set_unit(self, sample_model): + def test_set_unit(self, component_collection): # WHEN THEN EXPECT with pytest.raises( AttributeError, match="Unit is read-only. Use convert_unit to change the unit", ): - sample_model.unit = "eV" + component_collection.unit = "eV" - def test_evaluate(self, sample_model): + def test_evaluate(self, component_collection): # WHEN x = np.linspace(-5, 5, 100) - result = sample_model.evaluate(x) + result = component_collection.evaluate(x) # EXPECT - expected_result = sample_model.components[0].evaluate( + expected_result = component_collection.components[0].evaluate( x - ) + sample_model.components[1].evaluate(x) + ) + component_collection.components[1].evaluate(x) np.testing.assert_allclose(result, expected_result, rtol=1e-5) def test_evaluate_no_components_raises(self): # WHEN THEN - sample_model = SampleModel(display_name="EmptyModel") + component_collection = ComponentCollection(display_name="EmptyModel") x = np.linspace(-5, 5, 100) # EXPECT with pytest.raises(ValueError, match="No components in the model to evaluate."): - sample_model.evaluate(x) + component_collection.evaluate(x) - def test_evaluate_component(self, sample_model): + def test_evaluate_component(self, component_collection): # WHEN THEN x = np.linspace(-5, 5, 100) - result1 = sample_model.evaluate_component(x, "TestGaussian1") - result2 = sample_model.evaluate_component(x, "TestLorentzian1") + result1 = component_collection.evaluate_component(x, "TestGaussian1") + result2 = component_collection.evaluate_component(x, "TestLorentzian1") # EXPECT - expected_result1 = sample_model.components[0].evaluate(x) - expected_result2 = sample_model.components[1].evaluate(x) + expected_result1 = component_collection.components[0].evaluate(x) + expected_result2 = component_collection.components[1].evaluate(x) np.testing.assert_allclose(result1, expected_result1, rtol=1e-5) np.testing.assert_allclose(result2, expected_result2, rtol=1e-5) - def test_evaluate_nonexistent_component_raises(self, sample_model): + def test_evaluate_nonexistent_component_raises(self, component_collection): # WHEN x = np.linspace(-5, 5, 100) @@ -173,17 +178,17 @@ def test_evaluate_nonexistent_component_raises(self, sample_model): with pytest.raises( KeyError, match="No component named 'NonExistentComponent' exists" ): - sample_model.evaluate_component(x, "NonExistentComponent") + component_collection.evaluate_component(x, "NonExistentComponent") def test_evaluate_component_no_components_raises(self): # WHEN THEN - sample_model = SampleModel(display_name="EmptyModel") + component_collection = ComponentCollection(display_name="EmptyModel") x = np.linspace(-5, 5, 100) # EXPECT with pytest.raises(ValueError, match="No components in the model to evaluate."): - sample_model.evaluate_component(x, "AnyComponent") + component_collection.evaluate_component(x, "AnyComponent") - def test_evaluate_component_invalid_name_type_raises(self, sample_model): + def test_evaluate_component_invalid_name_type_raises(self, component_collection): # WHEN x = np.linspace(-5, 5, 100) @@ -192,56 +197,58 @@ def test_evaluate_component_invalid_name_type_raises(self, sample_model): TypeError, match="Component name must be a string, got instead.", ): - sample_model.evaluate_component(x, 123) + component_collection.evaluate_component(x, 123) # ───── Utilities ───── - def test_normalize_area(self, sample_model): + def test_normalize_area(self, component_collection): # WHEN THEN - sample_model.normalize_area() + component_collection.normalize_area() # EXPECT x = np.linspace(-10000, 10000, 1000000) # Lorentzians have long tails - result = sample_model.evaluate(x) + result = component_collection.evaluate(x) numerical_area = simpson(result, x) assert np.isclose(numerical_area, 1.0, rtol=1e-4) def test_normalize_area_no_components_raises(self): # WHEN THEN - sample_model = SampleModel(display_name="EmptyModel") + component_collection = ComponentCollection(display_name="EmptyModel") # EXPECT with pytest.raises( ValueError, match="No components in the model to normalize." ): - sample_model.normalize_area() + component_collection.normalize_area() @pytest.mark.parametrize( "area_value", [np.nan, 0.0, np.inf], ids=["NaN area", "Zero area", "Infinite area"], ) - def test_normalize_area_not_finite_area_raises(self, sample_model, area_value): + def test_normalize_area_not_finite_area_raises( + self, component_collection, area_value + ): # WHEN THEN - sample_model.components[0].area = area_value - sample_model.components[1].area = area_value + component_collection.components[0].area = area_value + component_collection.components[1].area = area_value # EXPECT with pytest.raises(ValueError, match="cannot normalize."): - sample_model.normalize_area() + component_collection.normalize_area() - def test_normalize_area_non_area_component_warns(self, sample_model): + def test_normalize_area_non_area_component_warns(self, component_collection): # WHEN component1 = Polynomial( display_name="TestPolynomial", coefficients=[1, 2, 3], unit="meV" ) - sample_model.add_component(component1) + component_collection.add_component(component1) # THEN EXPECT with pytest.warns(UserWarning, match="does not have an 'area' "): - sample_model.normalize_area() + component_collection.normalize_area() - def test_get_all_parameters(self, sample_model): + def test_get_all_parameters(self, component_collection): # WHEN THEN - parameters = sample_model.get_all_parameters() + parameters = component_collection.get_all_parameters() # EXPECT assert len(parameters) == 6 @@ -258,24 +265,24 @@ def test_get_all_parameters(self, sample_model): assert all(isinstance(param, Parameter) for param in parameters) def test_get_parameters_no_components(self): - sample_model = SampleModel(display_name="EmptyModel") + component_collection = ComponentCollection(display_name="EmptyModel") # WHEN THEN - parameters = sample_model.get_all_parameters() + parameters = component_collection.get_all_parameters() # EXPECT assert len(parameters) == 0 - def test_get_fit_parameters(self, sample_model): + def test_get_fit_parameters(self, component_collection): # WHEN # Fix one parameter and make another dependent - sample_model.components[0].area.fixed = True - sample_model.components[1].width.make_dependent_on( + component_collection.components[0].area.fixed = True + component_collection.components[1].width.make_dependent_on( "comp1_width", - {"comp1_width": sample_model.components[0].width}, + {"comp1_width": component_collection.components[0].width}, ) # THEN - fit_parameters = sample_model.get_fit_parameters() + fit_parameters = component_collection.get_fit_parameters() # EXPECT assert len(fit_parameters) == 4 @@ -290,53 +297,53 @@ def test_get_fit_parameters(self, sample_model): assert actual_names == expected_names assert all(isinstance(param, Parameter) for param in fit_parameters) - def test_fix_and_free_all_parameters(self, sample_model): + def test_fix_and_free_all_parameters(self, component_collection): # WHEN THEN - sample_model.fix_all_parameters() + component_collection.fix_all_parameters() # EXPECT - for param in sample_model.get_all_parameters(): + for param in component_collection.get_all_parameters(): assert param.fixed is True # WHEN - sample_model.free_all_parameters() + component_collection.free_all_parameters() # THEN - for param in sample_model.get_all_parameters(): + for param in component_collection.get_all_parameters(): assert param.fixed is False - def test_contains(self, sample_model): + def test_contains(self, component_collection): # WHEN THEN - assert "TestGaussian1" in sample_model - assert "TestLorentzian1" in sample_model - assert "NonExistentComponent" not in sample_model + assert "TestGaussian1" in component_collection + assert "TestLorentzian1" in component_collection + assert "NonExistentComponent" not in component_collection - gaussian_component = sample_model.components[0] - lorentzian_component = sample_model.components[1] - assert gaussian_component in sample_model - assert lorentzian_component in sample_model + gaussian_component = component_collection.components[0] + lorentzian_component = component_collection.components[1] + assert gaussian_component in component_collection + assert lorentzian_component in component_collection fake_component = Gaussian( display_name="FakeGaussian", area=1.0, center=0.0, width=1.0, unit="meV" ) - assert fake_component not in sample_model + assert fake_component not in component_collection - def test_repr_contains_name_and_components(self, sample_model): + def test_repr_contains_name_and_components(self, component_collection): # WHEN THEN - rep = repr(sample_model) + rep = repr(component_collection) # EXPECT - assert "SampleModel" in rep + assert "ComponentCollection" in rep assert "TestGaussian" in rep - def test_copy(self, sample_model): + def test_copy(self, component_collection): # WHEN THEN - sample_model.temperature = 300 - model_copy = copy(sample_model) + component_collection.temperature = 300 + model_copy = copy(component_collection) # EXPECT - assert model_copy is not sample_model - assert model_copy.display_name == sample_model.display_name - assert len(model_copy.components) == len(sample_model.components) - for comp in sample_model.components: + assert model_copy is not component_collection + assert model_copy.display_name == component_collection.display_name + assert len(model_copy.components) == len(component_collection.components) + for comp in component_collection.components: copied_comp = model_copy.components[ model_copy.list_component_names().index(comp.display_name) ] From 4f7608eec54b538044712c91df352b25f74feb00 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 12 Dec 2025 06:09:57 +0100 Subject: [PATCH 32/44] Add a few tests, simplify polynomial --- .../sample_model/component_collection.py | 6 +++-- .../sample_model/components/polynomial.py | 22 ------------------- .../components/test_polynomial.py | 17 +++++++++----- .../sample_model/test_component_collection.py | 20 ++++++++++++++--- 4 files changed, 32 insertions(+), 33 deletions(-) diff --git a/src/easydynamics/sample_model/component_collection.py b/src/easydynamics/sample_model/component_collection.py index 556bbfc..36b6280 100644 --- a/src/easydynamics/sample_model/component_collection.py +++ b/src/easydynamics/sample_model/component_collection.py @@ -60,12 +60,14 @@ def add_component(self, component: ModelComponent) -> None: raise TypeError("Component must be an instance of ModelComponent.") if component in self._components: - raise ValueError(f"Component '{component.display_name}' already added.") + raise ValueError( + f"Component '{component.display_name}' is already in the collection." + ) for comp in self._components: if comp.display_name == component.display_name: raise ValueError( - f"A component with the name '{component.display_name}' already exists." + f"A component with the name '{component.display_name}' is already in the collection." ) self._components.append(component) diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 59bda05..183d45c 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -97,28 +97,6 @@ def coefficient_values(self) -> list[float]: coefficient_list = [param.value for param in self._coefficients] return coefficient_list - @coefficient_values.setter - def coefficient_values(self, coeffs: Sequence[Union[Numeric, Parameter]]) -> None: - """Replace the coefficients. Length must match current number of coefficients.""" - if not isinstance(coeffs, (list, tuple, np.ndarray)): - raise TypeError( - "coefficients must be a sequence (list/tuple/ndarray) of numbers or Parameter objects." - ) - if len(coeffs) != len(self._coefficients): - raise ValueError( - "Number of coefficients must match the existing number of coefficients." - ) - for i, coef in enumerate(coeffs): - if isinstance(coef, Parameter): - # replace parameter - self._coefficients[i] = coef - elif isinstance(coef, Numeric): - self._coefficients[i].value = float(coef) - else: - raise TypeError( - "Each coefficient must be either a numeric value or a Parameter." - ) - def evaluate( self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] ) -> np.ndarray: diff --git a/tests/unit_tests/sample_model/components/test_polynomial.py b/tests/unit_tests/sample_model/components/test_polynomial.py index ef3c5da..3ee6fb4 100644 --- a/tests/unit_tests/sample_model/components/test_polynomial.py +++ b/tests/unit_tests/sample_model/components/test_polynomial.py @@ -91,10 +91,10 @@ def test_degree(self, polynomial: Polynomial): [2.0, Parameter("p1", 0.0), -1.0], # mixed numbers and Parameters ], ) - def test_set_coefficient_values(self, polynomial: Polynomial, values): + def test_set_coefficients(self, polynomial: Polynomial, values): """Test that coefficients can be updated from numeric values or Parameters.""" # WHEN - polynomial.coefficient_values = values + polynomial.coefficients = values # THEN EXPECT: Parameter values match the new inputs for i, val in enumerate(values): @@ -107,12 +107,12 @@ def test_set_coefficient_values(self, polynomial: Polynomial, values): def test_set_coefficients_wrong_length_raises(self, polynomial: Polynomial): """Ensure that setting coefficients with mismatched length raises an error.""" with pytest.raises(ValueError, match="Number of coefficients"): - polynomial.coefficient_values = [1.0, 2.0] # shorter list + polynomial.coefficients = [1.0, 2.0] # shorter list def test_set_coefficients_invalid_type_raises(self, polynomial: Polynomial): """Ensure that invalid coefficient types raise a TypeError.""" with pytest.raises(TypeError): - polynomial.coefficient_values = [1.0, "invalid", 3.0] + polynomial.coefficients = [1.0, "invalid", 3.0] @pytest.mark.parametrize( "invalid_coeffs, expected_message", @@ -122,12 +122,17 @@ def test_set_coefficients_invalid_type_raises(self, polynomial: Polynomial): ("not a list", "coefficients must be "), ], ) - def test_set_coefficient_values_raises(self, invalid_coeffs, expected_message): + def test_set_coefficients_raises(self, invalid_coeffs, expected_message): with pytest.raises(TypeError, match=expected_message): polynomial = Polynomial( display_name="TestPolynomial", coefficients=[1.0, -2.0, 3.0] ) - polynomial.coefficient_values = invalid_coeffs + polynomial.coefficients = invalid_coeffs + + def test_coefficient_values(self, polynomial: Polynomial): + # WHEN THEN EXPECT + coeff_values = polynomial.coefficient_values + assert coeff_values == [1.0, -2.0, 3.0] def test_get_all_parameters(self, polynomial: Polynomial): # WHEN THEN diff --git a/tests/unit_tests/sample_model/test_component_collection.py b/tests/unit_tests/sample_model/test_component_collection.py index 8171b59..b7b2054 100644 --- a/tests/unit_tests/sample_model/test_component_collection.py +++ b/tests/unit_tests/sample_model/test_component_collection.py @@ -47,13 +47,20 @@ def test_add_component(self, component_collection): # EXPECT assert component_collection.components[-1] is component - def test_add_duplicate_component_raises(self, component_collection): + def test_add_duplicate_component_name_raises(self, component_collection): # WHEN THEN component = Gaussian( display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" ) # EXPECT - with pytest.raises(ValueError, match="already exists"): + with pytest.raises(ValueError, match="is already in the collection"): + component_collection.add_component(component) + + def test_add_existing_component_raises(self, component_collection): + # WHEN THEN + component = component_collection.components[0] + # EXPECT + with pytest.raises(ValueError, match="is already in the collection"): component_collection.add_component(component) def test_add_invalid_component_raises(self, component_collection): @@ -69,6 +76,11 @@ def test_remove_component(self, component_collection): # EXPECT assert "TestGaussian1" not in component_collection.components + def test_remove_component_raises(self, component_collection): + # WHEN THEN EXPECT + with pytest.raises(TypeError, match="Component name must be a string"): + component_collection.remove_component(123) + def test_remove_nonexistent_component_raises(self, component_collection): # WHEN THEN EXPECT with pytest.raises( @@ -313,7 +325,6 @@ def test_fix_and_free_all_parameters(self, component_collection): assert param.fixed is False def test_contains(self, component_collection): - # WHEN THEN assert "TestGaussian1" in component_collection assert "TestLorentzian1" in component_collection assert "NonExistentComponent" not in component_collection @@ -323,10 +334,13 @@ def test_contains(self, component_collection): assert gaussian_component in component_collection assert lorentzian_component in component_collection + # WHEN THEN fake_component = Gaussian( display_name="FakeGaussian", area=1.0, center=0.0, width=1.0, unit="meV" ) + # EXPECT assert fake_component not in component_collection + assert 123 not in component_collection # Invalid type def test_repr_contains_name_and_components(self, component_collection): # WHEN THEN From 2d9c1342794db411c1a24f6287c3859b21ed95e3 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 12 Dec 2025 06:15:46 +0100 Subject: [PATCH 33/44] Update examples --- ...model.ipynb => component_collection.ipynb} | 35 ++++--- examples/detailed_balance.ipynb | 92 ++----------------- 2 files changed, 24 insertions(+), 103 deletions(-) rename examples/{sample_model.ipynb => component_collection.ipynb} (55%) diff --git a/examples/sample_model.ipynb b/examples/component_collection.ipynb similarity index 55% rename from examples/sample_model.ipynb rename to examples/component_collection.ipynb index bffd235..f64254c 100644 --- a/examples/sample_model.ipynb +++ b/examples/component_collection.ipynb @@ -14,7 +14,7 @@ "from easydynamics.sample_model import DampedHarmonicOscillator\n", "from easydynamics.sample_model import Polynomial\n", "\n", - "from easydynamics.sample_model import SampleModel\n", + "from easydynamics.sample_model import ComponentCollection\n", "\n", "\n", "import matplotlib.pyplot as plt\n", @@ -30,30 +30,29 @@ "metadata": {}, "outputs": [], "source": [ - "sample_model=SampleModel(name='sample_model')\n", + "component_collection=ComponentCollection()\n", "\n", "# Creating components\n", - "gaussian=Gaussian(name='Gaussian',width=0.5,area=1)\n", - "dho = DampedHarmonicOscillator(name='DHO',center=1.0,width=0.3,area=2.0)\n", - "lorentzian = Lorentzian(name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", - "polynomial = Polynomial(name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", - "\n", - "# Adding components to the sample model\n", - "sample_model.add_component(gaussian)\n", - "sample_model.add_component(dho)\n", - "sample_model.add_component(lorentzian)\n", - "sample_model.add_component(polynomial)\n", + "gaussian=Gaussian(display_name='Gaussian',width=0.5,area=1)\n", + "dho = DampedHarmonicOscillator(display_name='DHO',center=1.0,width=0.3,area=2.0)\n", + "lorentzian = Lorentzian(display_name='Lorentzian',center=-1.0,width=0.2,area=1.0)\n", + "polynomial = Polynomial(display_name='Polynomial',coefficients=[0.1, 0, 0.5]) # y=0.1+0.5*x^2\n", "\n", + "# Adding components to the component collection\n", + "component_collection.add_component(gaussian)\n", + "component_collection.add_component(dho)\n", + "component_collection.add_component(lorentzian)\n", + "component_collection.add_component(polynomial)\n", "\n", "x=np.linspace(-2, 2, 100)\n", "\n", "plt.figure()\n", - "y=sample_model.evaluate(x)\n", - "plt.plot(x, y, label='Sample Model')\n", + "y=component_collection.evaluate(x)\n", + "plt.plot(x, y, label='Component collection')\n", "\n", - "for component in list(sample_model):\n", + "for component in component_collection.components:\n", " y = component.evaluate(x)\n", - " plt.plot(x, y, label=component.name)\n", + " plt.plot(x, y, label=component.display_name)\n", "\n", "plt.legend()\n", "plt.show()" @@ -62,7 +61,7 @@ ], "metadata": { "kernelspec": { - "display_name": "newdynamics", + "display_name": "easydynamics_newbase", "language": "python", "name": "python3" }, @@ -76,7 +75,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.13" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/examples/detailed_balance.ipynb b/examples/detailed_balance.ipynb index 172422f..b4ca072 100644 --- a/examples/detailed_balance.ipynb +++ b/examples/detailed_balance.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "97050b3e", "metadata": {}, "outputs": [], @@ -17,36 +17,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "c1654720", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7cfd67c54e984f0bbf333f80d81e1929", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "temperatures=[1, 10, 100]\n", @@ -68,36 +42,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "a64fbe7c", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "16184f6dae4a40ea85c0c8ca1c716fd3", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "\n", "temperatures=[1, 10, 100]\n", @@ -119,36 +67,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "ea1f36ac", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "309863fb77bf4e798eecf4ceb72a9e96", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import scipp as sc\n", "temperatures=[1, 10, 100]\n", From 65a941a600918d555fb9a91ec6dbc290c3dd73e9 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Mon, 15 Dec 2025 20:09:19 +0100 Subject: [PATCH 34/44] Update based on PR comments --- .../sample_model/component_collection.py | 4 ++-- .../components/damped_harmonic_oscillator.py | 11 ++++------- .../sample_model/components/delta_function.py | 11 ++++------- .../sample_model/components/lorentzian.py | 11 ++++------- .../sample_model/components/polynomial.py | 5 +---- src/easydynamics/sample_model/components/voigt.py | 12 ++++-------- 6 files changed, 19 insertions(+), 35 deletions(-) diff --git a/src/easydynamics/sample_model/component_collection.py b/src/easydynamics/sample_model/component_collection.py index 36b6280..1637870 100644 --- a/src/easydynamics/sample_model/component_collection.py +++ b/src/easydynamics/sample_model/component_collection.py @@ -30,7 +30,7 @@ def __init__( self, display_name: str = "MyComponentCollection", unit: str | sc.Unit = "meV", - components: List[ModelComponent] = [], + components: List[ModelComponent] | None = None, ): """ Initialize a new ComponentCollection. @@ -51,7 +51,7 @@ def __init__( self._components = [] # Add initial components if provided. Used for serialization. - if components: + if components is not None: for comp in components: self.add_component(comp) diff --git a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py index 8099770..0f978a3 100644 --- a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py +++ b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py @@ -33,9 +33,10 @@ def __init__( width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", ): - # Validate inputs and create Parameters if not given - self.validate_unit(unit) - self._unit = unit + super().__init__( + display_name=display_name, + unit=unit, + ) # These methods live in ValidationMixin area = self._create_area_parameter( @@ -49,10 +50,6 @@ def __init__( width = self._create_width_parameter( width=width, name=display_name, unit=self._unit ) - super().__init__( - display_name=display_name, - unit=unit, - ) self._area = area self._center = center diff --git a/src/easydynamics/sample_model/components/delta_function.py b/src/easydynamics/sample_model/components/delta_function.py index b8fb7d2..9c36872 100644 --- a/src/easydynamics/sample_model/components/delta_function.py +++ b/src/easydynamics/sample_model/components/delta_function.py @@ -35,8 +35,10 @@ def __init__( unit: str | sc.Unit = "meV", ): # Validate inputs and create Parameters if not given - self.validate_unit(unit) - self._unit = unit + super().__init__( + display_name=display_name, + unit=unit, + ) # These methods live in ValidationMixin area = self._create_area_parameter( @@ -46,11 +48,6 @@ def __init__( center=center, name=display_name, fix_if_none=True, unit=self._unit ) - super().__init__( - display_name=display_name, - unit=unit, - ) - self._area = area self._center = center diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index 51aad17..0426e04 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -34,9 +34,10 @@ def __init__( width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", ): - # Validate inputs and create Parameters if not given - self.validate_unit(unit) - self._unit = unit + super().__init__( + display_name=display_name, + unit=unit, + ) # These methods live in ValidationMixin area = self._create_area_parameter( @@ -49,10 +50,6 @@ def __init__( width=width, name=display_name, unit=self._unit ) - super().__init__( - display_name=display_name, - unit=unit, - ) self._area = area self._center = center self._width = width diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 183d45c..4f68488 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -30,7 +30,7 @@ def __init__( coefficients: Sequence[Union[Numeric, Parameter]] = (0.0,), unit: str | sc.Unit = "meV", ): - self.validate_unit(unit) + super().__init__(display_name=display_name, unit=unit) if coefficients is None: raise ValueError("At least one coefficient must be provided.") @@ -61,9 +61,6 @@ def __init__( # Helper scipp scalar to track unit conversions (value initialized to 1 with provided unit) self._unit_conversion_helper = sc.scalar(value=1.0, unit=unit) - # call parent with the Parameters - super().__init__(display_name=display_name, unit=unit) - @property def coefficients(self) -> list[Parameter]: """Get the coefficients of the polynomial as a list of Parameters.""" diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index 7c62a1b..889a07a 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -37,9 +37,10 @@ def __init__( lorentzian_width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", ): - # Validate inputs and create Parameters if not given - self.validate_unit(unit) - self._unit = unit + super().__init__( + display_name=display_name, + unit=unit, + ) # These methods live in ValidationMixin area = self._create_area_parameter( @@ -61,11 +62,6 @@ def __init__( unit=self._unit, ) - super().__init__( - display_name=display_name, - unit=unit, - ) - self._area = area self._center = center self._gaussian_width = gaussian_width From f0844619400439762626a1f5059ba31397cf3b6b Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Mon, 15 Dec 2025 20:20:19 +0100 Subject: [PATCH 35/44] Update type hints --- .../sample_model/component_collection.py | 24 +++++++++++-------- .../components/damped_harmonic_oscillator.py | 6 ++--- .../sample_model/components/delta_function.py | 4 +--- .../sample_model/components/lorentzian.py | 4 +--- .../sample_model/components/mixins.py | 15 ++++++------ .../components/model_component.py | 2 +- .../sample_model/components/polynomial.py | 10 ++++---- .../sample_model/components/voigt.py | 4 +--- src/easydynamics/utils/detailed_balance.py | 12 +++++----- .../components/test_model_component.py | 4 +--- 10 files changed, 39 insertions(+), 46 deletions(-) diff --git a/src/easydynamics/sample_model/component_collection.py b/src/easydynamics/sample_model/component_collection.py index 1637870..9abb51f 100644 --- a/src/easydynamics/sample_model/component_collection.py +++ b/src/easydynamics/sample_model/component_collection.py @@ -1,5 +1,5 @@ import warnings -from typing import List, Optional, Union +from typing import List import numpy as np import scipp as sc @@ -10,7 +10,7 @@ from .components.model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int class ComponentCollection(ModelBase): @@ -37,16 +37,20 @@ def __init__( Parameters ---------- - name : str - Name of the sample model. + display_name : str + Display name of the sample model. unit : str or sc.Unit, optional Unit of the sample model. Defaults to "meV". - **kwargs : ModelComponent - Initial model components to add to the ComponentCollection. Keys are component names, values are ModelComponent instances. + components : List[ModelComponent], optional + Initial model components to add to the ComponentCollection. """ super().__init__(display_name=display_name) + if unit is not None and not isinstance(unit, (str, sc.Unit)): + raise TypeError( + f"unit must be None, a string, or a scipp Unit, got {type(unit).__name__}" + ) self._unit = unit self._components = [] @@ -147,7 +151,7 @@ def get_all_variables(self) -> list[DescriptorBase]: ] @property - def unit(self) -> Optional[Union[str, sc.Unit]]: + def unit(self) -> str | sc.Unit: """ Get the unit of the ComponentCollection. @@ -166,7 +170,7 @@ def unit(self, unit_str: str) -> None: ) ) # noqa: E501 - def convert_unit(self, unit: Union[str, sc.Unit]) -> None: + def convert_unit(self, unit: str | sc.Unit) -> None: """ Convert the unit of the ComponentCollection and all its components. """ @@ -187,7 +191,7 @@ def convert_unit(self, unit: Union[str, sc.Unit]) -> None: raise e def evaluate( - self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """ Evaluate the sum of all components. @@ -259,7 +263,7 @@ def free_all_parameters(self) -> None: for param in self.get_all_parameters(): param.fixed = False - def __contains__(self, item: Union[str, ModelComponent]) -> bool: + def __contains__(self, item: str | ModelComponent) -> bool: """ Check if a component with the given name or instance exists in the ComponentCollection. Args: diff --git a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py index 0f978a3..d6acf0a 100644 --- a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py +++ b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py @@ -1,7 +1,5 @@ from __future__ import annotations -from typing import Union - import numpy as np import scipp as sc from easyscience.variable import Parameter @@ -10,7 +8,7 @@ from .model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int class DampedHarmonicOscillator(CreateParametersMixin, ModelComponent): @@ -92,7 +90,7 @@ def width(self, value: Numeric) -> None: self._width.value = value def evaluate( - self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """Evaluate the Damped Harmonic Oscillator at the given x values. If x is a scipp Variable, the unit of the DHO will be converted to diff --git a/src/easydynamics/sample_model/components/delta_function.py b/src/easydynamics/sample_model/components/delta_function.py index 9c36872..cc465eb 100644 --- a/src/easydynamics/sample_model/components/delta_function.py +++ b/src/easydynamics/sample_model/components/delta_function.py @@ -1,7 +1,5 @@ from __future__ import annotations -from typing import Union - import numpy as np import scipp as sc from easyscience.variable import Parameter @@ -10,7 +8,7 @@ from .model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int EPSILON = 1e-8 # small number to avoid floating point issues diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index 0426e04..a288e6a 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -1,7 +1,5 @@ from __future__ import annotations -from typing import Union - import numpy as np import scipp as sc from easyscience.variable import Parameter @@ -10,7 +8,7 @@ from .model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int class Lorentzian(CreateParametersMixin, ModelComponent): diff --git a/src/easydynamics/sample_model/components/mixins.py b/src/easydynamics/sample_model/components/mixins.py index 84ae9e6..1204736 100644 --- a/src/easydynamics/sample_model/components/mixins.py +++ b/src/easydynamics/sample_model/components/mixins.py @@ -1,11 +1,10 @@ import warnings -from typing import Union import numpy as np import scipp as sc from easyscience.variable import Parameter -Numeric = Union[int, float] +Numeric = int | float class CreateParametersMixin: @@ -20,9 +19,9 @@ class CreateParametersMixin: def _create_area_parameter( self, - area: Union[Numeric, Parameter], + area: Numeric | Parameter, name: str, - unit: Union[str, sc.Unit] = "meV", + unit: str | sc.Unit = "meV", minimum_area: float = MINIMUM_AREA, ) -> Parameter: """Validate and convert a number to a Parameter describing the area @@ -60,10 +59,10 @@ def _create_area_parameter( def _create_center_parameter( self, - center: Union[Numeric, Parameter, None], + center: Numeric | Parameter | None, name: str, fix_if_none: bool, - unit: Union[str, sc.Unit] = "meV", + unit: str | sc.Unit = "meV", ) -> Parameter: """Validate and convert a number to a Parameter describing the center of a function. args: @@ -96,10 +95,10 @@ def _create_center_parameter( def _create_width_parameter( self, - width: Union[Numeric, Parameter], + width: Numeric | Parameter, name: str, param_name: str = "width", - unit: Union[str, sc.Unit] = "meV", + unit: str | sc.Unit = "meV", minimum_width: float = MINIMUM_WIDTH, ) -> Parameter: """Validate and convert a number to a Parameter describing the width of a function. diff --git a/src/easydynamics/sample_model/components/model_component.py b/src/easydynamics/sample_model/components/model_component.py index caa95dd..26fce2b 100644 --- a/src/easydynamics/sample_model/components/model_component.py +++ b/src/easydynamics/sample_model/components/model_component.py @@ -147,7 +147,7 @@ def evaluate(self, x: Numeric | sc.Variable) -> np.ndarray: Evaluate the model component at input x. Args: - x (Union[Numeric, sc.Variable]): Input values. + x (Numeric | sc.Variable): Input values. Returns: np.ndarray: Evaluated function values. diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 4f68488..27fd324 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -1,7 +1,7 @@ from __future__ import annotations import warnings -from typing import Sequence, Union +from typing import Sequence import numpy as np import scipp as sc @@ -27,7 +27,7 @@ class Polynomial(ModelComponent): def __init__( self, display_name: str = "Polynomial", - coefficients: Sequence[Union[Numeric, Parameter]] = (0.0,), + coefficients: Sequence[Numeric | Parameter] = (0.0,), unit: str | sc.Unit = "meV", ): super().__init__(display_name=display_name, unit=unit) @@ -67,7 +67,7 @@ def coefficients(self) -> list[Parameter]: return self._coefficients @coefficients.setter - def coefficients(self, coeffs: Sequence[Union[Numeric, Parameter]]) -> None: + def coefficients(self, coeffs: Sequence[Numeric | Parameter]) -> None: """Replace the coefficients. Length must match current number of coefficients.""" if not isinstance(coeffs, (list, tuple, np.ndarray)): raise TypeError( @@ -95,7 +95,7 @@ def coefficient_values(self) -> list[float]: return coefficient_list def evaluate( - self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """Evaluate the Polynomial at the given x values. The Polynomial evaluates to c0 + c1*x + c2*x^2 + ... + cN*x^N @@ -134,7 +134,7 @@ def get_all_variables(self) -> list[DescriptorBase]: """ return self._coefficients - def convert_unit(self, unit: Union[str, sc.Unit]): + def convert_unit(self, unit: str | sc.Unit): """Convert the unit of the polynomial. Args: unit (str or sc.Unit): The target unit to convert to. diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index 889a07a..5265843 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -1,7 +1,5 @@ from __future__ import annotations -from typing import Union - import numpy as np import scipp as sc from easyscience.variable import Parameter @@ -116,7 +114,7 @@ def lorentzian_width(self, value: Numeric) -> None: self._lorentzian_width.value = value def evaluate( - self, x: Union[Numeric, list, np.ndarray, sc.Variable, sc.DataArray] + self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray ) -> np.ndarray: """Evaluate the Voigt at the given x values. If x is a scipp Variable, the unit of the Voigt will be converted to match x. diff --git a/src/easydynamics/utils/detailed_balance.py b/src/easydynamics/utils/detailed_balance.py index dcca2e2..ff4ad72 100644 --- a/src/easydynamics/utils/detailed_balance.py +++ b/src/easydynamics/utils/detailed_balance.py @@ -1,5 +1,5 @@ import warnings -from typing import Optional, Union +from typing import Optional import numpy as np import scipp as sc @@ -13,10 +13,10 @@ def _detailed_balance_factor( - energy: Union[int, float, list, np.ndarray, sc.Variable], - temperature: Union[int, float, sc.Variable, Parameter], - energy_unit: Union[str, sc.Unit] = "meV", - temperature_unit: Union[str, sc.Unit] = "K", + energy: int | float | list | np.ndarray | sc.Variable, + temperature: int | float | sc.Variable | Parameter, + energy_unit: str | sc.Unit = "meV", + temperature_unit: str | sc.Unit = "K", divide_by_temperature: bool = True, ) -> np.ndarray: """ @@ -141,7 +141,7 @@ def _detailed_balance_factor( def _convert_to_scipp_variable( - value: Union[int, float, list, np.ndarray, Parameter, sc.Variable], + value: int | float | list | np.ndarray | Parameter | sc.Variable, name: str, unit: Optional[str] = None, ) -> sc.Variable: diff --git a/tests/unit_tests/sample_model/components/test_model_component.py b/tests/unit_tests/sample_model/components/test_model_component.py index 9213cc5..ba1ea4d 100644 --- a/tests/unit_tests/sample_model/components/test_model_component.py +++ b/tests/unit_tests/sample_model/components/test_model_component.py @@ -1,5 +1,3 @@ -from typing import Union - import numpy as np import pytest import scipp as sc @@ -7,7 +5,7 @@ from easydynamics.sample_model.components.model_component import ModelComponent -Numeric = Union[float, int] +Numeric = float | int class DummyComponent(ModelComponent): From 23c8660f3d844cc5863c7bac5d0ca8a73adbfa1c Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Mon, 15 Dec 2025 20:22:49 +0100 Subject: [PATCH 36/44] Add tests of to and from dict --- .../sample_model/test_component_collection.py | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/unit_tests/sample_model/test_component_collection.py b/tests/unit_tests/sample_model/test_component_collection.py index b7b2054..87113d3 100644 --- a/tests/unit_tests/sample_model/test_component_collection.py +++ b/tests/unit_tests/sample_model/test_component_collection.py @@ -370,3 +370,35 @@ def test_copy(self, component_collection): assert param_copy.name == param_orig.name assert param_copy.value == param_orig.value assert param_copy.fixed == param_orig.fixed + + def test_to_dict(self, component_collection): + # WHEN THEN + model_dict = component_collection.to_dict() + # EXPECT + assert model_dict["display_name"] == "TestComponentCollection" + assert len(model_dict["components"]) == 2 + component_names = [ + comp_dict["display_name"] for comp_dict in model_dict["components"] + ] + assert "TestGaussian1" in component_names + assert "TestLorentzian1" in component_names + + def test_from_dict(self, component_collection): + # WHEN + model_dict = component_collection.to_dict() + # THEN + new_model = ComponentCollection.from_dict(model_dict) + # EXPECT + assert new_model.display_name == component_collection.display_name + assert len(new_model.components) == len(component_collection.components) + for comp in component_collection.components: + new_comp = new_model.components[ + new_model.list_component_names().index(comp.display_name) + ] + assert new_comp.display_name == comp.display_name + for param_orig, param_new in zip( + comp.get_all_parameters(), new_comp.get_all_parameters() + ): + assert param_new.name == param_orig.name + assert param_new.value == param_orig.value + assert param_new.fixed == param_orig.fixed From 49074d93ed8cb5e98c1e6b1138e8870149ba5974 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 19 Dec 2025 11:05:25 +0100 Subject: [PATCH 37/44] Add unique names in init --- .../sample_model/components/damped_harmonic_oscillator.py | 2 ++ src/easydynamics/sample_model/components/delta_function.py | 2 ++ src/easydynamics/sample_model/components/gaussian.py | 2 ++ src/easydynamics/sample_model/components/lorentzian.py | 2 ++ src/easydynamics/sample_model/components/model_component.py | 5 +++-- src/easydynamics/sample_model/components/polynomial.py | 3 ++- src/easydynamics/sample_model/components/voigt.py | 2 ++ src/easydynamics/utils/detailed_balance.py | 3 +-- 8 files changed, 16 insertions(+), 5 deletions(-) diff --git a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py index d6acf0a..fa9600b 100644 --- a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py +++ b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py @@ -30,9 +30,11 @@ def __init__( center: Numeric | Parameter = 1.0, width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + unique_name: str | None = None, ): super().__init__( display_name=display_name, + unique_name=unique_name, unit=unit, ) diff --git a/src/easydynamics/sample_model/components/delta_function.py b/src/easydynamics/sample_model/components/delta_function.py index cc465eb..a6e31ca 100644 --- a/src/easydynamics/sample_model/components/delta_function.py +++ b/src/easydynamics/sample_model/components/delta_function.py @@ -31,11 +31,13 @@ def __init__( center: None | Numeric | Parameter = None, area: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + unique_name: str | None = None, ): # Validate inputs and create Parameters if not given super().__init__( display_name=display_name, unit=unit, + unique_name=unique_name, ) # These methods live in ValidationMixin diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index 2805a39..869841b 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -31,11 +31,13 @@ def __init__( center: Numeric | Parameter | None = None, width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + unique_name: str | None = None, ): # Validate inputs and create Parameters if not given super().__init__( display_name=display_name, unit=unit, + unique_name=unique_name, ) # These methods live in ValidationMixin diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index a288e6a..adea5cc 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -31,10 +31,12 @@ def __init__( center: Numeric | Parameter | None = None, width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + unique_name: str | None = None, ): super().__init__( display_name=display_name, unit=unit, + unique_name=unique_name, ) # These methods live in ValidationMixin diff --git a/src/easydynamics/sample_model/components/model_component.py b/src/easydynamics/sample_model/components/model_component.py index 26fce2b..28e4991 100644 --- a/src/easydynamics/sample_model/components/model_component.py +++ b/src/easydynamics/sample_model/components/model_component.py @@ -19,11 +19,12 @@ class ModelComponent(ModelBase): def __init__( self, - display_name: str = None, + display_name: str | None = None, + unique_name: str | None = None, unit: str | sc.Unit = "meV", ): self.validate_unit(unit) - super().__init__(display_name=display_name) + super().__init__(display_name=display_name, unique_name=unique_name) self._unit = unit @property diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 27fd324..796aeb4 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -29,8 +29,9 @@ def __init__( display_name: str = "Polynomial", coefficients: Sequence[Numeric | Parameter] = (0.0,), unit: str | sc.Unit = "meV", + unique_name: str | None = None, ): - super().__init__(display_name=display_name, unit=unit) + super().__init__(display_name=display_name, unit=unit, unique_name=unique_name) if coefficients is None: raise ValueError("At least one coefficient must be provided.") diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index 5265843..b64cd54 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -34,10 +34,12 @@ def __init__( gaussian_width: Numeric | Parameter = 1.0, lorentzian_width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + unique_name: str | None = None, ): super().__init__( display_name=display_name, unit=unit, + unique_name=unique_name, ) # These methods live in ValidationMixin diff --git a/src/easydynamics/utils/detailed_balance.py b/src/easydynamics/utils/detailed_balance.py index ff4ad72..311768c 100644 --- a/src/easydynamics/utils/detailed_balance.py +++ b/src/easydynamics/utils/detailed_balance.py @@ -1,5 +1,4 @@ import warnings -from typing import Optional import numpy as np import scipp as sc @@ -143,7 +142,7 @@ def _detailed_balance_factor( def _convert_to_scipp_variable( value: int | float | list | np.ndarray | Parameter | sc.Variable, name: str, - unit: Optional[str] = None, + unit: str | None = None, ) -> sc.Variable: """Convert various input types to a scipp Variable with proper units.""" if isinstance(value, sc.Variable): From aae94eb72495658826f572818a7df91ade3bb76a Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 19 Dec 2025 11:11:14 +0100 Subject: [PATCH 38/44] Fix some type hints --- .../sample_model/components/damped_harmonic_oscillator.py | 2 +- src/easydynamics/sample_model/components/delta_function.py | 2 +- src/easydynamics/sample_model/components/gaussian.py | 2 +- src/easydynamics/sample_model/components/lorentzian.py | 2 +- src/easydynamics/sample_model/components/polynomial.py | 2 +- src/easydynamics/sample_model/components/voigt.py | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py index fa9600b..3f14f2a 100644 --- a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py +++ b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py @@ -25,11 +25,11 @@ class DampedHarmonicOscillator(CreateParametersMixin, ModelComponent): def __init__( self, - display_name: str = "DampedHarmonicOscillator", area: Numeric | Parameter = 1.0, center: Numeric | Parameter = 1.0, width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + display_name: str | None = "DampedHarmonicOscillator", unique_name: str | None = None, ): super().__init__( diff --git a/src/easydynamics/sample_model/components/delta_function.py b/src/easydynamics/sample_model/components/delta_function.py index a6e31ca..49ed561 100644 --- a/src/easydynamics/sample_model/components/delta_function.py +++ b/src/easydynamics/sample_model/components/delta_function.py @@ -27,10 +27,10 @@ class DeltaFunction(CreateParametersMixin, ModelComponent): def __init__( self, - display_name: str = "DeltaFunction", center: None | Numeric | Parameter = None, area: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + display_name: str | None = "DeltaFunction", unique_name: str | None = None, ): # Validate inputs and create Parameters if not given diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index 869841b..1c7e08f 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -26,11 +26,11 @@ class Gaussian(CreateParametersMixin, ModelComponent): def __init__( self, - display_name: str = "Gaussian", area: Numeric | Parameter = 1.0, center: Numeric | Parameter | None = None, width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + display_name: str | None = "Gaussian", unique_name: str | None = None, ): # Validate inputs and create Parameters if not given diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index adea5cc..e875007 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -26,11 +26,11 @@ class Lorentzian(CreateParametersMixin, ModelComponent): def __init__( self, - display_name: str = "Lorentzian", area: Numeric | Parameter = 1.0, center: Numeric | Parameter | None = None, width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + display_name: str | None = "Lorentzian", unique_name: str | None = None, ): super().__init__( diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 796aeb4..e8ec589 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -26,9 +26,9 @@ class Polynomial(ModelComponent): def __init__( self, - display_name: str = "Polynomial", coefficients: Sequence[Numeric | Parameter] = (0.0,), unit: str | sc.Unit = "meV", + display_name: str | None = "Polynomial", unique_name: str | None = None, ): super().__init__(display_name=display_name, unit=unit, unique_name=unique_name) diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index b64cd54..28813b7 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -28,12 +28,12 @@ class Voigt(CreateParametersMixin, ModelComponent): def __init__( self, - display_name: str = "Voigt", area: Numeric | Parameter = 1.0, center: Numeric | Parameter | None = None, gaussian_width: Numeric | Parameter = 1.0, lorentzian_width: Numeric | Parameter = 1.0, unit: str | sc.Unit = "meV", + display_name: str | None = "Voigt", unique_name: str | None = None, ): super().__init__( From af3010b3c097d5765404fb24365acca2a7a85929 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 19 Dec 2025 11:13:46 +0100 Subject: [PATCH 39/44] Remove unneeded check in polynomial --- .../sample_model/components/polynomial.py | 3 --- .../sample_model/components/test_polynomial.py | 12 ++++-------- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index e8ec589..6ef283d 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -33,9 +33,6 @@ def __init__( ): super().__init__(display_name=display_name, unit=unit, unique_name=unique_name) - if coefficients is None: - raise ValueError("At least one coefficient must be provided.") - if not isinstance(coefficients, (list, tuple, np.ndarray)): raise TypeError( "coefficients must be a sequence (list/tuple/ndarray) of numbers or Parameter objects." diff --git a/tests/unit_tests/sample_model/components/test_polynomial.py b/tests/unit_tests/sample_model/components/test_polynomial.py index 3ee6fb4..d8d62b9 100644 --- a/tests/unit_tests/sample_model/components/test_polynomial.py +++ b/tests/unit_tests/sample_model/components/test_polynomial.py @@ -43,20 +43,16 @@ def test_initialization(self, polynomial: Polynomial): {"coefficients": [1.0, -2.0, 3.0], "unit": 123}, "unit must be ", ), + ( + {"coefficients": None}, + "coefficients must be ", + ), ], ) def test_input_type_validation_raises(self, kwargs, expected_message): with pytest.raises(TypeError, match=expected_message): Polynomial(display_name="TestPolynomial", **kwargs) - @pytest.mark.parametrize("invalid_coeffs", [[], None]) - def test_no_coefficients_raises(self, invalid_coeffs): - # WHEN THEN EXPECT - with pytest.raises( - ValueError, match="At least one coefficient must be provided" - ): - Polynomial(display_name="TestPolynomial", coefficients=invalid_coeffs) - def test_negative_value_warns_in_evaluate(self): # WHEN THEN test_polynomial = Polynomial(display_name="TestPolynomial", coefficients=[-1.0]) From 5a898037e11ee113644476fe56ba55c27bddc34d Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 19 Dec 2025 11:27:05 +0100 Subject: [PATCH 40/44] Update polynomial to not return list --- src/easydynamics/sample_model/components/polynomial.py | 5 ++--- src/easydynamics/sample_model/components/voigt.py | 2 +- tests/unit_tests/sample_model/components/test_polynomial.py | 2 +- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 6ef283d..9590acb 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -62,7 +62,7 @@ def __init__( @property def coefficients(self) -> list[Parameter]: """Get the coefficients of the polynomial as a list of Parameters.""" - return self._coefficients + return list(self._coefficients) @coefficients.setter def coefficients(self, coeffs: Sequence[Numeric | Parameter]) -> None: @@ -86,7 +86,6 @@ def coefficients(self, coeffs: Sequence[Numeric | Parameter]) -> None: "Each coefficient must be either a numeric value or a Parameter." ) - @property def coefficient_values(self) -> list[float]: """Get the coefficients of the polynomial as a list.""" coefficient_list = [param.value for param in self._coefficients] @@ -130,7 +129,7 @@ def get_all_variables(self) -> list[DescriptorBase]: Returns: List[Parameter]: List of parameters in the component. """ - return self._coefficients + return list(self._coefficients) def convert_unit(self, unit: str | sc.Unit): """Convert the unit of the polynomial. diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index 28813b7..6661c86 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -85,7 +85,7 @@ def center(self) -> Parameter: return self._center @center.setter - def center(self, value: Numeric) -> None: + def center(self, value: Numeric | None) -> None: """Set the center parameter value.""" if not isinstance(value, Numeric): raise TypeError("center must be a number") diff --git a/tests/unit_tests/sample_model/components/test_polynomial.py b/tests/unit_tests/sample_model/components/test_polynomial.py index d8d62b9..3e117bc 100644 --- a/tests/unit_tests/sample_model/components/test_polynomial.py +++ b/tests/unit_tests/sample_model/components/test_polynomial.py @@ -127,7 +127,7 @@ def test_set_coefficients_raises(self, invalid_coeffs, expected_message): def test_coefficient_values(self, polynomial: Polynomial): # WHEN THEN EXPECT - coeff_values = polynomial.coefficient_values + coeff_values = polynomial.coefficient_values() assert coeff_values == [1.0, -2.0, 3.0] def test_get_all_parameters(self, polynomial: Polynomial): From 7fb0a902ea4cbfe174c5747d735456f1ff19d8ae Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 19 Dec 2025 11:28:11 +0100 Subject: [PATCH 41/44] Allow center to be None in setters --- src/easydynamics/sample_model/components/delta_function.py | 5 ++++- src/easydynamics/sample_model/components/gaussian.py | 3 +++ src/easydynamics/sample_model/components/lorentzian.py | 5 ++++- src/easydynamics/sample_model/components/voigt.py | 3 +++ 4 files changed, 14 insertions(+), 2 deletions(-) diff --git a/src/easydynamics/sample_model/components/delta_function.py b/src/easydynamics/sample_model/components/delta_function.py index 49ed561..6f84622 100644 --- a/src/easydynamics/sample_model/components/delta_function.py +++ b/src/easydynamics/sample_model/components/delta_function.py @@ -69,8 +69,11 @@ def center(self) -> Parameter: return self._center @center.setter - def center(self, value: Numeric) -> None: + def center(self, value: Numeric | None) -> None: """Set the center parameter value.""" + if value is None: + value = 0.0 + self._center.fixed = True if not isinstance(value, Numeric): raise TypeError("center must be a number") self._center.value = value diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index 1c7e08f..b2110b4 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -75,6 +75,9 @@ def center(self) -> Parameter: @center.setter def center(self, value: Numeric) -> None: """Set the center parameter value.""" + if value is None: + value = 0.0 + self._center.fixed = True if not isinstance(value, Numeric): raise TypeError("center must be a number") self._center.value = value diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index e875007..ef78482 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -72,8 +72,11 @@ def center(self) -> Parameter: return self._center @center.setter - def center(self, value: Numeric) -> None: + def center(self, value: Numeric | None) -> None: """Set the center parameter value.""" + if value is None: + value = 0.0 + self._center.fixed = True if not isinstance(value, Numeric): raise TypeError("center must be a number") self._center.value = value diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index 6661c86..585753d 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -87,6 +87,9 @@ def center(self) -> Parameter: @center.setter def center(self, value: Numeric | None) -> None: """Set the center parameter value.""" + if value is None: + value = 0.0 + self._center.fixed = True if not isinstance(value, Numeric): raise TypeError("center must be a number") self._center.value = value From 0794808a9116ea59c82314504bbb2b19b8a6df56 Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 19 Dec 2025 11:36:00 +0100 Subject: [PATCH 42/44] Update DHO min center --- .../components/damped_harmonic_oscillator.py | 7 +++++-- src/easydynamics/sample_model/components/mixins.py | 12 ++++++++---- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py index 3f14f2a..69a0681 100644 --- a/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py +++ b/src/easydynamics/sample_model/components/damped_harmonic_oscillator.py @@ -43,9 +43,12 @@ def __init__( area=area, name=display_name, unit=self._unit ) center = self._create_center_parameter( - center=center, name=display_name, fix_if_none=False, unit=self._unit + center=center, + name=display_name, + fix_if_none=False, + unit=self._unit, + enforce_minimum_center=True, ) - center.min = 0.0 # Enforce center >= 0 for DHO width = self._create_width_parameter( width=width, name=display_name, unit=self._unit diff --git a/src/easydynamics/sample_model/components/mixins.py b/src/easydynamics/sample_model/components/mixins.py index 1204736..f229f20 100644 --- a/src/easydynamics/sample_model/components/mixins.py +++ b/src/easydynamics/sample_model/components/mixins.py @@ -7,6 +7,11 @@ Numeric = int | float +MINIMUM_WIDTH = 1e-10 # To avoid division by zero +MINIMUM_AREA = 0.0 # To avoid negative areas +DHO_MINIMUM_CENTER = 1e-10 # To avoid zero center in DHO + + class CreateParametersMixin: """Provides parameter creation and validation methods for model components. @@ -14,9 +19,6 @@ class CreateParametersMixin: (area, center, width) with appropriate bounds and type checking. """ - MINIMUM_WIDTH = 1e-10 # To avoid division by zero - MINIMUM_AREA = 0.0 # To avoid negative areas - def _create_area_parameter( self, area: Numeric | Parameter, @@ -63,6 +65,7 @@ def _create_center_parameter( name: str, fix_if_none: bool, unit: str | sc.Unit = "meV", + enforce_minimum_center: bool = False, ) -> Parameter: """Validate and convert a number to a Parameter describing the center of a function. args: @@ -90,7 +93,8 @@ def _create_center_parameter( raise ValueError("center must be None, a finite number or a Parameter") center = Parameter(name=name + " center", value=float(center), unit=unit) - + if enforce_minimum_center: + center.min = DHO_MINIMUM_CENTER return center def _create_width_parameter( From cfd5c9a58ac43ed86736c9b70bb496a71788e9bb Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Fri, 19 Dec 2025 20:15:28 +0100 Subject: [PATCH 43/44] small changes based on PR comments --- .../sample_model/component_collection.py | 17 +++++++++++------ .../sample_model/test_component_collection.py | 18 ++++++++++++++++++ 2 files changed, 29 insertions(+), 6 deletions(-) diff --git a/src/easydynamics/sample_model/component_collection.py b/src/easydynamics/sample_model/component_collection.py index 9abb51f..82f598f 100644 --- a/src/easydynamics/sample_model/component_collection.py +++ b/src/easydynamics/sample_model/component_collection.py @@ -6,7 +6,7 @@ # from easyscience.job.theoreticalmodel import TheoreticalModelBase from easyscience.base_classes.model_base import ModelBase -from easyscience.variable import DescriptorBase +from easyscience.variable import DescriptorBase, Parameter from .components.model_component import ModelComponent @@ -28,8 +28,8 @@ class ComponentCollection(ModelBase): def __init__( self, - display_name: str = "MyComponentCollection", unit: str | sc.Unit = "meV", + display_name: str = "MyComponentCollection", components: List[ModelComponent] | None = None, ): """ @@ -56,6 +56,10 @@ def __init__( # Add initial components if provided. Used for serialization. if components is not None: + if not isinstance(components, list): + raise TypeError( + "components must be a list of ModelComponent instances." + ) for comp in components: self.add_component(comp) @@ -101,7 +105,7 @@ def list_component_names(self) -> List[str]: Component names. """ - return [component.display_name for component in self.components] + return [component.display_name for component in self._components] def clear_components(self) -> None: """Remove all components.""" @@ -119,9 +123,10 @@ def normalize_area(self) -> None: total_area = 0.0 for component in self.components: + total_area = Parameter(name="total_area", value=0.0, unit=self._unit) if hasattr(component, "area"): area_params.append(component.area) - total_area += component.area.value + total_area += component.area else: warnings.warn( f"Component '{component.display_name}' does not have an 'area' attribute and will be skipped in normalization.", @@ -253,14 +258,14 @@ def fix_all_parameters(self) -> None: """ Fix all free parameters in the model. """ - for param in self.get_all_parameters(): + for param in self.get_fittable_parameters(): param.fixed = True def free_all_parameters(self) -> None: """ Free all fixed parameters in the model. """ - for param in self.get_all_parameters(): + for param in self.get_fittable_parameters(): param.fixed = False def __contains__(self, item: str | ModelComponent) -> bool: diff --git a/tests/unit_tests/sample_model/test_component_collection.py b/tests/unit_tests/sample_model/test_component_collection.py index 87113d3..0ad3004 100644 --- a/tests/unit_tests/sample_model/test_component_collection.py +++ b/tests/unit_tests/sample_model/test_component_collection.py @@ -35,6 +35,24 @@ def test_init(self): assert component_collection.display_name == "InitModel" assert component_collection.components == [] + def test_init_with_components(self): + # WHEN THEN + component1 = Gaussian( + display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" + ) + component2 = Lorentzian( + display_name="TestLorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" + ) + component_collection = ComponentCollection( + display_name="InitModel", components=[component1, component2] + ) + + # EXPECT + assert component_collection.display_name == "InitModel" + assert len(component_collection.components) == 2 + assert component_collection.components[0] is component1 + assert component_collection.components[1] is component2 + # ───── Component Management ───── def test_add_component(self, component_collection): From b6059e6834702f5b9ad51d3431c4502a35a3e7ee Mon Sep 17 00:00:00 2001 From: henrikjacobsenfys Date: Mon, 22 Dec 2025 20:23:46 +0100 Subject: [PATCH 44/44] Fix tests --- examples/component_collection.ipynb | 48 ++++++ .../sample_model/component_collection.py | 60 ++++--- .../sample_model/components/delta_function.py | 5 +- .../sample_model/components/gaussian.py | 5 +- .../sample_model/components/lorentzian.py | 5 +- .../components/model_component.py | 4 +- .../sample_model/components/polynomial.py | 8 +- .../sample_model/components/voigt.py | 7 +- .../components/test_delta_function.py | 2 +- .../sample_model/components/test_gaussian.py | 2 +- .../components/test_lorentzian.py | 2 +- .../components/test_polynomial.py | 2 +- .../sample_model/components/test_voigt.py | 2 +- .../sample_model/test_component_collection.py | 156 ++++++++++++------ 14 files changed, 208 insertions(+), 100 deletions(-) diff --git a/examples/component_collection.ipynb b/examples/component_collection.ipynb index f64254c..d50197d 100644 --- a/examples/component_collection.ipynb +++ b/examples/component_collection.ipynb @@ -23,6 +23,54 @@ "%matplotlib widget" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "f2d27900", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.integrate import simpson\n", + "\n", + "model = ComponentCollection(display_name=\"TestComponentCollection\")\n", + "component1 = Gaussian(\n", + " display_name=\"TestGaussian1\",\n", + " area=1.0,\n", + " center=0.0,\n", + " width=1.0,\n", + " unit=\"meV\",\n", + " unique_name=\"TestGaussian1\",\n", + ")\n", + "component2 = Lorentzian(\n", + " display_name=\"TestLorentzian1\",\n", + " area=2.0,\n", + " center=1.0,\n", + " width=0.5,\n", + " unit=\"meV\",\n", + " unique_name=\"TestLorentzian1\",\n", + ")\n", + "model.add_component(component1)\n", + "model.add_component(component2)\n", + "\n", + "model.normalize_area()\n", + "# EXPECT\n", + "x = np.linspace(-10000, 10000, 1000000) # Lorentzians have long tails\n", + "result = model.evaluate(x)\n", + "numerical_area = simpson(result, x)\n", + "\n", + "print(numerical_area)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe3b8780", + "metadata": {}, + "outputs": [], + "source": [ + "model.components[1].area" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/src/easydynamics/sample_model/component_collection.py b/src/easydynamics/sample_model/component_collection.py index 82f598f..6b31dce 100644 --- a/src/easydynamics/sample_model/component_collection.py +++ b/src/easydynamics/sample_model/component_collection.py @@ -30,6 +30,7 @@ def __init__( self, unit: str | sc.Unit = "meV", display_name: str = "MyComponentCollection", + unique_name: str | None = None, components: List[ModelComponent] | None = None, ): """ @@ -37,10 +38,12 @@ def __init__( Parameters ---------- - display_name : str - Display name of the sample model. unit : str or sc.Unit, optional Unit of the sample model. Defaults to "meV". + display_name : str + Display name of the sample model. + unique_name : str or None, optional + Unique name of the sample model. Defaults to None. components : List[ModelComponent], optional Initial model components to add to the ComponentCollection. """ @@ -69,27 +72,21 @@ def add_component(self, component: ModelComponent) -> None: if component in self._components: raise ValueError( - f"Component '{component.display_name}' is already in the collection." + f"Component '{component.unique_name}' is already in the collection." ) - for comp in self._components: - if comp.display_name == component.display_name: - raise ValueError( - f"A component with the name '{component.display_name}' is already in the collection." - ) - self._components.append(component) - def remove_component(self, name: str) -> None: - if not isinstance(name, str): + def remove_component(self, unique_name: str) -> None: + if not isinstance(unique_name, str): raise TypeError("Component name must be a string.") for comp in self._components: - if comp.display_name == name: + if comp.unique_name == unique_name: self._components.remove(comp) return - raise KeyError(f"No component named '{name}' exists.") + raise KeyError(f"No component named '{unique_name}' exists.") @property def components(self) -> list[ModelComponent]: @@ -105,7 +102,7 @@ def list_component_names(self) -> List[str]: Component names. """ - return [component.display_name for component in self._components] + return [component.unique_name for component in self._components] def clear_components(self) -> None: """Remove all components.""" @@ -120,27 +117,26 @@ def normalize_area(self) -> None: raise ValueError("No components in the model to normalize.") area_params = [] - total_area = 0.0 + total_area = Parameter(name="total_area", value=0.0, unit=self._unit) for component in self.components: - total_area = Parameter(name="total_area", value=0.0, unit=self._unit) if hasattr(component, "area"): area_params.append(component.area) total_area += component.area else: warnings.warn( - f"Component '{component.display_name}' does not have an 'area' attribute and will be skipped in normalization.", + f"Component '{component.unique_name}' does not have an 'area' attribute and will be skipped in normalization.", UserWarning, ) - if total_area == 0: + if total_area.value == 0: raise ValueError("Total area is zero; cannot normalize.") - if not np.isfinite(total_area): + if not np.isfinite(total_area.value): raise ValueError("Total area is not finite; cannot normalize.") for param in area_params: - param.value /= total_area + param.value /= total_area.value def get_all_variables(self) -> list[DescriptorBase]: """ @@ -219,7 +215,7 @@ def evaluate( def evaluate_component( self, x: Numeric | list | np.ndarray | sc.Variable | sc.DataArray, - name: str, + unique_name: str, ) -> np.ndarray: """ Evaluate a single component by name. @@ -228,8 +224,8 @@ def evaluate_component( ---------- x : Number, list, np.ndarray, sc.Variable, or sc.DataArray Energy axis. - name : str - Component name. + unique_name : str + Component unique name. Returns ------- @@ -239,14 +235,16 @@ def evaluate_component( if not self.components: raise ValueError("No components in the model to evaluate.") - if not isinstance(name, str): + if not isinstance(unique_name, str): raise TypeError( - (f"Component name must be a string, got {type(name)} instead.") + ( + f"Component unique name must be a string, got {type(unique_name)} instead." + ) ) - matches = [comp for comp in self.components if comp.display_name == name] + matches = [comp for comp in self.components if comp.unique_name == unique_name] if not matches: - raise KeyError(f"No component named '{name}' exists.") + raise KeyError(f"No component named '{unique_name}' exists.") component = matches[0] @@ -282,8 +280,8 @@ def __contains__(self, item: str | ModelComponent) -> bool: """ if isinstance(item, str): - # Check by component name - return any(comp.display_name == item for comp in self.components) + # Check by component unique name + return any(comp.unique_name == item for comp in self.components) elif isinstance(item, ModelComponent): # Check by component instance return any(comp is item for comp in self.components) @@ -299,7 +297,7 @@ def __repr__(self) -> str: str """ comp_names = ( - ", ".join(c.display_name for c in self.components) or "No components" + ", ".join(c.unique_name for c in self.components) or "No components" ) - return f"" + return f"" diff --git a/src/easydynamics/sample_model/components/delta_function.py b/src/easydynamics/sample_model/components/delta_function.py index 6f84622..2480c71 100644 --- a/src/easydynamics/sample_model/components/delta_function.py +++ b/src/easydynamics/sample_model/components/delta_function.py @@ -19,10 +19,11 @@ class DeltaFunction(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - display_name (str): Name of the component. center (Int or float or None): Center of the delta function. If None, defaults to 0 and is fixed. area (Int or float): Total area under the curve. unit (str or sc.Unit): Unit of the parameters. Defaults to "meV". + display_name (str): Name of the component. + unique_name (str or None): Unique name of the component. If None, a unique_name is automatically generated. """ def __init__( @@ -115,4 +116,4 @@ def evaluate( return model def __repr__(self): - return f"DeltaFunction(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center}" + return f"DeltaFunction(unique_name = {self.unique_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center}" diff --git a/src/easydynamics/sample_model/components/gaussian.py b/src/easydynamics/sample_model/components/gaussian.py index b2110b4..d642c5a 100644 --- a/src/easydynamics/sample_model/components/gaussian.py +++ b/src/easydynamics/sample_model/components/gaussian.py @@ -17,11 +17,12 @@ class Gaussian(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - display_name (str): Name of the component. area (Int, float or Parameter): Area of the Gaussian. center (Int, float, None or Parameter): Center of the Gaussian. If None, defaults to 0 and is fixed width (Int, float or Parameter): Standard deviation. unit (str or sc.Unit): Unit of the parameters. Defaults to "meV". + display_name (str): Name of the component. + unique_name (str or None): Unique name of the component. If None, a unique_name is automatically generated. """ def __init__( @@ -109,4 +110,4 @@ def evaluate( return self.area.value * normalization * np.exp(exponent) def __repr__(self): - return f"Gaussian(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" + return f"Gaussian(unique_name = {self.unique_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" diff --git a/src/easydynamics/sample_model/components/lorentzian.py b/src/easydynamics/sample_model/components/lorentzian.py index ef78482..75cce27 100644 --- a/src/easydynamics/sample_model/components/lorentzian.py +++ b/src/easydynamics/sample_model/components/lorentzian.py @@ -17,11 +17,12 @@ class Lorentzian(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - display_name (str): Display name of the component. area (Int, float or Parameter): Area of the Lorentzian. center (Int, float, None or Parameter): Peak center. If None, defaults to 0 and is fixed. width (Int, float or Parameter): Half Width at Half Maximum (HWHM) unit (str or sc.Unit): Unit of the parameters. Defaults to "meV". + display_name (str): Display name of the component. + unique_name (str or None): Unique name of the component. If None, a unique_name is automatically generated. """ def __init__( @@ -108,4 +109,4 @@ def evaluate( return self.area.value * normalization / denominator def __repr__(self): - return f"Lorentzian(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" + return f"Lorentzian(unique_name = {self.unique_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n width = {self.width})" diff --git a/src/easydynamics/sample_model/components/model_component.py b/src/easydynamics/sample_model/components/model_component.py index 28e4991..412b265 100644 --- a/src/easydynamics/sample_model/components/model_component.py +++ b/src/easydynamics/sample_model/components/model_component.py @@ -19,9 +19,9 @@ class ModelComponent(ModelBase): def __init__( self, + unit: str | sc.Unit = "meV", display_name: str | None = None, unique_name: str | None = None, - unit: str | sc.Unit = "meV", ): self.validate_unit(unit) super().__init__(display_name=display_name, unique_name=unique_name) @@ -156,4 +156,4 @@ def evaluate(self, x: Numeric | sc.Variable) -> np.ndarray: pass def __repr__(self): - return f"{self.__class__.__name__}(name={self.display_name})" + return f"{self.__class__.__name__}(unique_name={self.unique_name}, unit={self._unit})" diff --git a/src/easydynamics/sample_model/components/polynomial.py b/src/easydynamics/sample_model/components/polynomial.py index 9590acb..c2e8856 100644 --- a/src/easydynamics/sample_model/components/polynomial.py +++ b/src/easydynamics/sample_model/components/polynomial.py @@ -18,11 +18,11 @@ class Polynomial(ModelComponent): Polynomial function component. c0 + c1*x + c2*x^2 + ... + cN*x^N Args: - display_name (str): Display name of the Polynomial component. coefficients (list or tuple): Coefficients c0, c1, ..., cN representing f(x) = c0 + c1*x + c2*x^2 + ... + cN*x^N unit (str or sc.Unit): Unit of the Polynomial component. - """ + display_name (str): Display name of the Polynomial component. + unique_name (str or None): Unique name of the component. If None, a unique_name is automatically generated.""" def __init__( self, @@ -106,7 +106,7 @@ def evaluate( if any(result < 0): warnings.warn( - f"The Polynomial with name {self.display_name} has negative values, " + f"The Polynomial with unique_name {self.unique_name} has negative values, " "which may not be physically meaningful.", UserWarning, ) @@ -157,7 +157,7 @@ def __repr__(self) -> str: coeffs_str = ", ".join( f"{param.name}={param.value}" for param in self._coefficients ) - return f"Polynomial(display_name = {self.display_name}, unit = {self._unit},\n coefficients = [{coeffs_str}])" + return f"Polynomial(unique_name = {self.unique_name}, unit = {self._unit},\n coefficients = [{coeffs_str}])" # from typing import Callable, Dict diff --git a/src/easydynamics/sample_model/components/voigt.py b/src/easydynamics/sample_model/components/voigt.py index 585753d..0adfafc 100644 --- a/src/easydynamics/sample_model/components/voigt.py +++ b/src/easydynamics/sample_model/components/voigt.py @@ -18,12 +18,13 @@ class Voigt(CreateParametersMixin, ModelComponent): If the center is not provided, it will be centered at 0 and fixed, which is typically what you want in QENS. Args: - display_name (str): Name of the component. + area (Int or float): Total area under the curve. center (Int or float or None): Center of the Voigt profile. gaussian_width (Int or float): Standard deviation of the Gaussian part. lorentzian_width (Int or float): Half width at half max (HWHM) of the Lorentzian part. - area (Int or float): Total area under the curve. unit (str or sc.Unit): Unit of the parameters. Defaults to "meV". + display_name (str): Display name of the component. + unique_name (str or None): Unique name of the component. If None, a unique_name is automatically generated. """ def __init__( @@ -134,4 +135,4 @@ def evaluate( ) def __repr__(self): - return f"Voigt(display_name = {self.display_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n gaussian_width = {self.gaussian_width},\n lorentzian_width = {self.lorentzian_width})" + return f"Voigt(unique_name = {self.unique_name}, unit = {self._unit},\n area = {self.area},\n center = {self.center},\n gaussian_width = {self.gaussian_width},\n lorentzian_width = {self.lorentzian_width})" diff --git a/tests/unit_tests/sample_model/components/test_delta_function.py b/tests/unit_tests/sample_model/components/test_delta_function.py index c14ad38..f944ae3 100644 --- a/tests/unit_tests/sample_model/components/test_delta_function.py +++ b/tests/unit_tests/sample_model/components/test_delta_function.py @@ -219,7 +219,7 @@ def test_repr(self, delta_function: DeltaFunction): # EXPECT assert "DeltaFunction" in repr_str - assert "name = TestDeltaFunction" in repr_str + assert "unique_name = DeltaFunction" in repr_str assert "unit = meV" in repr_str assert "area =" in repr_str assert "center =" in repr_str diff --git a/tests/unit_tests/sample_model/components/test_gaussian.py b/tests/unit_tests/sample_model/components/test_gaussian.py index e705590..a8fc771 100644 --- a/tests/unit_tests/sample_model/components/test_gaussian.py +++ b/tests/unit_tests/sample_model/components/test_gaussian.py @@ -211,7 +211,7 @@ def test_repr(self, gaussian: Gaussian): repr_str = repr(gaussian) # EXPECT assert "Gaussian" in repr_str - assert "display_name = TestGaussian" in repr_str + assert "unique_name = Gaussian" in repr_str assert "unit = meV" in repr_str assert "area =" in repr_str assert "center =" in repr_str diff --git a/tests/unit_tests/sample_model/components/test_lorentzian.py b/tests/unit_tests/sample_model/components/test_lorentzian.py index f42b11b..3a60821 100644 --- a/tests/unit_tests/sample_model/components/test_lorentzian.py +++ b/tests/unit_tests/sample_model/components/test_lorentzian.py @@ -209,7 +209,7 @@ def test_repr(self, lorentzian: Lorentzian): # EXPECT assert "Lorentzian" in repr_str - assert "display_name = TestLorentzian" in repr_str + assert "unique_name = Lorentzian" in repr_str assert "unit = meV" in repr_str assert "area =" in repr_str assert "center =" in repr_str diff --git a/tests/unit_tests/sample_model/components/test_polynomial.py b/tests/unit_tests/sample_model/components/test_polynomial.py index 3e117bc..ed83093 100644 --- a/tests/unit_tests/sample_model/components/test_polynomial.py +++ b/tests/unit_tests/sample_model/components/test_polynomial.py @@ -175,5 +175,5 @@ def test_repr(self, polynomial: Polynomial): # EXPECT assert "Polynomial" in repr_str - assert "name = TestPolynomial" in repr_str + assert "unique_name = Polynomial" in repr_str assert "coefficients =" in repr_str diff --git a/tests/unit_tests/sample_model/components/test_voigt.py b/tests/unit_tests/sample_model/components/test_voigt.py index 842adec..cb3caaf 100644 --- a/tests/unit_tests/sample_model/components/test_voigt.py +++ b/tests/unit_tests/sample_model/components/test_voigt.py @@ -295,7 +295,7 @@ def test_repr(self, voigt: Voigt): # EXPECT assert "Voigt" in repr_str - assert "name = TestVoigt" in repr_str + assert "unique_name = Voigt" in repr_str assert "unit = meV" in repr_str assert "area =" in repr_str assert "center =" in repr_str diff --git a/tests/unit_tests/sample_model/test_component_collection.py b/tests/unit_tests/sample_model/test_component_collection.py index 0ad3004..56aede4 100644 --- a/tests/unit_tests/sample_model/test_component_collection.py +++ b/tests/unit_tests/sample_model/test_component_collection.py @@ -18,10 +18,20 @@ class TestComponentCollection: def component_collection(self): model = ComponentCollection(display_name="TestComponentCollection") component1 = Gaussian( - display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" + display_name="TestGaussian1", + area=1.0, + center=0.0, + width=1.0, + unit="meV", + unique_name="TestGaussian1", ) component2 = Lorentzian( - display_name="TestLorentzian1", area=2.0, center=1.0, width=0.5, unit="meV" + display_name="TestLorentzian1", + area=2.0, + center=1.0, + width=0.5, + unit="meV", + unique_name="TestLorentzian1", ) model.add_component(component1) model.add_component(component2) @@ -65,15 +75,6 @@ def test_add_component(self, component_collection): # EXPECT assert component_collection.components[-1] is component - def test_add_duplicate_component_name_raises(self, component_collection): - # WHEN THEN - component = Gaussian( - display_name="TestGaussian1", area=1.0, center=0.0, width=1.0, unit="meV" - ) - # EXPECT - with pytest.raises(ValueError, match="is already in the collection"): - component_collection.add_component(component) - def test_add_existing_component_raises(self, component_collection): # WHEN THEN component = component_collection.components[0] @@ -225,7 +226,7 @@ def test_evaluate_component_invalid_name_type_raises(self, component_collection) # THEN EXPECT with pytest.raises( TypeError, - match="Component name must be a string, got instead.", + match="Component unique name must be a string, got instead.", ): component_collection.evaluate_component(x, 123) @@ -367,56 +368,113 @@ def test_repr_contains_name_and_components(self, component_collection): assert "ComponentCollection" in rep assert "TestGaussian" in rep - def test_copy(self, component_collection): - # WHEN THEN - component_collection.temperature = 300 - model_copy = copy(component_collection) - # EXPECT - assert model_copy is not component_collection - assert model_copy.display_name == component_collection.display_name - assert len(model_copy.components) == len(component_collection.components) - for comp in component_collection.components: - copied_comp = model_copy.components[ - model_copy.list_component_names().index(comp.display_name) - ] - assert copied_comp is not comp - assert copied_comp.display_name == comp.display_name - for param_orig, param_copy in zip( - comp.get_all_parameters(), copied_comp.get_all_parameters() - ): - assert param_copy is not param_orig - assert param_copy.name == param_orig.name - assert param_copy.value == param_orig.value - assert param_copy.fixed == param_orig.fixed - + # def test_copy(self, component_collection): + # # WHEN THEN + # component_collection.temperature = 300 + # model_copy = copy(component_collection) + # # EXPECT + # assert model_copy is not component_collection + # assert model_copy.display_name == component_collection.display_name + # assert len(model_copy.components) == len(component_collection.components) + # for comp in component_collection.components: + # copied_comp = model_copy.components[ + # model_copy.list_component_names().index(comp.display_name) + # ] + # assert copied_comp is not comp + # assert copied_comp.display_name == comp.display_name + # for param_orig, param_copy in zip( + # comp.get_all_parameters(), copied_comp.get_all_parameters() + # ): + # assert param_copy is not param_orig + # assert param_copy.name == param_orig.name + # assert param_copy.value == param_orig.value + # assert param_copy.fixed == param_orig.fixed + + # def test_to_dict(self, component_collection): + # # WHEN THEN + # model_dict = component_collection.to_dict() + # # EXPECT + # assert model_dict["display_name"] == "TestComponentCollection" + # assert len(model_dict["components"]) == 2 + # component_names = [ + # comp_dict["display_name"] for comp_dict in model_dict["components"] + # ] + # assert "TestGaussian1" in component_names + # assert "TestLorentzian1" in component_names def test_to_dict(self, component_collection): # WHEN THEN model_dict = component_collection.to_dict() + # EXPECT - assert model_dict["display_name"] == "TestComponentCollection" - assert len(model_dict["components"]) == 2 - component_names = [ - comp_dict["display_name"] for comp_dict in model_dict["components"] - ] - assert "TestGaussian1" in component_names - assert "TestLorentzian1" in component_names + assert model_dict["display_name"] == component_collection.display_name + assert model_dict["unit"] == component_collection.unit + assert len(model_dict["components"]) == len(component_collection.components) + + for comp, comp_dict in zip( + component_collection.components, model_dict["components"] + ): + assert comp_dict["@class"] == type(comp).__name__ + assert comp_dict["display_name"] == comp.display_name + assert comp_dict["unit"] == comp.unit def test_from_dict(self, component_collection): # WHEN model_dict = component_collection.to_dict() + # THEN new_model = ComponentCollection.from_dict(model_dict) + # EXPECT assert new_model.display_name == component_collection.display_name assert len(new_model.components) == len(component_collection.components) - for comp in component_collection.components: - new_comp = new_model.components[ - new_model.list_component_names().index(comp.display_name) - ] - assert new_comp.display_name == comp.display_name - for param_orig, param_new in zip( - comp.get_all_parameters(), new_comp.get_all_parameters() - ): + + # Compare each component and its parameters + for orig_comp, new_comp in zip( + component_collection.components, new_model.components + ): + assert type(new_comp) is type(orig_comp) + assert new_comp.display_name == orig_comp.display_name + assert new_comp.unit == orig_comp.unit + + orig_params = orig_comp.get_all_parameters() + new_params = new_comp.get_all_parameters() + assert len(orig_params) == len(new_params) + for param_orig, param_new in zip(orig_params, new_params): assert param_new.name == param_orig.name assert param_new.value == param_orig.value assert param_new.fixed == param_orig.fixed + + def test_copy(self, component_collection): + # WHEN + component_collection.temperature = 300 + model_copy = copy(component_collection) + + # THEN: collection-level checks + assert model_copy is not component_collection + assert model_copy.display_name == component_collection.display_name + assert len(model_copy.components) == len(component_collection.components) + + # EXPECT: deep copy, same order + for orig_comp, copied_comp in zip( + component_collection.components, model_copy.components + ): + # New object + assert copied_comp is not orig_comp + + # Same type and display name + assert type(copied_comp) is type(orig_comp) + assert copied_comp.display_name == orig_comp.display_name + assert copied_comp.unit == orig_comp.unit + + # Parameters are deep-copied and equivalent + orig_params = orig_comp.get_all_parameters() + copied_params = copied_comp.get_all_parameters() + + assert len(orig_params) == len(copied_params) + + for param_orig, param_copy in zip(orig_params, copied_params): + assert param_copy is not param_orig + assert param_copy.value == param_orig.value + assert param_copy.min == param_orig.min + assert param_copy.max == param_orig.max + assert param_copy.fixed == param_orig.fixed