ChessAnalysisPipeline 0.0.14__py3-none-any.whl → 0.0.16__py3-none-any.whl

CHAP/utils/models.py

@@ -0,0 +1,594 @@
+"""Utils Pydantic model classes."""
+
+# Third party imports
+import numpy as np
+from pydantic import (
+    BaseModel,
+    Field,
+    PrivateAttr,
+    StrictBool,
+    conint,
+    conlist,
+    confloat,
+    constr,
+    field_validator,
+)
+from typing import (
+    Literal,
+    Optional,
+    Union,
+)
+from typing_extensions import Annotated
+
+# Local modules
+from CHAP.utils.general import not_zero, tiny
+
+tiny = np.finfo(np.float64).resolution
+s2pi = np.sqrt(2*np.pi)
+
+#def constant(x, c=0.5):
+def constant(x, c=0.0):
+    """Return a linear function.
+
+    constant(x, c) = c
+
+    """
+    return c*np.ones((x.size))
+
+
+#def linear(x, slope=0.9, intercept=0.1):
+def linear(x, slope=1.0, intercept=0.0):
+    """Return a linear function.
+
+    linear(x, slope, intercept) = slope * x + intercept
+
+    """
+    return slope * x + intercept
+
+
+#def quadratic(x, a=0.5, b=0.4, c=0.1):
+def quadratic(x, a=0.0, b=0.0, c=0.0):
+    """Return a parabolic function.
+
+    parabolic(x, a, b, c) = a * x**2 + b * x + c
+
+    """
+    return (a*x + b) * x + c
+
+
+#def exponential(x, amplitude=1.0, decay=0.3):
+def exponential(x, amplitude=1.0, decay=1.0):
+    """Return an exponential function.
+
+    exponential(x, amplitude, decay) = amplitude * exp(-x/decay)
+
+    """
+    return amplitude * np.exp(-x/not_zero(decay))
+
+
+#def gaussian(x, amplitude=0.25, center=0.5, sigma=0.1):
+def gaussian(x, amplitude=1.0, center=0.0, sigma=1.0):
+    """Return a 1-dimensional Gaussian function.
+
+    gaussian(x, amplitude, center, sigma) =
+        (amplitude/(s2pi*sigma)) * exp(-(x-center)**2 / (2*sigma**2))
+
+    """
+    return ((amplitude/(max(tiny, s2pi*sigma)))
+            * np.exp(-(x-center)**2 / max(tiny, (2*sigma**2))))
+
+
+#def lorentzian(x, amplitude=0.3, center=0.5, sigma=0.1):
+def lorentzian(x, amplitude=1.0, center=0.0, sigma=1.0):
+    """Return a 1-dimensional Lorentzian function.
+
+    lorentzian(x, amplitude, center, sigma) =
+        (amplitude/(1 + ((1.0*x-center)/sigma)**2)) / (pi*sigma)
+
+    """
+    return ((amplitude/(1 + ((x-center)/max(tiny, sigma))**2))
+            / max(tiny, (pi*sigma)))
+
+
+def rectangle(
+        x, amplitude=1.0, center1=0.0, sigma1=1.0, center2=1.0,
+        sigma2=1.0, form='linear'):
+    """Return a rectangle function.
+
+    Starts at 0.0, rises to `amplitude` (at `center1` with width `sigma1`),
+    then drops to 0.0 (at `center2` with width `sigma2`) with `form`:
+    - `'linear'` (default) = ramp_up + ramp_down
+    - `'atan'`, `'arctan`' = amplitude*(atan(arg1) + atan(arg2))/pi
+    - `'erf'`              = amplitude*(erf(arg1) + erf(arg2))/2.
+    - `'logisitic'`        = amplitude*[1 - 1/(1 + exp(arg1)) - 1/(1+exp(arg2))]
+
+    where ``arg1 = (x - center1)/sigma1`` and
+    ``arg2 = -(x - center2)/sigma2``.
+
+    """
+    arg1 = (x - center1)/max(tiny, sigma1)
+    arg2 = (center2 - x)/max(tiny, sigma2)
+
+    if form == 'erf':
+        # Third party modules
+        from scipy.special import erf
+
+        rect = 0.5*(erf(arg1) + erf(arg2))
+    elif form == 'logistic':
+        rect = 1. - 1./(1. + np.exp(arg1)) - 1./(1. + np.exp(arg2))
+    elif form in ('atan', 'arctan'):
+        rect = (np.arctan(arg1) + np.arctan(arg2))/pi
+    elif form == 'linear':
+        rect = 0.5*(np.minimum(1, np.maximum(-1, arg1))
+                   + np.minimum(1, np.maximum(-1, arg2)))
+    else:
+        raise ValueError(f'Invalid parameter form ({form})')
+
+    return amplitude*rect
+
+
+def validate_parameters(parameters, info):
+    """Validate the parameters
+
+    :param parameters: Fit model parameters.
+    :type parameters: list[FitParameter]
+    :param info: Pydantic validator info object.
+    :type info: pydantic_core._pydantic_core.ValidationInfo
+    :return: List of fit model parameters.
+    :rtype: list[FitParameter]
+    """
+    # System imports
+    import inspect
+    from copy import deepcopy
+
+    if 'model' in info.data:
+        model = info.data['model']
+    else:
+        model = None
+    if model is None or model == 'expression':
+        return parameters
+    sig = {
+        name:par
+        for name, par in inspect.signature(models[model]).parameters.items()}
+    sig.pop('x')
+
+    # Check input model parameter validity
+    for par in parameters:
+        if par.name not in sig:
+            raise ValueError('Invalid parameter {par.name} in {model} model')
+
+    # Set model parameters
+    output_parameters = []
+    for sig_name, sig_par in sig.items():
+        if model == 'rectangle' and sig_name == 'form':
+            continue
+        for par in parameters:
+            if sig_name == par.name:
+                break
+        else:
+            par = FitParameter(name=sig_name)
+        if sig_par.default != sig_par.empty:
+            par._default = sig_par.default
+        output_parameters.append(par)
+
+    return output_parameters
+
+
+class FitParameter(BaseModel):
+    """
+    Class representing a specific fit parameter for the fit processor.
+
+    """
+    name: constr(strip_whitespace=True, min_length=1)
+    value: Optional[confloat(allow_inf_nan=False)] = None
+    min: Optional[confloat()] = -np.inf
+    max: Optional[confloat()] = np.inf
+    vary: StrictBool = True
+    expr: Optional[constr(strip_whitespace=True, min_length=1)] = None
+    _default: float = PrivateAttr()
+    _init_value: float = PrivateAttr()
+    _prefix: str = PrivateAttr()
+    _stderr: float = PrivateAttr()
+
+    @field_validator('min')
+    @classmethod
+    def validate_min(cls, value):
+        """Validate the specified min.
+
+        :param value: Field value to validate (`min`).
+        :type value: Union[float, None]
+        :return: Lower bound of fit parameter.
+        :rtype: float
+        """
+        if value is None:
+            return -np.inf
+        return value
+
+    @field_validator('max')
+    @classmethod
+    def validate_max(cls, value):
+        """Validate the specified max.
+
+        :param value: Field value to validate (`max`).
+        :type value: Union[float, None]
+        :return: Upper bound of fit parameter.
+        :rtype: float
+        """
+        if value is None:
+            return np.inf
+        return value
+
+    @property
+    def default(self):
+        """Return the _default attribute."""
+        if hasattr(self, '_default'):
+            return self._default
+        else:
+            return None
+
+    @property
+    def init_value(self):
+        """Return the _init_value attribute."""
+        if hasattr(self, '_init_value'):
+            return self._init_value
+        else:
+            return None
+
+    @property
+    def prefix(self):
+        """Return the _prefix attribute."""
+        if hasattr(self, '_prefix'):
+            return self._prefix
+        else:
+            return None
+
+    @property
+    def stderr(self):
+        """Return the _stderr attribute."""
+        if hasattr(self, '_stderr'):
+            return self._stderr
+        else:
+            return None
+
+    def set(self, value=None, min=None, max=None, vary=None, expr=None):
+        """
+        Set or update FitParameter attributes.
+
+        :param value: Parameter value.
+        :type value: float, optional
+        :param min: Lower Parameter value bound. To remove the lower
+            bound you must set min to `numpy.inf`.
+        :type min: bool, optional
+        :param max: Upper Parameter value bound. To remove the lower
+            bound you must set max to `numpy.inf`.
+        :type max: bool, optional
+        :param vary: Whether the Parameter is varied during a fit.
+        :type vary: bool, optional
+        :param expr: Mathematical expression used to constrain the
+            value during the fit. To remove a constraint you must
+            supply an empty string.
+        :type expr: str, optional
+        """
+        if expr is not None:
+            if not isinstance(expr, str):
+                raise ValueError(f'Invalid parameter expr ({expr})')
+            if expr == '':
+                expr = None
+            self.expr = expr
+            if expr is not None:
+                self.value = None
+                self.min = -np.inf
+                self.max = np.inf
+                self.vary = False
+                return
+        if min is not None:
+            if not isinstance(min, (int, float)):
+                raise ValueError(f'Invalid parameter min ({min})')
+            self.min = min
+        if max is not None:
+            if not isinstance(max, (int, float)):
+                raise ValueError(f'Invalid parameter max ({max})')
+            self.max = max
+        if vary is not None:
+            if not isinstance(vary, bool):
+                raise ValueError(f'Invalid parameter vary ({vary})')
+            self.vary = vary
+        if value is not None:
+            if not isinstance(value, (int, float)):
+                raise ValueError(f'Invalid parameter value ({value})')
+            self.value = value
+            if self.value > self.max:
+                self.value = self.max
+            elif self.value < self.min:
+                self.value = self.min
+            self.expr = None
+
+class Constant(BaseModel):
+    """
+    Class representing a Constant model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['constant']
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the function signature (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['constant']
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Linear(BaseModel):
+    """
+    Class representing a Linear model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['linear']
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the function signature (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['linear']
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Quadratic(BaseModel):
+    """
+    Class representing a Quadratic model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['quadratic']
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the function signature (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['quadratic']
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Exponential(BaseModel):
+    """
+    Class representing an Exponential model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['exponential']
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the function signature (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['exponential']
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Gaussian(BaseModel):
+    """
+    Class representing a Gaussian model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['gaussian']
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the function signature (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['gaussian']
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Lorentzian(BaseModel):
+    """
+    Class representing a Lorentzian model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['lorentzian']
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the function signature (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['lorentzian']
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Rectangle(BaseModel):
+    """
+    Class representing a Rectangle model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['rectangle']
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the function signature (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['rectangle']
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Expression(BaseModel):
+    """
+    Class representing an Expression model component.
+
+    :ivar model: The model component base name (a prefix will be added
+        if multiple identical model components are added).
+    :type model: Literal['expression']
+    :ivar expr: Mathematical expression to represent the model
+        component.
+    :type expr: str
+    :ivar parameters: Function parameters, defaults to those auto
+        generated from the model expression (excluding the
+        independent variable), defaults to `[]`.
+    :type parameters: list[FitParameter], optional
+    :ivar prefix: The model prefix, defaults to `''`.
+    :type prefix: str, optional
+    """
+    model: Literal['expression']
+    expr: constr(strip_whitespace=True, min_length=1)
+    parameters: Annotated[
+        conlist(item_type=FitParameter),
+        Field(validate_default=True)] = []
+    prefix: Optional[str] = ''
+
+    _validate_parameters_parameters = field_validator(
+        'parameters')(validate_parameters)
+
+
+class Multipeak(BaseModel):
+    model: Literal['multipeak']
+    centers: conlist(item_type=confloat(allow_inf_nan=False), min_length=1)
+    fit_type: Optional[Literal['uniform', 'unconstrained']] = 'unconstrained'
+    centers_range: Optional[confloat(allow_inf_nan=False)] = None
+    fwhm_min: Optional[confloat(allow_inf_nan=False)] = None
+    fwhm_max: Optional[confloat(allow_inf_nan=False)] = None
+    peak_models: Literal['gaussian', 'lorentzian'] = 'gaussian'
+
+
+models = {
+    'constant': constant,
+    'linear': linear,
+    'quadratic': quadratic,
+    'exponential': exponential,
+    'gaussian': gaussian,
+    'lorentzian': lorentzian,
+    'rectangle': rectangle,
+}
+
+model_classes = (
+    Constant,
+    Linear,
+    Quadratic,
+    Exponential,
+    Gaussian,
+    Lorentzian,
+    Rectangle,
+)
+
+
+class FitConfig(BaseModel):
+    """
+    Class representing the configuration for the fit processor.
+
+    :ivar code: Specifies is lmfit is used to perform the fit or if
+        the scipy fit method is called directly, default is `'lmfit'`.
+    :type code: Literal['lmfit', 'scipy'], optional
+    :ivar parameters: Fit model parameters in addition to those
+        implicitly defined through the build-in model functions,
+        defaults to `[]`'
+    :type parameters: list[FitParameter], optional
+    :ivar models: The component(s) of the (composite) fit model.
+    :type models: Union[Constant, Linear, Quadratic, Exponential,
+        Gaussian, Lorentzian, Rectangle, Expression, Multipeak]
+    :ivar rel_height_cutoff: Relative peak height cutoff for
+        peak fitting (any peak with a height smaller than
+        `rel_height_cutoff` times the maximum height of all peaks 
+        gets removed from the fit model), defaults to `None`.
+    :type rel_height_cutoff: float, optional
+    :ivar num_proc: The number of processors used in fitting a map
+        of data, defaults to `1`.
+    :type num_proc: int, optional
+    :ivar plot: Weather a plot of the fit result is generated,
+        defaults to `False`.
+    :type plot: bool, optional.
+    :ivar print_report:  Weather to generate a fit result printout,
+        defaults to `False`.
+    :type print_report: bool, optional.
+    """
+    code: Literal['lmfit', 'scipy'] = 'scipy'
+    parameters: conlist(item_type=FitParameter) = []
+    models: conlist(item_type=Union[
+        Constant, Linear, Quadratic, Exponential, Gaussian, Lorentzian,
+        Rectangle, Expression, Multipeak], min_length=1)
+    method: Literal[
+        'leastsq', 'trf', 'dogbox', 'lm', 'least_squares'] = 'leastsq'
+    rel_height_cutoff: Optional[
+        confloat(gt=0, lt=1.0, allow_inf_nan=False)] = None
+    num_proc: conint(gt=0) = 1
+    plot: StrictBool = False
+    print_report:  StrictBool = False
+
+    @field_validator('method')
+    @classmethod
+    def validate_method(cls, method, info):
+        """Validate the specified method.
+
+        :param method: The value of `method` to validate.
+        :type method: str
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
+        :return: Fit method.
+        :rtype: str
+        """
+        code = info.data['code']
+        if code == 'lmfit':
+            if method not in ('leastsq', 'least_squares'):
+                method = 'leastsq'
+        elif method == 'least_squares':
+            method = 'leastsq'
+
+        return method

CHAP/utils/parfile.py

@@ -2,10 +2,13 @@
 as input
 """
 
+# System modules
 import csv
-import json
 import os
 
+# Third party modules
+import json
+
 class ParFile():
     """Representation of a .par file
 
@@ -78,9 +81,12 @@ class ParFile():
         :return: a map configuration
         :rtype: CHAP.common.models.map.MapConfig
         """
+        # Third party modules
         import numpy as np
+
+        # Local modules
         from CHAP.common.models.map import MapConfig
-        from CHAP.utils.scanparsers import SMBScanParser
+        from chess_scanparsers import SMBScanParser
 
         scanparser = SMBScanParser(self.spec_file, 1)
         good_scans = self.good_scan_numbers()
@@ -156,7 +162,9 @@ class ParFile():
         :return: reshaped array of values
         :rtype: np.ndarray
         """
+        # Third party modules
         import numpy as np
+
         good_scans = self.good_scan_numbers()
         if len(values) != len(good_scans):
             raise ValueError('number of values provided ({len(values)}) does '

ChessAnalysisPipeline-0.0.16.dist-info/LICENSE

@@ -0,0 +1,60 @@
+MIT License
+
+Copyright (c) 2023 Valentin Kuznetsov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+Some code in CHAP.utils has been based or taken from the lmfit library whose
+licence is below.
+
+Copyright 2022 Matthew Newville, The University of Chicago
+               Renee Otten, Brandeis University
+               Till Stensitzki, Freie Universitat Berlin
+               A. R. J. Nelson, Australian Nuclear Science and Technology Organisation
+               Antonino Ingargiola, University of California, Los Angeles
+               Daniel B. Allen, Johns Hopkins University
+               Michal Rawlik, Eidgenossische Technische Hochschule, Zurich
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+  3. Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+

{ChessAnalysisPipeline-0.0.14.dist-info → ChessAnalysisPipeline-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ChessAnalysisPipeline
-Version: 0.0.14
+Version: 0.0.16
 Summary: CHESS analysis pipeline framework
 Home-page: https://github.com/CHESSComputing/ChessAnalysisPipeline
 Author: Keara Soloway, Rolf Verberg, Valentin Kuznetsov