selecting x value as label for point selection should work

# Conflicts:
#	src/gui_qt/main/mainwindow.py

src/gui_qt/io/asciireader.py

@@ -133,7 +133,7 @@ class QAsciiReader(QtWidgets.QDialog, Ui_ascii_reader):
         if self.column_checkBox.isChecked() and self.line_spinBox.isEnabled():
             header_line = self.reader.header[self.line_spinBox.value()-1]
             header_line = header_line.strip('\n\t\r, ')
-            header_line = re.sub(r'[\t, ;]+(?!\w*})', ';', header_line)
+            header_line = re.sub(r'[\t ;,]+', ';', header_line)
 
             self.ascii_table.setHorizontalHeaderLabels(header_line.split(';'))
 

src/gui_qt/main/management.py

@@ -542,9 +542,7 @@ class UpperManagement(QtCore.QObject):
                     elif fit_limits[0] == 'in':
                         inside = np.where((_x >= fit_limits[1][0]) & (_x <= fit_limits[1][1]))
                     else:
-                        x_lim, _ = self.graphs[self.current_graph].ranges
+                        inside = np.where((_x < fit_limits[1][0]) | (_x > fit_limits[1][1]))
-                        inside_graph = (_x >= x_lim[0]) & (_x <= x_lim[1])
-                        inside = np.where(((_x < fit_limits[1][0]) | (_x > fit_limits[1][1])) & inside_graph)
 
                     try:
                         if isinstance(we, str):

src/nmreval/clib/diffusion.c

@@ -1,16 +0,0 @@
-/* integrands used in quadrature integration with scipy's LowLevelCallables */
-#include <math.h>
-
-double anistropicDiffusion(double x, void *user_data) {
-    double *c = (double *)user_data;
-
-    double q = c[0];
-    double t = c[1];
-    double d_perp = c[2];
-    double d_par = c[3];
-
-    double cos_theta = cos(x);
-    double sin_theta = sin(x);
-
-    return exp(-q * q * t * (d_par * cos_theta * cos_theta + d_perp * sin_theta * sin_theta)) * sin_theta;
-}

src/nmreval/distributions/helper.py

@@ -5,17 +5,6 @@ from ctypes import CDLL, c_double, c_void_p
 from ..lib.logger import logger
 
 
-diffusion_lib = None
-try:
-    diffusion_lib = CDLL(str(Path(__file__).parents[1] / 'clib' / 'diffusion.so'))
-
-    diffusion_lib.anistropicDiffusion.restype = c_double
-    diffusion_lib.anistropicDiffusion.argtypes = (c_double, c_void_p)
-
-    HAS_C_FUNCS = True
-except OSError:
-    HAS_C_FUNCS = False
-
 lib = None
 try:
     lib = CDLL(str(Path(__file__).parents[1] / 'clib' / 'integrate.so'))
@@ -50,8 +39,10 @@ try:
     lib.energyDistSuscImag.restype = c_double
     lib.energyDistSuscImag.argtypes = (c_double, c_void_p)
 
+
     HAS_C_FUNCS = True
     logger.info('Use C functions')
 except OSError:
     HAS_C_FUNCS = False
     logger.info('Use python functions')
+

src/nmreval/io/asciireader.py

@@ -49,7 +49,7 @@ class AsciiReader:
         with self.fname.open('r') as f:
             for i, line in enumerate(islice(f, len(self.header)+len(self.lines), num_lines)):
                 line = line.strip('\n\t\r, ')
-                line = re.sub(r'[\t, ;]+(?!\w*})', ';', line)
+                line = re.sub(r'[\t ;,]+', ';', line)
                 line = line.split(';')
 
                 try:
@@ -146,11 +146,10 @@ class AsciiReader:
             raw_data = raw_data.reshape((1, *raw_data.shape))
 
         if len(x) == 0 or raw_data.shape[2] == 1:
-            raw_data = raw_data.reshape(raw_data.shape[0], raw_data.shape[2], raw_data.shape[1])
+            _temp = np.zeros((raw_data.shape[0], raw_data.shape[1], raw_data.shape[2]+1))
-            # _temp = np.zeros((raw_data.shape[0], raw_data.shape[2], raw_data.shape[1]))
+            _temp[:, :, 0] = np.arange(raw_data.shape[1])
-            # _temp[:, :, 0] = np.arange(raw_data.shape[1])
+            _temp[:, :, 1:] = raw_data
-            # _temp[:, :, 1:] = raw_data
+            raw_data = _temp
-            # raw_data = _temp
 
             if y:
                 y = [i+1 for i in y]

src/nmreval/io/hdfreader.py

@@ -302,26 +302,15 @@ class HdfReader(HdfNode):
 
     def make_signal(self, node, flag: str = 'fid', value: str = None, group: str = None):
         if value is None:
-            data_name = node.name
             value = self._get_parameter_values(node, node.parameter)
         else:
             try:
-                data_name = f"{value}={node.parameter[value]}"
                 value = node.parameter[value]
             except KeyError:
-                print(node.title_parameter)
                 try:
-                    temp = node
+                    value = node.title_parameter[1][value]
-                    while value != temp.title_parameter[0][0]:
-                        if temp.parent is None:
-                            break
-                        temp = temp.parent
-
-                    value = temp.title_parameter[0][1]
-                    data_name = temp.name
                 except KeyError:
                     print(f'{value} is not a valid key for {node.name}')
-                    data_name = node.name
                     value = None
 
         if group is None:
@@ -354,11 +343,11 @@ class HdfReader(HdfNode):
         dw = float(index['dwelltime'])
         if flag == 'fid':
             x = np.arange(len(y)) * dw
-            ret = FID(x, y, name=data_name, value=value, group=group, filename=self.file.filename)
+            ret = FID(x, y, name=node.name, value=value, group=group, filename=self.file.filename)
 
         elif flag == 'spectrum':
             x = np.linspace(-1/dw, 1/dw, num=len(y))
-            ret = Spectrum(x, y, name=data_name, value=value, group=group, filename=self.file.filename)
+            ret = Spectrum(x, y, name=node.name, value=value, group=group, filename=self.file.filename)
         else:
             raise ValueError(f'{flag} unknown, use `fid` or `spectrum`.')
 

src/nmreval/models/basic.py

@@ -203,31 +203,6 @@ class Sinc:
         return c * np.sinc(((x-x0)/w)/np.pi)
 
 
-class Sigmoid:
-    type = 'Basic'
-    name = 'Sigmoid'
-    equation = 'C / [1 + exp(-a * (x - x_{0})] + y_{0}'
-    params = ['C', 'a', 'x_{0}', 'y_{0}']
-
-    @staticmethod
-    def func(x, c, a, x0, y0):
-        """
-        Sigmoid function
-
-        .. math::
-            y = C / [1 + exp(-a * (x - x_0))] + y_0
-
-        Args:
-            x (array_like): Input values
-            c (float): Prefactor
-            a (float): Steepness of the sigmoid
-            x0 (float): x position of the sigmoid's midpoint
-            y0 (float): y position of the sigmoid's midpoint
-
-        """
-        return c / (1 + np.exp(-a * (x - x0))) + y0
-
-
 class Sine:
     """
     Wavy sine function

src/nmreval/models/diffusion.py

@@ -1,11 +1,7 @@
-from ctypes import c_double, cast, c_void_p, pointer
-
 import numpy as np
-from scipy import special as special, LowLevelCallable
+from scipy import special as special
-from scipy.integrate import quad
 
 from ..utils import gamma
-from nmreval.distributions.helper import HAS_C_FUNCS, diffusion_lib
 
 
 class Diffusion:
@@ -107,36 +103,20 @@ class AnisotropicDiffusion(object):
             tp = x
             relax = np.exp(-(tp/trel)**brel)*np.exp(-(tp/trel)**brel)
 
-        q = g * nucleus * tp
+        q_squared = np.power(g * nucleus * tp, 2)
         t = 2 * tp / 3 + tm
+        z = np.sqrt(q_squared * (d_par - d_perp) * t)
         # Callaghan eq (6.89)
-        if HAS_C_FUNCS:
+        diffs = np.exp(-q_squared*t*d_perp) * special.erf(z) / z
-            # divide by 2 to normalize by integral sin(x), x=0..pi
-            diffusion_decay = AnisotropicDiffusion._integrate_c(q, t, d_perp, d_par) / 2
-        else:
-            z = np.sqrt(q**2 * (d_par - d_perp) * t)
-            diffusion_decay = np.exp(-q**2 * t * d_perp) * special.erf(z) / z
 
-        return m0 * diffusion_decay * relax
+        return m0 * diffs * relax
-
-    @staticmethod
-    def _integrate_c(q, t, d_perp, d_par) -> np.ndarray:
-        diffusion_decay = np.zeros_like(t)
-
-        for (i, t_i) in enumerate(t):
-            c = (c_double * 4)(q, t_i, d_perp, d_par)
-            user_data = cast(pointer(c), c_void_p)
-
-            diffusion_decay[i] = quad(LowLevelCallable(diffusion_lib.anistropicDiffusion, user_data), 0, np.pi, epsabs=1e-13)[0]
-
-        return diffusion_decay
 
 
 class Peschier:
     name = 'Diffusion + Cross-Relaxation'
     type = 'Diffusion'
     equation = r'Diffusion with cross-relax f(ast) \rightarrow s(low)'
-    params = ['M_{0}', 'D', 'T_{1f}', 'T_{1s}', 'k', 'p_{f}', 't_{ev}', 'g']
+    params = ['M_{0}', 'D', 'T_{1,f}', 'T_{1,s}', 'k', 'p_{f}', 't_{ev}', 'g']
     bounds = [(0, None), (0, None), (0, None), (0, None), (0, None), (0, None)]
     choices = [(r'\gamma', 'nucleus', gamma)]
 

src/nmreval/models/relaxation.py

@@ -75,7 +75,7 @@ class TwoSatRecAbsolute:
     type = 'Relaxation'
     name = 'Two-step relaxation (abs. int)'
     equation = r'M_{0} + \Sigma \DeltaM_{i}(1-exp(-(x/T_{1,i})^{\beta_{i}}))'
-    params = [r'\DeltaM_{1}', 'T_{11}', r'\beta_{1}', r'\DeltaM_{2}', 'T_{12}', r'\beta_{2}', 'M_{0}']
+    params = [r'\DeltaM_{1}', 'T_{1,1}', r'\beta_{1}', r'\DeltaM_{2}', 'T_{1,2}', r'\beta_{2}', 'M_{0}']
     choices = [('Type', 'is_inv', {'Saturation': False, 'Inversion': True})]
     bounds = [(0, None), (0, None), (0, 1), (0, None), (0, None), (0, 1), (None, None)]
 
@@ -92,7 +92,7 @@ class TwoSatRecRelative:
     name = 'Two-step relaxation (rel. int)'
     equation = r'M_{0} + \DeltaM[R(1-exp(-(x/T_{1,1})^{\beta_{1}})) + \n'\
                r'(1-R)(1-exp(-(x/T_{1,2})^{\beta_{2}}))]'
-    params = [r'\DeltaM', 'M_{0}', 'T_{11}', r'\beta_{1}', 'T_{12}', r'\beta_{2}', 'R']
+    params = [r'\DeltaM', 'M_{0}', 'T_{1,1}', r'\beta_{1}', 'T_{1,2}', r'\beta_{2}', 'R']
     choices = [('Type', 'kind', {'Saturation': 'sat', 'Inversion': 'inv'})]
     bounds = [(0, None), (None, None), (0, None), (0, 1), (0, None), (0, 1), (0, 1)]
 

src/nmreval/models/transitions.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import numpy as np
 from scipy import special as special
 

src/nmreval/models/wideline.py

@@ -3,42 +3,11 @@ try:
     from scipy.integrate import simpson
 except ImportError:
     from scipy.integrate import simps as simpson
+from numpy import pi
 
 from ..math.orientations import zcw_spherical as crystallites
 
 
-__all__ = ['CSA', 'Pake', 'SecCentralLine']
-
-
-def _make_broadening(x: np.ndarray, sigma: float, mode: str):
-    dx = x[1] - x[0]
-    _x = np.arange(len(x)) * dx
-    _x -= 0.5 * _x[-1]
-    if mode == 'l':
-        apd = 2 * sigma / (4*_x**2 + sigma**2) / np.pi
-    else:
-        ln2 = np.log(2)
-        apd = np.exp(-4*ln2 * (_x/sigma)**2) * 2 * np.sqrt(ln2/np.pi) / sigma
-    return apd
-
-
-def _make_bins(x: np.ndarray) -> np.ndarray:
-    bins = 0.5 * (x[1:] + x[:-1])
-    return np.r_[0.5 * (-x[1] + 3 * x[0]), bins, 0.5 * (3 * x[-1] - x[-2])]
-
-
-def _make_x(x: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
-    _x = x
-    dx = x[1:] - x[:-1]
-    dx = np.min(dx)
-    width = x[-1] - x[0]
-    _x = np.arange(width/dx - 1) * dx + x[0]
-
-    bins = (_x[1:] + _x[:-1]) / 2
-    bins = np.r_[_x[0]-dx/2, bins, _x[-1] + dx/2]
-    return _x, bins
-
-
 class Pake:
     type = 'Spectrum'
     name = 'Pake'
@@ -48,39 +17,38 @@ class Pake:
     choices = [('Broadening', 'broad', {'Gaussian': 'g', 'Lorentzian': 'l'})]
 
     @staticmethod
-    def func(
+    def func(x, c, delta, eta, sigma, t_pulse, broad='g'):
-            x: np.ndarray,
-            c: float,
-            delta: float,
-            eta: float,
-            sigma: float,
-            t_pulse: float,
-            broad: str = 'g',
-    ) -> np.ndarray:
         a, b, _ = crystallites(100000)
+        bins = 0.5 * (x[1:] + x[:-1])
+        bins = np.r_[0.5*(3*x[0]-x[1]), bins, 0.5*(3*x[-1]-x[-2])]
+
         omega = delta * 0.5 * (3*np.cos(b)**2 - 1 - eta * np.sin(b)**2 * np.cos(2*a))
-        x_used, bins = _make_x(x)
 
         s_left = np.histogram(omega, bins=bins)[0]
         s_right = np.histogram(-omega, bins=bins)[0]
         s = s_left + s_right
 
         if sigma != 0:
-            apd = _make_broadening(x_used, sigma, broad)
+            _x = np.arange(len(x))*(x[1]-x[0])
+            _x -= 0.5*_x[-1]
+
+            if broad == 'l':
+                apd = 2 * sigma / (4 * _x**2 + sigma**2) / pi
+            else:
+                apd = np.exp(-4 * np.log(2) * (_x/sigma)**2) * 2 * np.sqrt(np.log(2) / pi) / sigma
+
             ret_val = np.convolve(s, apd, mode='same')
+
         else:
             ret_val = s
-
+            
-        omega_1 = np.pi/2/t_pulse
+        omega_1 = pi/2/t_pulse
-        attn = omega_1 * np.sin(t_pulse*np.sqrt(omega_1**2 + 0.5*(2*np.pi*x_used)**2)) / np.sqrt(omega_1**2 + (np.pi*x_used)**2)
+        attn = omega_1 * np.sin(t_pulse*np.sqrt(omega_1**2+0.5*(2*pi*x)**2)) / \
+            np.sqrt(omega_1**2+(np.pi*x)**2)
 
         ret_val *= attn
-        ret_val /= simpson(y=ret_val, x=x_used)
 
-        if x_used.size == x.size:
+        return c * ret_val / simpson(ret_val, x)
-            return c * ret_val
-        else:
-            return c * np.interp(x=x, xp=x_used, fp=ret_val)
 
 
 class CSA:
@@ -92,29 +60,28 @@ class CSA:
     choices = [('Broadening', 'broad', {'Gaussian': 'g', 'Lorentzian': 'l'})]
 
     @staticmethod
-    def func(
+    def func(x, c, delta, eta, w_iso, sigma, broad='g'):
-            x: np.ndarray,
-            c: float,
-            delta: float,
-            eta: float,
-            w_iso: float,
-            sigma: float,
-            broad: str = 'g',
-    ) -> np.ndarray:
         a, b, _ = crystallites(100000)
+        bins = 0.5 * (x[1:] + x[:-1])
+        bins = np.r_[0.5*(-x[1] + 3*x[0]), bins, 0.5*(3*x[-1] - x[-2])]
 
         omega = w_iso + delta * 0.5 * (3*np.cos(b)**2 - 1 - eta * np.sin(b)**2 * np.cos(2*a))
 
-        s = np.histogram(omega, bins=_make_bins(x))[0]
+        s_left = np.histogram(omega, bins=bins)[0]
+        s = s_left
 
         if sigma != 0:
-            print(len(s))
+            _x = np.arange(len(x)) * (x[1] - x[0])
-            apd = _make_broadening(x, sigma, broad)
+            _x -= 0.5 * _x[-1]
+            if broad == 'l':
+                apd = 2 * sigma / (4*_x**2 + sigma**2) / pi
+            else:
+                apd = np.exp(-4 * np.log(2) * (_x / sigma) ** 2) * 2 * np.sqrt(np.log(2) / pi) / sigma
             ret_val = np.convolve(s, apd, mode='same')
         else:
             ret_val = s
 
-        return c * ret_val / simpson(y=ret_val, x=x)
+        return c * ret_val / simpson(ret_val, x)
 
 
 class SecCentralLine:
@@ -127,18 +94,10 @@ class SecCentralLine:
                ('Broadening', 'broad', {'Gaussian': 'g', 'Lorentzian': 'l'})]
 
     @staticmethod
-    def func(
+    def func(x, c, cq, eta, f_iso, gb, f_l, spin=2.5, broad='g'):
-            x: np.ndarray,
-            c: float,
-            cq: float,
-            eta: float,
-            f_iso: float,
-            gb: float,
-            f_l: float,
-            spin: float = 2.5,
-            broad: str = 'g',
-    ) -> np.ndarray:
         a, b, _ = crystallites(200000)
+        bins = 0.5 * (x[1:] + x[:-1])
+        bins = np.r_[0.5*(-x[1] + 3*x[0]), bins, 0.5*(3*x[-1] - x[-2])]
 
         # coupling constant
         omega_q = 2 * np.pi * cq / (2*spin*(2*spin-1))
@@ -157,12 +116,17 @@ class SecCentralLine:
         orient += prefactor_c
 
         omega = 2*np.pi*f_iso + coupling * orient
-        s = np.histogram(omega / (2*np.pi), bins=_make_bins(x))[0]
+        s = np.histogram(omega / (2*np.pi), bins=bins)[0]
 
         if gb != 0:
-            apd = _make_broadening(x, gb, broad)
+            _x = np.arange(len(x)) * (x[1]-x[0])
+            _x -= 0.5*_x[-1]
+            if broad == 'l':
+                apd = 2*gb / (4*_x**2 + gb**2) / np.pi
+            else:
+                apd = np.exp(-4*np.log(2) * (_x/gb)**2) * 2 * np.sqrt(np.log(2)/np.pi) / gb
             ret_val = np.convolve(s, apd, mode='same')
         else:
             ret_val = s
 
-        return c * ret_val / simpson(y=ret_val, x=x)
+        return c * ret_val / simpson(ret_val, x)