spinlab 0.0.0__py3-none-any.whl

spinlab/analysis/peaks.py

@@ -0,0 +1,249 @@
+import numpy as _np
+import scipy.signal as _spsig
+import spinlab as _sl
+import warnings
+
+
+def find_peaks(
+    data,
+    dims="f2",
+    normalize=True,
+    regions=None,
+    height=0.5,
+    threshold=None,
+    distance=None,
+    prominence=None,
+    width=None,
+    wlen=None,
+    rel_height=0.5,
+    plateau_size=None,
+):
+    """Find peaks in spectrum
+
+    Find peaks in spectrum (sldata object) and returns peak index, chemical shift (ppm), peak height, peak width (Hz) and peak width height. The function uses the SciPy functions "find_peaks" and "peak_widths".
+
+    Args:
+        data (SpinData):                         Data object
+        dims (str):                             Dimension to find peaks
+        regions (None, list):                   List of tuples defining the region to find peaks
+        normalize (boolean):                    Normalize data to a maximum value of 1. Default is True
+        height (float or numpy.array):          Optionally, height of peaks. If an array is supplied, the first element is minimum and the second is maximum
+        threshold (float or numpy.array):       Optionally, threshold of minimum peak height to be counted. If an array is supplied, the first element is minimum and the second is maximum
+        distance (float):                       Optionally, minimal horizontal distance in samples between peaks. Smaller peaks are removed first until the condition is fulfilled for all remaining peaks.
+        prominence (float or numpy.array):      Optionally, prominence of peaks. If an array is supplied, the first element is minimum and the second is maximum
+        width (float or numpy.array):           Optionally, width of peaks. If an array is supplied, the first element is minimum and the second is maximum
+        wlen (int):                             Optionally, for calculating the peaks prominences. Only valid if prominence is given
+        rel_height (float):                     Optionally, relative height at which peak width is measured. Default is 0.5 for FWHH
+        plateau_size (float or numpy.array):    Optionally, size of the flat top of peaks in samples. If an array is supplied, the first element is minimum and the second is maximum
+        peak_info (boolean):                    If True print output to terminal
+
+    Returns:
+        data (SpinData):         nd array of peak index, peak width and relative peak height. The linewidth is returned in (Hz), based on the spectrometer frequency
+
+    Examples:
+        Find peaks in entire data region:
+
+            >>> peak_list = sl.find_peaks(data)
+
+        Find peaks with an amplitude > 0.01 (after normalization):
+
+            >>> peak_list = sl.find_peaks(data, peak_height = 0.05)
+
+        Find peaks with an amplitude > 500 (data not normalized):
+
+            >>> peak_list = sl.find_peaks(data, peak_height = 500, normalize = False)
+
+    """
+
+    if len(data.dims) == 2:
+        data_list = []
+        second_dim = data.dims[-1]
+        second_coord = data.coords[second_dim]
+        for i in range(len(second_coord)):
+            sub_data = data[second_dim, i].sum(second_dim)
+            data_list.append(
+                find_peaks(
+                    sub_data,
+                    dims,
+                    normalize,
+                    regions=regions,
+                    height=height,
+                    threshold=threshold,
+                    distance=distance,
+                    prominence=prominence,
+                    width=width,
+                    wlen=wlen,
+                    rel_height=rel_height,
+                    plateau_size=plateau_size,
+                )
+            )
+
+        # data_list, second_coord = _peak_list_checker(
+        #     data_list, second_coord, second_dim
+        # )
+
+        return _sl.concat(
+            data_list, dim=second_dim, coord=second_coord, casting="unsafe"
+        )
+
+    elif len(data.dims) == 1:
+        out = data.copy()
+        out.attrs["experiment_type"] = "peak_list"
+        out.attrs["data_type"] = "peak_list"
+
+        resolution = _np.sum(_np.diff(out.coords)) / _np.size(out.coords)
+        frequency = out.attrs["nmr_frequency"]
+
+        coords = out.coords[dims]
+        append_index = 0
+
+        if regions:
+            out = out[dims, regions]
+            append_index = _np.where(coords == out.coords[dims][0])[0][0]
+
+        if normalize == True:
+            out = _sl.normalize(out)
+
+            # In the case of the negative peaks
+            real_array = out.values.real
+            max_value = _np.max(real_array)
+            min_value = _np.min(real_array)
+            if _np.abs(max_value) < _np.abs(min_value):
+                out.values *= -1
+
+        peak_index, _ = _spsig.find_peaks(
+            out.values,
+            height=height,
+            threshold=threshold,
+            distance=distance,
+            prominence=prominence,
+            width=width,
+            wlen=wlen,
+            rel_height=rel_height,
+            plateau_size=plateau_size,
+        )
+        peak_width_height = _spsig.peak_widths(
+            out.values.real, peaks=peak_index, rel_height=rel_height
+        )
+        peak_width = peak_width_height[0] * resolution * 1e-6 * frequency
+        peak_width_height = peak_width_height[1]
+
+        peak_index = [x + append_index for x in peak_index]
+        peak_values = [data.values.real[x] for x in peak_index]
+        peak_shift = [coords[int(x)] for x in peak_index]
+
+        out.values = _np.vstack(
+            (peak_index, peak_shift, peak_values, peak_width, peak_width_height)
+        )
+
+        out = _sl.update_axis(
+            out, dim=0, new_dims="peak_info", start_stop=(0, len(out.values) - 1)
+        )
+        out.coords.append(dim="index", coord=_np.arange(0, len(peak_index), 1))
+
+        proc_attr_name = "peak_list"
+        proc_parameters = {
+            "dims": dims,
+            "normalize": normalize,
+            "regions": regions,
+            "height": height,
+            "threshold": threshold,
+            "distance": distance,
+            "prominence": prominence,
+            "width": width,
+            "wlen": wlen,
+            "rel_height": rel_height,
+            "plateau_size": plateau_size,
+        }
+
+        out.add_proc_attrs(proc_attr_name, proc_parameters)
+
+        return out
+
+    else:
+        raise ValueError("The function only works with 1d or 2d datasets")
+
+
+def peak_info(data):
+    """
+    Print peak list in human readable form
+
+    Function to print the peak list in a human readable form. You first have to run find_peaks to create a sldata object that includes a peak list.
+
+    Args:
+        data (SpinData):     SpinData object created by find_peaks
+
+    Returns:
+        Output (str):       Peak list table
+    """
+
+    if data.attrs["experiment_type"] != "peak_list":
+        print("Peak list required as input")
+        return
+
+    if len(data.dims) == 3:
+        dim = data.dims[-1]
+        coord = data.coords[dim]
+        for i in range(len(coord)):
+            sub_data = data[dim, i].sum(dim)
+            print("Dim: %s, Dim Index: %d, Dim Value: %0.01f" % (dim, i, coord[i]))
+            print("--------------------------------------------")
+            peak_info(sub_data)
+
+    elif len(data.dims) == 2:
+        for peak_number in range(len(data.coords["index"])):
+            values = data["index", peak_number].sum("index").values
+            if any(_np.isnan(values)):
+                print("Peak #%d Information Not Available." % (peak_number + 1))
+            else:
+                print(
+                    "Peak #%d: Index: %5d, Shift (ppm): %0.02f, Height : %4.2f, Width (Hz): %4.2f, Width Height: %2.2f"
+                    % (
+                        peak_number + 1,
+                        values[0],
+                        values[1],
+                        values[2],
+                        values[3],
+                        values[4],
+                    )
+                )
+        print("--------------------------------------------")
+    else:
+        raise ValueError("The function only works with 1d or 2d datasets")
+
+
+def _peak_list_checker(peak_list, coord, dim):
+    """
+    Check peak list before concat. It will remove the inconsistent peak data from list.
+
+    Args:
+        peak_list (list): list of peak data
+        coord (numpy.array): an array of coord
+        dim (str): the dim for concat
+
+    Returns:
+        new_peak_list (list): concat-able list of peak data
+        new_coord (numpy.array): a new array of coord
+    """
+
+    ref = peak_list[-1]
+    ref_shape = _np.shape(ref)
+    new_peak_list = [peak for peak in peak_list if _np.shape(peak) == ref_shape]
+    new_coord = _np.array(
+        [
+            coord[i]
+            for i in range(len(peak_list))
+            if _np.shape(peak_list[i]) == ref_shape
+        ]
+    )
+
+    if new_peak_list != peak_list:
+        print("In dim %s, the following datasets are removed." % dim)
+        for i in range(len(peak_list)):
+            if peak_list[i] not in new_peak_list:
+                print(
+                    "Index: %i, Value: %0.01f, Number of Peaks Found: %i"
+                    % (i, coord[i], len(peak_list[i].coords[1]))
+                )
+
+    return new_peak_list, new_coord

spinlab/analysis/relaxation_fit.py

@@ -0,0 +1,29 @@
+"""Modules which provide function to analyse relaxation measurements]"""
+
+import numpy as _np
+from ..fitting import fit
+from ..math import *
+
+
+def inversion_recovery_fit(integrals):
+    # Estimate an initial guess from experimental data
+
+    initial_guess = (2.0, -4000, 4000)
+
+    fit_results = fit(relaxation.t1, integrals.real, dim="t1", p0=initial_guess)
+
+    # fit returns dictionary with results
+
+    print(fit_results)
+
+    # print(fit_results['fit'])
+
+    # fit = out['fit']
+    # popt = out['popt']
+    # err = out['err']
+
+    # T1 = popt['popt',0]
+    # M_0 = popt['popt',1]
+    # M_inf = popt['popt',2]
+
+    # return out

spinlab/analysis/simulate_enhancement_profiles.py

@@ -0,0 +1,109 @@
+"""Modules to calculate Spin enhancement profiles"""
+
+import numpy as _np
+from scipy import optimize
+import spinlab as _sl
+import warnings
+from ..constants import constants
+
+
+def sim_sl_profile(
+    data,
+    B0,
+    nucleus="1H",
+    sl_process="SE",
+    add_details=False,
+    remove_background=True,
+    normalize=True,
+    integrate=True,
+):
+    """Simulate Spin enhancment profile
+
+    Simulate Spin enhancement profile based on the EPR spectrum. For more details:
+
+    Banerjee, D., D. Shimon, A. Feintuch, S. Vega, and D. Goldfarb. “The Interplay between the Solid Effect and the Cross Effect Mechanisms in Solid State (1)(3)C Spin at 95 GHz Using Trityl Radicals.” Journal of Magnetic Resonance 230 (May 2013): 212–19.
+    https://doi.org/10.1016/j.jmr.2013.02.010.
+
+    Args:
+        data (Spindata): EPR spectrum
+        B0 (float): Field position for the Spin experiment in (T)
+        nucleus (int): Nucleus for Spin experiment
+        sl_process (int): Select Spin mechanism, SE - Solid Effect, CE/TM - Cross-Effect/Thermal Mixing
+        add_details (boolean): Add individual spectra to proc_attrs. Default is False
+        remove_background (boolean): Remove 0th order background from EPR spectrum. Default is True
+        normalize (boolean): Normalize EPR spectrum to maximum amplitude of 1. Default is True
+        integrate (boolean): Integrate EPR spectrum. Default is True
+
+    Returns:
+        data (Spindata): Simulated Spin enhancement profile
+
+    .. math::
+
+    """
+    out = data.copy()
+
+    # Some error checks:
+    if out.attrs.get("experiment_type") == None:
+        print("Error: Key experiment_type not present")
+        return
+
+    if out.attrs["experiment_type"] != "epr_spectrum":
+        print("Error: EPR spectrum required as input.")
+        return
+
+    if len(out.dims) > 1:
+        print("Error: This function requires a 1D EPR spectrum as input.")
+        return
+
+    if remove_background == True:
+        out = _sl.remove_background(out, dim="B0", deg=0)  # Remove background
+
+    if normalize == True:
+        out = _sl.normalize(out)
+
+    if integrate == True:
+        out = _sl.cumulative_integrate(out, dim="B0")  # Calculate cumsum
+
+    ## Calculate number of points to shift
+    slLarmorFrequency = _sl.mr_properties(nucleus, B0)  # Nuclear Larmor Frequency
+    slLarmorFrequency_G = slLarmorFrequency / (
+        1000 * _sl.mr_properties("0e") / 2 / pi
+    )  # Nuclear Larmor Frequency in [G]
+    deltaB0_G = (out.coords["B0"][1] - out.coords["B0"][0]) * 10
+    points_to_shift = round(slLarmorFrequency_G / deltaB0_G)
+
+    ## Shift EPR spectra using mumpy's roll function
+    EPRdataPos = out.copy()
+    EPRdataPos.values = _np.roll(EPRdataPos.values, points_to_shift)
+
+    EPRdataNeg = out.copy()
+    EPRdataNeg.values = _np.roll(out.values, (-1) * points_to_shift)
+    EPRdataNeg.values = (-1) * EPRdataNeg.values
+
+    if sl_process == "SE":
+        out = EPRdataPos + EPRdataNeg
+    elif sl_process == "CE/TM":
+        out = out.values * (EPRdataPos + EPRdataNeg)
+
+    proc_attr_name = "sim_sl_profile"
+    proc_parameters = {
+        "nucleus": nucleus,
+        "sl_process": sl_process,
+        "remove_background": remove_background,
+        "normalize": normalize,
+        "integrate": integrate,
+    }
+
+    out.add_proc_attrs(proc_attr_name, proc_parameters)
+
+    if add_details == True:
+        sim_data = _np.array([out.values, EPRdataNeg.values, EPRdataPos.values])
+
+        proc_attr_name = "sim_sl_profile"
+        proc_parameters = {
+            "sim_data": sim_data,
+        }
+
+        out.add_proc_attrs(proc_attr_name, proc_parameters)
+
+    return out

spinlab/config/config.py

@@ -0,0 +1,81 @@
+"""
+global config
+"""
+
+import configparser
+from pathlib import Path
+import warnings
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def _escape_split(s, delim=",", escape="\\"):
+    tokens = []
+    previous_escape = False
+    subtoken = ""
+    for k in range(len(s)):
+        if s[k] == delim and (not previous_escape):
+            if len(subtoken) > 0:
+                tokens.append(subtoken)
+            subtoken = ""  # reset subtoken
+        else:
+            # ESCAPE DELIM  -> DELIM
+            if previous_escape and s[k] != escape and s[k] == delim:
+                subtoken = subtoken[:-1] + s[k]
+            else:
+                # add to subtoken
+                subtoken += s[k]
+            # set previous_escape flag:
+            # If for current char is escape (True and s[k]=='\\') and previous_escape is False -> set it to True
+            # If for current char is escape (True and s[k]=='\\') and previous_escape is True -> case of '\\\\' -> escaping an escape character -> set it back to False
+            # if current char is no escape character -> set it to false
+            previous_escape = (not previous_escape) and (s[k] == escape)
+    if len(subtoken) > 0:
+        tokens.append(subtoken)
+    return tokens
+
+
+def _kwarg_converter(s: str):
+    tokens = _escape_split(s, ",", escape="\\")
+    args = []
+    kwargs = {}
+    for k in tokens:
+        subtokens = _escape_split(k, "=", escape="\\")
+        if len(subtokens) == 1:
+            args.append(subtokens[0])
+        else:
+            kwargs[subtokens[0].strip()] = subtokens[1].strip()
+    return args, kwargs
+
+
+def _get_sl_config(configname="spinlab.cfg"):
+    config = configparser.ConfigParser(
+        converters={
+            "list": lambda x: list(x.strip("[").strip("]").split(",")),
+            "args_kwargs": _kwarg_converter,
+        }
+    )
+
+    # define three possible locations:
+    spinlab_current_config = Path.cwd() / configname
+    spinlab_home_config = Path.home() / configname
+
+    spinlab_cfg_folder = str(
+        Path(__file__).parent
+    )  # / configname #.with_name("config"))
+    spinlab_global_config = Path(spinlab_cfg_folder) / configname
+
+    config_read_list = [
+        spinlab_global_config,
+        spinlab_home_config,
+        spinlab_current_config,
+    ]
+
+    # user defined takes precedence
+    config.read(config_read_list)
+    return config
+
+
+SpinLAB_CONFIG = _get_sl_config()

spinlab/constants/__init__.py

@@ -0,0 +1,5 @@
+"""Modules to store physical properties"""
+
+from .constants import *
+from .mrProperties import *
+from .radicalProperties import *

spinlab/constants/constants.py

@@ -0,0 +1,27 @@
+from scipy.constants import mu_0, c, pi, epsilon_0, hbar, h, N_A, m_e, eV
+from scipy.constants import e as e_charge
+
+from scipy.constants import physical_constants as pc
+
+e_gyro = pc["electron gyromag. ratio in MHz/T"][0]
+p_gyro = pc["proton gyromag. ratio in MHz/T"][0]
+mub = pc["Bohr magneton"][0]
+mub_Hz = pc["Bohr magneton in Hz/T"][0]
+
+
+__all__ = [
+    "mu_0",
+    "c",
+    "pi",
+    "epsilon_0",
+    "hbar",
+    "h",
+    "N_A",
+    "m_e",
+    "e_charge",
+    "e_gyro",
+    "p_gyro",
+    "eV",
+    "mub",
+    "mub_Hz",
+]