nmrglue-ng 1.0.0__py3-none-any.whl

nmrglue/__init__.py

@@ -0,0 +1,6 @@
+from .fileio import *
+from .process import *
+from .util import *
+from .analysis import *
+
+__version__ = '1.0.0'

nmrglue/analysis/__init__.py

@@ -0,0 +1,8 @@
+from . import analysisbase
+from . import leastsqbound
+from . import segmentation
+from . import peakpick
+from . import linesh
+from . import lineshapes1d
+from . import helpers
+from . import integration

nmrglue/analysis/analysisbase.py

@@ -0,0 +1,387 @@
+"""
+analysisbase provides general purpose analysis functions and classes used by
+several nmrglue.analysis modules
+"""
+
+import numpy as np
+
+pi = np.pi
+
+
+# helper functions
+def neighbors(pt, shape, structure):
+    """
+    Generate a list of all neighbors to a point.
+
+    Parameters
+    ----------
+    pt : tuple of ints
+        Index of the point to find neighbors of.
+    shape : tuple of ints
+        Shape of the region.
+    structure : ndarray of bools
+        Structure element that defines connections.
+
+    Returns
+    -------
+    pts : list of int tuples
+        List of tuples which represent indices for all points neighboring pt.
+        Edges are treated as stopping points.
+
+    """
+    # set middle of structure to False
+    s = np.copy(structure)  # copy structure
+    middle = [int(np.floor(i / 2.)) for i in s.shape]  # find middle
+    s.flat[np.ravel_multi_index(middle, s.shape)] = False
+    offsets = np.argwhere(s) - middle
+
+    # loop over the offset adding all valid points
+    pts = []
+    for offset in offsets:
+        npt = pt - offset
+        if valid_pt(npt, shape):
+            pts.append(tuple(npt))
+    return pts
+
+
+def valid_pt(pt, shape):
+    """
+    Determine if a point (indices) is valid for a given shaped
+    """
+    for i, j in zip(pt, shape):
+        if i < 0:   # index is not negative
+            return False
+        if i >= j:    # index is less than j
+            return False
+    return True
+
+dimension_names = ['A', 'Z', 'Y', 'X']
+
+
+# utility functions
+def find_limits(pts):
+    """
+    Find the limits which outline the provided list of points
+
+    Parameters
+    ----------
+    pts : list of int tuples
+        List of points [(z0, y0, x0), (z1, y1, x1), ...]
+
+    Returns
+    -------
+    min : ndarray
+        Array of minimum indices: array([zmin, ymin, xmin]
+    max : ndarray
+        Array of maximum indices: array([zmin, ymin, xmin]
+
+    See Also
+    --------
+    limits2slice : Create a list of slices from min, max limits
+
+    """
+    arr_pts = np.array(pts)
+    return np.min(arr_pts, 0), np.max(arr_pts, 0)
+
+
+def limits2slice(limits):
+    """
+    Create a set of slice objects given an array of min, max limits.
+
+    Parameters
+    ----------
+    limits: tuple, (ndarray, ndarray)
+        Two tuple consisting of array of the minimum and maximum indices.
+
+    Returns
+    -------
+    slices : list
+        List of slice objects which return points between limits
+
+    See Also
+    --------
+    find_limits : Find the minimum and maximum limits from a list of points.
+    slice2limits : Find a minimum and maximum limits for a list of slices.
+
+    """
+    mins, maxs = limits
+    return tuple([slice(i, j + 1) for i, j in zip(mins, maxs)])
+
+
+def slice2limits(slices):
+    """
+    Create a tuple of minimum, maximum limits from a set of slices.
+
+    Parameters
+    ----------
+    slices : list
+        List of slice objects which return points between limits
+
+    Returns
+    -------
+    limits: tuple, (ndarray, ndarray)
+        Two tuple consisting of array of the minimum and maximum indices.
+
+    See Also
+    --------
+    limits2slice : Find a list of slices given minimum and maximum limits.
+    """
+    mins = [s.start for s in slices]
+    maxs = [s.stop - 1 for s in slices]
+    return mins, maxs
+
+
+def squish(r, axis):
+    """
+    Squish array along an axis.
+
+    Determine the sum along all but one axis for an array.
+
+    Parameters
+    ----------
+    r : ndarray
+        Array to squish.
+    axis : int
+        Axis of r to squish along.
+
+    Returns
+    -------
+    s : 1D ndarray
+        Array r squished into a single dimension.
+
+    """
+    # put axis to be squished as the last axis
+    N = int(r.ndim)
+    r = r.swapaxes(axis, N - 1)
+
+    # sum along leading axis N-1 times
+    for i in range(N - 1):
+        r = r.sum(0)
+    return r
+
+
+# Windowing classes
+class ndwindow:
+    """
+    An N-dimensional iterator to slice arrays into windows.
+
+    Given the shape of an array and a window size, an 'ndwindow' instance
+    iterators over tuples of slices which slice an the array into wsize
+    sub-arrays.  At each iteration, the index of the center of the sub-array
+    is incremented by one along the last dimension.  Array borders are ignored
+    so the resulting sub-array can be smaller than wsize.  If wsize contains
+    even values the window is off center containing an additional point with
+    lower index.
+
+    Parameters
+    ----------
+    size : tuple of ints
+        Size of array to generate tuples of slices from.
+    wsize : tuple of ints
+        Window/sub-array size. Size of the area to select from array.  This is
+        the maximum size of the window.
+
+    Examples
+    --------
+
+    >>> a = np.arange(12).reshape(3,4)
+    >>> for s in ndwindow(a.shape,(3,3)):
+    ...     print(a[s])
+    [[0 1]
+     [4 5]]
+    [[0 1 2]
+     [4 5 6]]
+    [[1 2 3]
+     [5 6 7]]
+    [[2 3]
+     [6 7]]
+    [[0 1]
+     [4 5]
+     [8 9]]
+    [[ 0  1  2]
+     [ 4  5  6]
+     [ 8  9 10]]
+    [[ 1  2  3]
+     [ 5  6  7]
+     [ 9 10 11]]
+    [[ 2  3]
+     [ 6  7]
+     [10 11]]
+    [[4 5]
+     [8 9]]
+    [[ 4  5  6]
+     [ 8  9 10]]
+    [[ 5  6  7]
+     [ 9 10 11]]
+    [[ 6  7]
+     [10 11]]
+
+    See Also
+    --------
+    ndwindow_index : Iterator of a ndwindow and index of the window center
+    ndwindow_inside : Iterator over equal sized windows in the array.
+
+    """
+    def __init__(self, shape, wsize):
+        """ Set up the ndwindow object """
+        if len(shape) != len(wsize):
+            raise ValueError("shape and wsize do match match")
+        self.ndindex = np.ndindex(shape)
+        wsize = np.array(wsize)
+        self.sub = np.ceil((wsize - 1.) / 2.)
+        self.add = wsize - 1. - self.sub
+
+    def __next__(self):
+        """ next iterator. """
+        return self.next()
+
+    def next(self):
+        """ x.next() -> the next value, or raise StopIteration """
+        center = self.ndindex.next()
+        start = [max(0, i - j) for i, j in zip(center, self.sub)]
+        stop = [i + j + 1 for i, j in zip(center, self.add)]
+        return tuple([slice(x, y) for x, y in zip(start, stop)])
+
+    def __iter__(self):
+        """ x.__iter__() <==> iter(x) """
+        return self
+
+
+class ndwindow_index:
+    """
+    An N-dimensional iterator object which returns the index of the window
+    center and a :py:class:`ndwindow` slice array.  See :py:class:`ndwindow`
+    for additional documentation.
+
+    This class is equivalent to:
+
+    for slices, index in zip(np.ndindex(shape), ndwindow(shape,wshape)):
+        return (index, slice)
+
+    See Also
+    --------
+    ndwindow: Iterator over only the window slices.
+    ndwindow_inside : Iterator over equal sized windows in the array.
+
+    """
+    def __init__(self, shape, wsize):
+        """ Set up the object """
+        if len(shape) != len(wsize):
+            raise ValueError("shape and wsize do match match")
+        self.ndindex = np.ndindex(shape)
+        wsize = np.array(wsize)
+        self.sub = np.ceil((wsize - 1.) / 2.)
+        self.add = wsize - 1. - self.sub
+
+    def __next__(self):
+        """ next iterator. """
+        return self.next()
+
+    def next(self):
+        """ x.next() -> the next value, or raise StopIteration """
+        center = self.ndindex.next()
+        start = [max(0, i - j) for i, j in zip(center, self.sub)]
+        stop = [i + j + 1 for i, j in zip(center, self.add)]
+        return center, tuple([slice(x, y) for x, y in zip(start, stop)])
+
+    def __iter__(self):
+        """ x.__iter__() <==> iter(x) """
+        return self
+
+
+class ndwindow_inside:
+    """
+    An N-dimensional iterator to slice arrays into uniform size windows.
+
+    Given the shape of an array and a window size, an 'ndwindow_inside'
+    instance iterators over tuples of slices which slice an the array into
+    uniform size wsize windows/sub-arrays.  At each iteration, the index of
+    the top left of the sub-array is incremented by one along the last
+    dimension until the resulting windows would extend past the array border.
+    All sub-arrays are equal sized (wsize).
+
+    Parameters
+    ----------
+    size : tuple of ints
+        Size of array to generate tuples of slices from.
+    wsize : tuple of ints
+        Size of the area to select from array (widow size).
+
+    Examples
+    --------
+
+    >>> a = np.arange(9).reshape(3,3)
+    >>> for s in ndwindow_inside(a.shape,(2,2)):
+    ...     print(a[s])
+    [[0 1]
+     [3 4]]
+    [[1 2]
+     [4 5]]
+    [[3 4]
+     [6 7]]
+    [[4 5]
+     [7 8]]
+
+    See Also
+    --------
+    ndwindow : Iterator over non-uniform windows.
+    ndwindow_inside_index : Iterator of a ndwindow_inside and the index of the
+        window's top left point.
+
+    """
+    def __init__(self, shape, wsize):
+        """ Set up the object """
+        if len(shape) != len(wsize):
+            raise ValueError("shape and wsize do match match")
+        self.ndindex = np.ndindex(
+            tuple(np.array(shape) - np.array(wsize) + 1))
+        self.wsize = wsize
+
+    def __next__(self):
+        """ next iterator. """
+        return self.next()
+
+    def next(self):
+        """ x.next() -> the next value, or raise StopIteration """
+        start = self.ndindex.next()
+        stop = np.array(start) + np.array(self.wsize)
+        return tuple([slice(x, y) for x, y in zip(start, stop)])
+
+    def __iter__(self):
+        """ x.__iter__() <==> iter(x) """
+        return self
+
+
+class ndwindow_inside_index:
+    """
+    An N-dimensional iterator object which returns the index of the window
+    top-left and a :py:class:`ndwindow_inside` slice array.
+
+    Similar to :py:class:`ndwindow_index` but reports top left index of
+    window.
+
+    See :py:class:`ndwindow_inside` and :py:class`ndwindow_index` for addition
+    documentation.
+
+    """
+    def __init__(self, shape, wsize):
+        " Set up the object """
+        if len(shape) != len(wsize):
+            raise ValueError("shape and wsize do match match")
+        self.ndindex = np.ndindex(
+            tuple(np.array(shape) - np.array(wsize) + 1))
+        self.wsize = wsize
+
+    def __next__(self):
+        """ next iterator. """
+        return self.next()
+
+    def next(self):
+        """ x.next() -> the next value, or raiseStopIteration """
+        start = self.ndindex.next()
+        stop = np.array(start) + np.array(self.wsize)
+        return (start, tuple([slice(x, y) for x, y in zip(start, stop)]))
+
+    def __iter__(self):
+        """ x.__iter__() <==> iter(x) """
+        return self

nmrglue/analysis/helpers.py

@@ -0,0 +1,58 @@
+"""
+Helper functions for lineshape fitting.
+"""
+
+
+# bound functions
+def delta(v, d):
+    """
+    Limits of v +/- d for array v and d.
+    """
+    return zip(v - d, v + d)
+
+
+def limit(vmin, vmax, npeaks):
+    """
+    Fixed limits, vmin to vmax for all peaks.
+    """
+    return [(vmin, vmax)] * npeaks
+
+
+def scale_params(rec, prefix, first, last):
+    """
+    scale lineshape parameters in rec with name prefixX with X from from
+    first to last (inclusive)
+    """
+    return [rec[prefix + str(z)] for z in range(first, last + 1)]
+
+
+def no_limits(nparams, npeaks):
+    """
+    No limits on nparameters for npeaks.
+    """
+    return [[(None, None)] * npeaks] * nparams
+
+
+def no_limits_amp(npeaks):
+    """
+    No amplitude limits for npeaks
+    """
+    return [(None, None)] * npeaks
+
+
+# misc
+def super_zip(l):
+    """
+    Zip a list after zipping each element.
+
+    Useful for lineshape parameter and bounds.
+    """
+    return zip(*[zip(*i) for i in l])
+
+
+def scale_columns(prefix, first, last):
+    """
+    Create a list of scale parameter column names with name prefixX with X
+    from first to last (inclusive)
+    """
+    return [prefix + str(i) for i in range(first, last + 1)]

nmrglue/analysis/integration.py

@@ -0,0 +1,207 @@
+import numpy as np
+
+
+def integrate(data, unit_conv, limits, unit='ppm', noise_limits=None,
+              norm_to_range=None, calibrate=1.0):
+    r"""
+    Integrate one 1D data array within limits given in units. Data points must
+    be equally spaced.
+
+    Functional form of integration is:
+
+    .. math::
+        value = \sum_a^b s(x_{i}) dx
+
+    Where:
+    s is the signal, a and b are the limits of integration and dx is the width
+    of each bin.
+
+    The integration error due to baseline noise is calculated as:
+
+    .. math::
+        error = \sigma_{vol} = \sigma \sqrt{n}
+
+    if the noise_limits are set.
+
+    Where:
+
+    .. math::
+        n =  \frac{|b-a|}{dx}+1
+
+    sigma is the standard deviation of the baseline noise. n is the number
+    of bins in the integration range.
+
+    Parameters
+    ----------
+    data: array like
+        1d array of intensity
+    unit_conv: `fileiobase.unit_conversion` object
+        unit_conversion object associated with data
+    limits: array like
+        With shape (2,) or (P, 2). Array with lower and upper integration
+        limit. Or array with P rows of lower and upper integration limits.
+    noise_limits: Optional[array like]
+        With shape(2, ). Array with lower and upper limits to section of data
+        with only noise. A larger range will likely yield a more accurate
+        estimate. It is unwise to use the very end of the spectrum for the
+        noise range.
+    norm_to_range: Optional[int]
+        If given, all values are normalized to the value determined within the
+        range given by limits[norm_to_range, :]
+    calibrate: Optional[float]
+        If norm_to_range is given, the values are re-normalized so that the
+        integral within limits[norm_to_range, :] equals some number.
+
+    Returns
+    -------
+    array
+        [value, ...] integration values
+
+    if noise_limits is given:
+
+    array
+        [[value, error], ...] where error a one sigma estimate of the error
+        only from the spectrum noise
+
+    """
+    # convert form limits in units to lower and upper index
+    limits = np.array(limits)
+    if limits.size == 2:
+        limits = np.expand_dims(limits, axis=0)
+    inds = [(unit_conv(x0, unit), unit_conv(x1, unit)) for (x0, x1) in limits]
+    inds = np.array([sorted(ind) for ind in inds])
+
+    # sum part of the integral
+    sum_slice = np.array([np.sum(data[slice(*ind)]) for ind in inds])
+
+    # dx part of the integral
+    scale = unit_conv.ppm_scale()
+    dx = abs(scale[1]-scale[0])
+
+    # put together the integral
+    values = sum_slice * dx
+
+    if noise_limits is not None:
+
+        # determine the standard deviation of the noise
+        noise_inds = (unit_conv(noise_limits[0], unit),
+                      unit_conv(noise_limits[1], unit))
+        noise_inds = sorted(noise_inds)
+
+        # the error (from noise) is  std * dx * limits range
+        std = np.std(data[slice(*noise_inds)])
+        errors = std * np.sqrt(inds[:, 1] - inds[:, 0])
+
+        if norm_to_range is not None:
+            # You must normalize the error before you normalize the value!
+            errors = (errors / values[norm_to_range]) * calibrate
+            values = (values / values[norm_to_range]) * calibrate
+        return np.vstack((values, errors)).T
+
+    else:
+
+        if norm_to_range is not None:
+            values = (values / values[norm_to_range]) * calibrate
+        return values
+
+
+def ndintegrate(data, unit_conv, limits, unit='ppm', noise_limits=None):
+    r"""
+    Integrate one nD data array within limits given in units. Data points must
+    be equally spaced. Can only integrate one region per function call.
+
+    The integration error due to baseline noise is calculated as:
+
+    .. math::
+        error = \sigma_{vol} = \sigma \sqrt{\prod_i^{d} n_{i}},
+
+    if the noise_limits are set.
+
+    Where:
+    sigma is the standard deviation of the baseline noise. n is the number
+    of bins in the integration range for each d dimensions.
+
+    See integrate for more information.
+
+    Parameters
+    ----------
+    data: array like
+        1d array of intensity
+    unit_convs: [`fileiobase.unit_conversion`, ] list
+        list of unit_conversion object associated with each dim of data.
+    limits: array like
+        With shape (2,) or (d, 2). 1D Array with lower and upper integration
+        limits for 1D . Or array with d rows of lower and upper integration
+        limits for each dimension.
+    noise_limits: Optional[array like]
+        With shape(2, ). Array with lower and upper limits to section of data
+        with only noise. A larger range will likely yield a more accurate
+        estimate. It is unwise to use the very end of the spectrum for the
+        noise range.
+
+    Returns
+    -------
+    array
+        [value, ...] integration values
+
+    if noise_limits is given:
+
+    array
+        [[value, error], ...] where error a one sigma estimate of the error
+        only from the spectrum noise
+    """
+
+    # determine the dimensionality of the data.
+    d = np.ndim(data)
+
+    try:
+        iter(unit_conv)
+    except TypeError:
+        unit_conv = [unit_conv, ]
+
+    if d != len(unit_conv):
+        mesg = 'A unit_conversion object is needed for each dimension.'
+        raise ValueError(mesg)
+
+    limits = np.array(limits)
+    if limits.ndim == 1:
+        limits = np.expand_dims(limits, axis=0)
+
+    if limits.shape[0] != d and limits.shape[1] != 2:
+        mesg = 'A lower and upper limit is needed for each dimension.'
+        raise ValueError(mesg)
+
+    inds = [(uc(x[0], unit), uc(x[1], unit))
+            for (uc, x) in zip(unit_conv, limits)]
+    inds = [sorted(x) for x in inds]
+
+    # the integrate_nd needs to be scaled by the bin width in ppm
+    ppm_scales = [x.ppm_scale() for x in unit_conv]
+    dx = np.prod(np.array([abs(x[1]-x[0]) for x in ppm_scales]))
+
+    slice_sum = (data[tuple([slice(x[0], x[1]) for x in np.flipud(inds)])]).sum()
+
+    value = slice_sum * dx
+
+    if noise_limits is None:
+        return value
+
+    else:
+        noise_limits = np.array(noise_limits)
+        if noise_limits.size == 2:
+            noise_limits = np.expand_dims(noise_limits, axis=0)
+
+        if noise_limits.shape[0] != d and noise_limits.shape[1] != 2:
+            mesg = 'If given, a noise limit is needed for each dimension.'
+            raise ValueError(mesg)
+
+        noise_inds = [(uc(x[0], unit), uc(x[1], unit))
+                      for (uc, x) in zip(unit_conv, noise_limits)]
+        noise_inds = [sorted(x) for x in noise_inds]
+
+        # see docstring of integrate
+        nm = np.prod(np.array([abs(x[1]-x[0]) for x in noise_inds]))
+        std = np.std(data[[slice(x[0], x[1])for x in np.flipud(noise_inds)]])
+
+        error = std * np.sqrt(nm)
+        return np.hstack((value, error))