easyreflectometry 1.0.0__tar.gz → 1.0.2__tar.gz

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: easyreflectometry
-Version: 1.0.0
+Version: 1.0.2
 Summary: A reflectometry python package built on the EasyScience framework.
 Project-URL: homepage, https://docs.easyreflectometry.org
 Project-URL: documentation, https://docs.easyreflectometry.org
@@ -72,13 +72,13 @@ Requires-Dist: myst-parser; extra == 'docs'
 Requires-Dist: nbsphinx; extra == 'docs'
 Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
 Requires-Dist: sphinx-book-theme; extra == 'docs'
+Requires-Dist: sphinx-copybutton; extra == 'docs'
 Requires-Dist: toml; extra == 'docs'
 Description-Content-Type: text/markdown
 
 ![Logo](https://github.com/easyScience/EasyReflectometryLib/raw/master/docs/src/_static/logo.png)
 [![CI badge](https://github.com/easyScience/EasyReflectometryLib/actions/workflows/python-ci.yml/badge.svg)](https://github.com/easyScience/easyReflectometryLib/actions/workflows/python-ci.yml)
-[![PyPI badge](http://img.shields.io/pypi/v/EasyReflectometryLib.svg)](https://pypi.python.org/pypi/EasyReflectometryLib)
-[![Coverage badge](https://codecov.io/gh/easyScience/EasyReflectometryLib/branch/master/graph/badge.svg?token=LcnB8AMGkw)](https://codecov.io/gh/easyScience/EasyReflectometryLib)
+[![PyPI badge](https://img.shields.io/pypi/v/easyreflectometry.svg)](https://pypi.python.org/pypi/easyreflectometry)
 [![Quality badge](https://www.codefactor.io/repository/github/easyscience/easyreflectometrylib/badge)](https://www.codefactor.io/repository/github/easyscience/easyreflectometrylib)
 [![Docs badge](https://img.shields.io/badge/docs-built-blue)](http://docs.easyreflectometry.org)
 

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/README.md

@@ -1,7 +1,6 @@
 ![Logo](https://github.com/easyScience/EasyReflectometryLib/raw/master/docs/src/_static/logo.png)
 [![CI badge](https://github.com/easyScience/EasyReflectometryLib/actions/workflows/python-ci.yml/badge.svg)](https://github.com/easyScience/easyReflectometryLib/actions/workflows/python-ci.yml)
-[![PyPI badge](http://img.shields.io/pypi/v/EasyReflectometryLib.svg)](https://pypi.python.org/pypi/EasyReflectometryLib)
-[![Coverage badge](https://codecov.io/gh/easyScience/EasyReflectometryLib/branch/master/graph/badge.svg?token=LcnB8AMGkw)](https://codecov.io/gh/easyScience/EasyReflectometryLib)
+[![PyPI badge](https://img.shields.io/pypi/v/easyreflectometry.svg)](https://pypi.python.org/pypi/easyreflectometry)
 [![Quality badge](https://www.codefactor.io/repository/github/easyscience/easyreflectometrylib/badge)](https://www.codefactor.io/repository/github/easyscience/easyreflectometrylib)
 [![Docs badge](https://img.shields.io/badge/docs-built-blue)](http://docs.easyreflectometry.org)
 

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/pyproject.toml

@@ -56,8 +56,9 @@ dev = [
 docs = [
     "myst_parser",
     "nbsphinx",
-    "sphinx_book_theme",
     "sphinx_autodoc_typehints",
+    "sphinx_book_theme",
+    "sphinx-copybutton",
     "toml"
 ]
 

easyreflectometry-1.0.2/src/easyreflectometry/__version__.py

@@ -0,0 +1 @@
+__version__ = '1.0.2'

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/src/easyreflectometry/calculators/refl1d/wrapper.py

@@ -3,7 +3,7 @@ __author__ = 'github.com/arm61'
 from typing import Tuple
 
 import numpy as np
-from easyreflectometry.experiment.resolution_functions import is_percentage_fhwm_resolution_function
+from easyreflectometry.experiment.resolution_functions import PercentageFhwm
 from refl1d import model
 from refl1d import names
 
@@ -145,9 +145,9 @@ class Refl1dWrapper(WrapperBase):
         :return: reflectivity calculated at q
         """
         sample = _build_sample(self.storage, model_name)
-        dq_array = self._resolution_function(q_array)
+        dq_array = self._resolution_function.smearing(q_array)
 
-        if is_percentage_fhwm_resolution_function(self._resolution_function):
+        if isinstance(self._resolution_function, PercentageFhwm):
             # Get percentage of Q and change from sigma to FWHM
             dq_array = dq_array * q_array / 100 / (2 * np.sqrt(2 * np.log(2)))
 

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/src/easyreflectometry/calculators/refnx/wrapper.py

@@ -3,7 +3,7 @@ __author__ = 'github.com/arm61'
 from typing import Tuple
 
 import numpy as np
-from easyreflectometry.experiment.resolution_functions import is_percentage_fhwm_resolution_function
+from easyreflectometry.experiment.resolution_functions import PercentageFhwm
 from refnx import reflect
 
 from ..wrapper_base import WrapperBase
@@ -129,8 +129,8 @@ class RefnxWrapper(WrapperBase):
             dq_type='pointwise',
         )
 
-        dq_vector = self._resolution_function(q_array)
-        if is_percentage_fhwm_resolution_function(self._resolution_function):
+        dq_vector = self._resolution_function.smearing(q_array)
+        if isinstance(self._resolution_function, PercentageFhwm):
             # FWHM Percentage resolution is constant given as
             # For a constant resolution percentage refnx supports to pass a scalar value rather than a vector
             dq_vector = dq_vector[0]

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/src/easyreflectometry/calculators/wrapper_base.py

@@ -1,10 +1,9 @@
 from abc import abstractmethod
-from typing import Callable
 
 import numpy as np
 
-from easyreflectometry.experiment import DEFAULT_RESOLUTION_FWHM_PERCENTAGE
-from easyreflectometry.experiment import percentage_fhwm_resolution_function
+from easyreflectometry.experiment import PercentageFhwm
+from easyreflectometry.experiment import ResolutionFunction
 
 
 class WrapperBase:
@@ -16,7 +15,7 @@ class WrapperBase:
             'item': {},
             'model': {},
         }
-        self._resolution_function = percentage_fhwm_resolution_function(DEFAULT_RESOLUTION_FWHM_PERCENTAGE)
+        self._resolution_function = PercentageFhwm()
 
     def reset_storage(self):
         """Reset the storage area to blank."""
@@ -205,7 +204,7 @@ class WrapperBase:
         item = getattr(item, key)
         return getattr(item, 'value')
 
-    def set_resolution_function(self, resolution_function: Callable[[np.array], np.array]) -> None:
+    def set_resolution_function(self, resolution_function: ResolutionFunction) -> None:
         """Set the resolution function for the calculator.
 
         :param resolution_function: The resolution function

easyreflectometry-1.0.2/src/easyreflectometry/experiment/__init__.py

@@ -0,0 +1,13 @@
+from .model import Model
+from .model_collection import ModelCollection
+from .resolution_functions import LinearSpline
+from .resolution_functions import PercentageFhwm
+from .resolution_functions import ResolutionFunction
+
+__all__ = (
+    LinearSpline,
+    PercentageFhwm,
+    ResolutionFunction,
+    Model,
+    ModelCollection,
+)

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/src/easyreflectometry/experiment/model.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 __author__ = 'github.com/arm61'
 
 from numbers import Number
-from typing import Callable
 from typing import Union
 
 import numpy as np
@@ -11,14 +10,14 @@ import yaml
 from easyscience.Objects.ObjectClasses import BaseObj
 from easyscience.Objects.ObjectClasses import Parameter
 
-from easyreflectometry.experiment.resolution_functions import is_percentage_fhwm_resolution_function
 from easyreflectometry.parameter_utils import get_as_parameter
 from easyreflectometry.sample import BaseAssembly
 from easyreflectometry.sample import Layer
 from easyreflectometry.sample import LayerCollection
 from easyreflectometry.sample import Sample
 
-from .resolution_functions import percentage_fhwm_resolution_function
+from .resolution_functions import PercentageFhwm
+from .resolution_functions import ResolutionFunction
 
 DEFAULTS = {
     'scale': {
@@ -59,7 +58,7 @@ class Model(BaseObj):
         sample: Union[Sample, None] = None,
         scale: Union[Parameter, Number, None] = None,
         background: Union[Parameter, Number, None] = None,
-        resolution_function: Union[Callable[[np.array], float], None] = None,
+        resolution_function: Union[ResolutionFunction, None] = None,
         name: str = 'EasyModel',
         interface=None,
     ):
@@ -69,7 +68,7 @@ class Model(BaseObj):
         :param scale: Scaling factor of profile.
         :param background: Linear background magnitude.
         :param name: Name of the model, defaults to 'EasyModel'.
-        :param resolution_function: Resolution function, defaults to percentage_fhwm_resolution_function.
+        :param resolution_function: Resolution function, defaults to PercentageFhwm.
         :param interface: Calculator interface, defaults to `None`.
 
         """
@@ -77,7 +76,7 @@ class Model(BaseObj):
         if sample is None:
             sample = Sample(interface=interface)
         if resolution_function is None:
-            resolution_function = percentage_fhwm_resolution_function(DEFAULTS['resolution']['value'])
+            resolution_function = PercentageFhwm(DEFAULTS['resolution']['value'])
 
         scale = get_as_parameter('scale', scale, DEFAULTS)
         background = get_as_parameter('background', background, DEFAULTS)
@@ -88,8 +87,6 @@ class Model(BaseObj):
             scale=scale,
             background=background,
         )
-        if not callable(resolution_function):
-            raise ValueError('Resolution function must be a callable.')
         self.resolution_function = resolution_function
         # Must be set after resolution function
         self.interface = interface
@@ -140,12 +137,12 @@ class Model(BaseObj):
         del self.sample[idx]
 
     @property
-    def resolution_function(self) -> Callable[[np.array], np.array]:
+    def resolution_function(self) -> ResolutionFunction:
         """Return the resolution function."""
         return self._resolution_function
 
     @resolution_function.setter
-    def resolution_function(self, resolution_function: Callable[[np.array], np.array]) -> None:
+    def resolution_function(self, resolution_function: ResolutionFunction) -> None:
         """Set the resolution function for the model."""
         self._resolution_function = resolution_function
         if self.interface is not None:
@@ -176,8 +173,8 @@ class Model(BaseObj):
     @property
     def _dict_repr(self) -> dict[str, dict[str, str]]:
         """A simplified dict representation."""
-        if is_percentage_fhwm_resolution_function(self._resolution_function):
-            resolution_value = self._resolution_function([0])[0]
+        if isinstance(self._resolution_function, PercentageFhwm):
+            resolution_value = self._resolution_function.as_dict()['constant']
             resolution = f'{resolution_value} %'
         else:
             resolution = 'function of Q'
@@ -204,21 +201,25 @@ class Model(BaseObj):
         if skip is None:
             skip = []
         this_dict = super().as_dict(skip=skip)
-        this_dict['sample'] = self.sample.as_dict()
+        this_dict['sample'] = self.sample.as_dict(skip=skip)
+        this_dict['resolution_function'] = self.resolution_function.as_dict()
         return this_dict
 
     @classmethod
-    def from_dict(cls, data: dict) -> Model:
+    def from_dict(cls, this_dict: dict) -> Model:
         """
         Create a Model from a dictionary.
 
-        :param data: dictionary of the Model
+        :param this_dict: dictionary of the Model
         :return: Model
         """
-        model = super().from_dict(data)
+        resolution_function = ResolutionFunction.from_dict(this_dict['resolution_function'])
+        del this_dict['resolution_function']
+        sample = Sample.from_dict(this_dict['sample'])
+        del this_dict['sample']
 
-        # Ensure that the sample is also converted
-        # TODO Should probably be handled in easyscience
-        model.sample = model.sample.__class__.from_dict(data['sample'])
+        model = super().from_dict(this_dict)
 
+        model.sample = sample
+        model.resolution_function = resolution_function
         return model

easyreflectometry-1.0.2/src/easyreflectometry/experiment/model_collection.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+__author__ = 'github.com/arm61'
+
+from typing import Optional
+
+from easyreflectometry.sample.base_element_collection import SIZE_DEFAULT_COLLECTION
+from easyreflectometry.sample.base_element_collection import BaseElementCollection
+
+from .model import Model
+
+
+class ModelCollection(BaseElementCollection):
+    # Added in super().__init__
+    models: list[Model]
+
+    def __init__(
+        self,
+        *models: Optional[tuple[Model]],
+        name: str = 'EasyModels',
+        interface=None,
+        **kwargs,
+    ):
+        if not models:
+            models = [Model(interface=interface) for _ in range(SIZE_DEFAULT_COLLECTION)]
+        super().__init__(name, interface, *models, **kwargs)
+        self.interface = interface
+
+    def add_model(self, new_model: Model):
+        """
+        Add a model to the models.
+
+        :param new_model: New model to be added.
+        """
+        self.append(new_model)
+
+    def remove_model(self, idx: int):
+        """
+        Remove an model from the models.
+
+        :param idx: Index of the model to remove
+        """
+        del self[idx]
+
+    @classmethod
+    def from_dict(cls, this_dict: dict) -> ModelCollection:
+        """
+        Create an instance of a collection from a dictionary.
+
+        :param data: The dictionary for the collection
+        :return: An instance of the collection
+        """
+        collection = super().from_dict(this_dict)  # type: ModelCollection
+
+        if len(collection) != len(this_dict['data']):
+            raise ValueError(f"Expected {len(collection)} models, got {len(this_dict['data'])}")
+        for i, model_data in enumerate(this_dict['data']):
+            collection[i] = Model.from_dict(model_data)
+
+        return collection

easyreflectometry-1.0.2/src/easyreflectometry/experiment/resolution_functions.py

@@ -0,0 +1,56 @@
+"""Resolution functions for the resolution of the experiment.
+When a percentage is provided we assume that the resolution is a
+Gaussian distribution with a FWHM of the percentage of the q value.
+To convert from a sigma value to a FWHM value we use the formula
+FWHM = 2.35 * sigma [2 * np.sqrt(2 * np.log(2)) * sigma].
+"""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import Union
+
+import numpy as np
+
+DEFAULT_RESOLUTION_FWHM_PERCENTAGE = 5.0
+
+
+class ResolutionFunction:
+    @abstractmethod
+    def smearing(q: Union[np.array, float]) -> np.array: ...
+
+    @abstractmethod
+    def as_dict() -> dict: ...
+
+    @classmethod
+    def from_dict(cls, data: dict) -> ResolutionFunction:
+        if data['smearing'] == 'PercentageFhwm':
+            return PercentageFhwm(data['constant'])
+        if data['smearing'] == 'LinearSpline':
+            return LinearSpline(data['q_data_points'], data['fwhm_values'])
+        raise ValueError('Unknown resolution function type')
+
+
+class PercentageFhwm:
+    def __init__(self, constant: Union[None, float] = None):
+        if constant is None:
+            constant = DEFAULT_RESOLUTION_FWHM_PERCENTAGE
+        self.constant = constant
+
+    def smearing(self, q: Union[np.array, float]) -> np.array:
+        return np.ones(np.array(q).size) * self.constant
+
+    def as_dict(self) -> dict:
+        return {'smearing': 'PercentageFhwm', 'constant': self.constant}
+
+
+class LinearSpline:
+    def __init__(self, q_data_points: np.array, fwhm_values: np.array):
+        self.q_data_points = q_data_points
+        self.fwhm_values = fwhm_values
+
+    def smearing(self, q: Union[np.array, float]) -> np.array:
+        return np.interp(q, self.q_data_points, self.fwhm_values)
+
+    def as_dict(self) -> dict:
+        return {'smearing': 'LinearSpline', 'q_data_points': self.q_data_points, 'fwhm_values': self.fwhm_values}

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/src/easyreflectometry/sample/base_element_collection.py

@@ -1,4 +1,6 @@
 from typing import Any
+from typing import List
+from typing import Optional
 
 import yaml
 from easyscience.Objects.Groups import BaseCollection
@@ -48,6 +50,18 @@ class BaseElementCollection(BaseCollection):
         """
         return {self.name: [i._dict_repr for i in self]}
 
+    def as_dict(self, skip: Optional[List[str]] = None) -> dict:
+        """
+        Create a dictionary representation of the collection.
+
+        :return: A dictionary representation of the collection
+        """
+        this_dict = super().as_dict(skip=skip)
+        this_dict['data'] = []
+        for collection_element in self:
+            this_dict['data'].append(collection_element.as_dict(skip=skip))
+        return this_dict
+
     @classmethod
     def from_dict(cls, data: dict) -> Any:
         """

{easyreflectometry-1.0.0 → easyreflectometry-1.0.2}/src/easyreflectometry/sample/sample.py

@@ -69,7 +69,7 @@ class Sample(BaseCollection):
             skip = []
         this_dict = super().as_dict(skip=skip)
         for i, layer in enumerate(self.data):
-            this_dict['data'][i] = layer.as_dict()
+            this_dict['data'][i] = layer.as_dict(skip=skip)
         return this_dict
 
     @classmethod

easyreflectometry-1.0.0/src/easyreflectometry/__version__.py

@@ -1 +0,0 @@
-__version__ = '1.0.0'

easyreflectometry-1.0.0/src/easyreflectometry/experiment/__init__.py

@@ -1,13 +0,0 @@
-from .model import Model
-from .model_collection import ModelCollection
-from .resolution_functions import DEFAULT_RESOLUTION_FWHM_PERCENTAGE
-from .resolution_functions import linear_spline_resolution_function
-from .resolution_functions import percentage_fhwm_resolution_function
-
-__all__ = (
-    DEFAULT_RESOLUTION_FWHM_PERCENTAGE,
-    percentage_fhwm_resolution_function,
-    linear_spline_resolution_function,
-    Model,
-    ModelCollection,
-)

easyreflectometry-1.0.0/src/easyreflectometry/experiment/model_collection.py

@@ -1,35 +0,0 @@
-__author__ = 'github.com/arm61'
-
-from typing import Optional
-
-from easyreflectometry.sample.base_element_collection import SIZE_DEFAULT_COLLECTION
-from easyreflectometry.sample.base_element_collection import BaseElementCollection
-
-from .model import Model
-
-
-class ModelCollection(BaseElementCollection):
-    # Added in super().__init__
-    models: list[Model]
-
-    def __init__(self, *models: Optional[list[Model]], name: str = 'EasyModels', interface=None, **kwargs):
-        if models is None:
-            models = [Model(interface=interface) for _ in range(SIZE_DEFAULT_COLLECTION)]
-        super().__init__(name, *models, **kwargs)
-        self.interface = interface
-
-    def add_model(self, new_model: Model):
-        """
-        Add a model to the models.
-
-        :param new_model: New model to be added.
-        """
-        self.append(new_model)
-
-    def remove_model(self, idx: int):
-        """
-        Remove an model from the models.
-
-        :param idx: Index of the model to remove
-        """
-        del self[idx]

easyreflectometry-1.0.0/src/easyreflectometry/experiment/resolution_functions.py

@@ -1,51 +0,0 @@
-"""Resolution functions for the resolution of the experiment.
-When a percentage is provided we assume that the resolution is a
-Gaussian distribution with a FWHM of the percentage of the q value.
-To convert from a sigma value to a FWHM value we use the formula
-FWHM = 2.35 * sigma [2 * np.sqrt(2 * np.log(2)) * sigma].
-"""
-
-from typing import Callable
-from typing import Union
-
-import numpy as np
-
-DEFAULT_RESOLUTION_FWHM_PERCENTAGE = 5.0
-
-
-def percentage_fhwm_resolution_function(constant: float) -> Callable[[np.array], np.array]:
-    """Create a resolution function that is constant across the q range.
-
-    :param constant: The constant resolution value.
-    """
-
-    def _constant(q: Union[np.array, float]) -> np.array:
-        """Function that calculates the resolution at a given q value.
-
-        The function uses the data points from the encapsulating function and produces a linearly interpolated between them.
-        """
-        return np.ones(np.array(q).size) * constant
-
-    return _constant
-
-
-def linear_spline_resolution_function(q_data_points: np.array, fwhm_values: np.array) -> Callable[[np.array], np.array]:
-    """Create a resolution function that is linearly interpolated between given data points.
-
-    :param q_data_points: The q values at which the resolution is defined.
-    :param fwhm_values: The resolution values at the given q values.
-    """
-
-    def _linear(q: np.array) -> np.array:
-        """Function that calculates the resolution at a given q value.
-
-        The function uses the data points from the encapsulating function and produces a linearly interpolated between them.
-        """
-        return np.interp(q, q_data_points, fwhm_values)
-
-    return _linear
-
-
-def is_percentage_fhwm_resolution_function(resolution_function: Callable[[np.array], np.array]) -> bool:
-    """Check if the resolution function is a constant."""
-    return 'constant' in resolution_function.__name__