klassez 0.2.2.dev0__tar.gz → 0.3.1__tar.gz

{klassez-0.2.2.dev0 → klassez-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: klassez
-Version: 0.2.2.dev0
+Version: 0.3.1
 Summary: A collection of functions for NMR data handling
 Author: Letizia Fiorucci
 Author-email: Francesco Bruno <bruno@cerm.unifi.it>
@@ -22,6 +22,7 @@ Requires-Dist: seaborn
 Requires-Dist: nmrglue
 Requires-Dist: matplotlib>=3.8
 Requires-Dist: csaps
+Requires-Dist: pyyaml
 Provides-Extra: jeolproc
 Requires-Dist: jeol_parser; extra == "jeolproc"
 Provides-Extra: docs

{klassez-0.2.2.dev0 → klassez-0.3.1}/docs/requirements.txt

@@ -8,3 +8,4 @@ seaborn
 nmrglue
 matplotlib>=3.8
 csaps
+pyyaml

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez/Spectra.py

@@ -128,7 +128,7 @@ class Spectrum_1D:
         isexp : bool
             True if this is an experimental dataset, False if it is simulated
         spect : str
-            Data file format. Allowed: ``'bruker'``, ``'varian'``, ``'magritek'``, ``'oxford'``, ``'jeol'``
+            Data file format. Allowed: ``'bruker'``, ``'varian'``, ``'magritek'``, ``'oxford'``, ``'jeol'``, ``'nana'``
 
         Returns
         -------
@@ -412,6 +412,7 @@ class Spectrum_1D:
             :func:`klassez.processing.apk`
         """
 
+        q = deepcopy(self.S)
         self.S, (p0, p1) = processing.apk(self.ppm, self.S, self.acqus['SFO1'], alpha, winsize, ap1)
 
         if update:
@@ -594,7 +595,7 @@ class Spectrum_1D:
     def write_acqus(self, other_dir=None):
         """
         Write the acqus dictionary in a file named ``<self.filename>.acqus``.
-        Calls :func:`klassez.misc.write_acqus_1D`
+        Calls :func:`klassez.misc.write_acqus`
 
         Parameters
         ----------
@@ -607,13 +608,13 @@ class Spectrum_1D:
 
         .. seealso::
 
-            :func:`klassez.misc.write_acqus_1D`
+            :func:`klassez.misc.write_acqus`
         """
         if other_dir:
-            path = Path(other_dir) / f'{self.filename}.acqus'
+            path = Path(other_dir) / f'{self.filename}'
         else:
-            path = self.datadir / f'{self.filename}.acqus'
-        misc.write_acqus_1D(self.acqus, path=path)
+            path = self.datadir / f'{self.filename}'
+        misc.write_acqus(self.acqus, filename=path, ext='acqus')
 
     def write_procs(self, other_dir=None):
         """
@@ -632,7 +633,7 @@ class Spectrum_1D:
             path = Path(other_dir) / f'{self.filename}'
         else:
             path = self.datadir / f'{self.filename}'
-        path.with_suffix('.procs').write_text(f'{self.procs}')
+        misc.write_yml(self.procs, path, ext='procs')
 
     def read_procs(self, other_dir=None):
         """
@@ -653,10 +654,10 @@ class Spectrum_1D:
             Dictionary of processing parameters
         """
         if other_dir:
-            path = Path(other_dir) / f'{self.filename}.procs'
+            path = Path(other_dir) / f'{self.filename}'
         else:
-            path = self.datadir / f'{self.filename}.procs'
-        procs = eval(path.read_text().replace('array', 'np.array'))
+            path = self.datadir / f'{self.filename}'
+        procs = misc.read_yml(path.with_suffix('.procs'))
         # Check if it was read correctly
         if isinstance(procs, dict):
             return procs
@@ -1276,7 +1277,11 @@ class Spectrum_2D:
         self.datadir, self.filename = misc.get_datadir_filename(in_file, isexp)
 
         if isexp is False:   # Simulate the data
-            self.acqus = sim.load_sim_2D(in_file)   # Read the acqus dictionary from the file
+            if isinstance(in_file, dict):   # using the provided dictionary
+                self.acqus = deepcopy(in_file)
+            else:   # or building it from the file
+                self.acqus = sim.load_sim_2D(in_file)
+            # Generate the FID
             self.acqus['FnMODE'] = 'States-TPPI'
             self.acqus['GRPDLY'] = 0
             self.fid = sim.sim_2D(in_file, pv=pv)   # Read the FID
@@ -2006,7 +2011,7 @@ class Spectrum_2D:
     def write_acqus(self, other_dir=None):
         """
         Write the ``acqus`` dictionary in a file named "filename.acqus".
-        Calls :func:`klassez.misc.write_acqus_1D`
+        Calls :func:`klassez.misc.write_acqus`
 
         Parameters
         ----------
@@ -2019,14 +2024,14 @@ class Spectrum_2D:
 
         .. seealso::
 
-            :func:`klassez.misc.write_acqus_1D`
+            :func:`klassez.misc.write_acqus`
         """
         if other_dir:
             path = Path(other_dir) / f'{self.filename}'
         else:
             path = self.datadir / f'{self.filename}'
 
-        misc.write_acqus_2D(self.acqus, path=path.with_suffix('.acqus'))
+        misc.write_acqus(self.acqus, filename=path, ext='acqus')
 
     def write_procs(self, other_dir=None):
         """
@@ -2045,7 +2050,7 @@ class Spectrum_2D:
             path = Path(other_dir) / f'{self.filename}'
         else:
             path = self.datadir / f'{self.filename}'
-        path.with_suffix('.procs').write_text(f'{self.procs}')
+        misc.write_yml(self.procs, path, ext='procs')
 
     def read_procs(self, other_dir=None):
         """
@@ -2066,10 +2071,10 @@ class Spectrum_2D:
             Dictionary of processing parameters
         """
         if other_dir:
-            path = Path(other_dir) / f'{self.filename}.procs'
+            path = Path(other_dir) / f'{self.filename}'
         else:
-            path = self.datadir / f'{self.filename}.procs'
-        procs = eval(path.read_text().replace('array', 'np.array'))
+            path = self.datadir / f'{self.filename}'
+        procs = misc.read_yml(path.with_suffix('.procs'))
         # Check if it was read correctly
         if isinstance(procs, dict):
             return procs
@@ -2200,6 +2205,7 @@ class Spectrum_2D:
             label = f'{a:.2f}:{b:.2f}'
         # Compute the trace
         f2 = anal.get_trace(self.rr, self.ppm_f2, self.ppm_f1, a, b, column=False)
+        f2 = processing.hilbert(f2)
         # Store it
         self.trf2[label] = f2
         self.Trf2[label] = pSpectrum_1D(f2, acqus=misc.split_acqus_2D(self.acqus)[1], procs=misc.split_procs_2D(self.procs)[1], istrace=True, filename=f'T2_{label}')
@@ -2839,6 +2845,79 @@ class Pseudo_2D(Spectrum_2D):
 
         return values
 
+    def adjph_rw(self, auto=True, alpha=3, winsize=50, ap1=True, from_procs=True, update=True):
+        """
+        Performs automatic phase correction of each transient independently.
+        The values are saved in ``self.procs['phtr']``.
+
+        Parameters
+        ----------
+        auto : bool
+            ``True`` for using :func:`klassez.processing.apk`, ``False`` to phase each transient manually.
+        alpha : float
+            Factor that multiplies the std of the spectrum to set the threshold
+        winsize : float
+            Minimum size of the window that can contain peaks /Hz
+        ap1 : bool
+            ``True`` to adjust both zero and first order, ``False`` for only phase zero
+        from_procs : bool
+            If ``True``, uses the values in ``self.procs['phtr']``
+        update : bool
+            Choose if to update the ``procs`` dictionary or not
+
+        Returns
+        -------
+        phases : 2darray
+            Employed values for each transient, in the form ``[p0, p1, pivot]``.
+
+
+        .. seealso::
+
+            :func:`klassez.processing.apk`
+
+            :func:`klassez.processing.adjph_rowwise`
+        """
+        newS = deepcopy(self.S)
+        # If there is not the correct key in procs, act like from_procs is False
+        if 'phtr' not in self.procs:
+            from_procs = False
+
+        if from_procs:
+            # Key found
+            print('Phase correction row-wise applied with values from procs.', c='violet')
+            # Copy to avoid conflict when calling write_procs at the end with update=True
+            phases = np.asarray(deepcopy(self.procs['phtr']))
+
+            for k, transient in enumerate(self.S):
+                # Unpack the values
+                p0, p1, pv = phases[k]
+                # Apply the correction
+                newS[k], *_ = processing.ps(transient, self.ppm_f2, p0=p0, p1=p1, pivot=pv)
+
+        elif auto:      # from_procs = False and auto = True
+            # Calls the correct function in processing
+            newS, phases = processing.adjph_rowwise(self.ppm_f2, self.S, self.acqus['SFO1'],
+                                                      alpha=alpha, winsize=winsize, ap1=ap1)
+
+        else:           # from_procs = False and auto = False
+            # Placeholder
+            phases = []
+            for k, transient in enumerate(self.S):
+                print(f'Phasing transient {k+1} of {self.S.shape[0]}', c='violet')
+                # Call manual phase correction in interactive panel
+                newS[k], values = processing.ps(transient, self.ppm_f2)
+                phases.append(values)
+            # Make array to avoid conflict
+            phases = np.asarray(phases)
+
+        self.S = newS
+        if update:
+            # Add/replace the key in procs and write the file
+            self.procs['phtr'] = np.array([vvv for vvv in phases.tolist()])
+            self.write_procs()
+
+        return phases
+
     def pknl(self):
         """
         Reverses the effect of the digital filter by applying a first order phase correction.
@@ -2916,6 +2995,7 @@ class Pseudo_2D(Spectrum_2D):
             label = f'{a:.2f}:{b:.2f}'
         # Compute the trace
         f2 = anal.get_trace(self.rr, self.ppm_f2, self.ppm_f1, a, b, column=False)
+        f2 = processing.hilbert(f2)
         # Store it
         self.trf2[label] = f2
         self.Trf2[label] = pSpectrum_1D(f2, acqus=self.acqus, procs=self.procs, istrace=True)
@@ -3867,7 +3947,7 @@ class DOSY_T1:
             path = Path(other_dir) / f'{self.filename}'
         else:
             path = self.datadir / f'{self.filename}'
-        path.with_suffix('.procs').write_text(f'{self.procs}')
+        misc.write_yml(self.procs, path, ext='procs')
 
     def read_procs(self, other_dir=None):
         """
@@ -3891,7 +3971,7 @@ class DOSY_T1:
             path = Path(other_dir) / f'{self.filename}.procs'
         else:
             path = self.datadir / f'{self.filename}.procs'
-        procs = eval(path.read_text().replace('array', 'np.array'))
+        procs = misc.read_yml(path.with_suffix('.procs'))
         # Check if it was read correctly
         if isinstance(procs, dict):
             return procs
@@ -3996,7 +4076,7 @@ class DOSY_T1:
         figures.plot_p3D(x_f1, x_f2, idx_scale, self.S.real, dim=dim, Neg=Neg,
                          name=name, X_label=X_label, Y_label=Y_label, lvl0=lvl0)
 
-    def integrate(self, filename=None):
+    def integrate(self, filename=None, keys=None):
         """
         Create the attribute ``self.D`` as ``klassez.fit.DosyFit_pp3D``, and integrate the planes along the `31` direction.
 
@@ -4004,6 +4084,8 @@ class DOSY_T1:
         ----------
         filename : str or None
             Custom filename for data and plots. If ``None``, ``self.filename`` is used.
+        keys : list of str
+            Keys that identify the regions to integrate. If None, the integration is performed interactively through GUI
 
         Returns
         -------
@@ -4017,4 +4099,98 @@ class DOSY_T1:
         if filename is None:
             filename = self.filename
         filename = Path(filename)
-        self.D = fit.DosyFit_pp3D(self, datadir=filename, filename=filename)
+        self.D = fit.DosyFit_pp3D(self, datadir=filename, filename=filename, keys=keys)
+
+
+class DOSY_SSel(DOSY_T1):
+    """
+    Class: 3D DOSY spectrum
+
+    It should be acquired with the sequence described in
+    `Novakovic M. et al. (2025), Nature Communications, 16(1), 4628`_,
+    Supporting Information, Figure 12a.
+    This sequence, adapted in the pulse program ``stebpgp1s193D.rav``,
+    evolves the big delta (``d20``) in dimension F2 and the gradient strength according to
+    the `difflist` in dimension F1.
+    This sequence is actually equivalent to acquiring separate DOSY with different ``d20``.
+
+
+    .. _Novakovic M. et al. (2025), Nature Communications, 16(1), 4628: https://www.nature.com/articles/s41467-025-59759-2
+
+    Attributes
+    ----------
+    datadir : str
+        Path to the input file/dataset directory
+    filename : str
+        Base of the name of the file, without extensions
+    fid : 3darray
+        FID
+    acqus : dict
+        Dictionary of acqusition parameters
+    ngdic : dict
+        Created only if it is an experimental spectrum. Generated by :func:`nmrglue.<spectrometer>.read`, contains all the information on the spectrometer and on the spectrum.
+    procs : dict
+        Dictionary of processing parameters
+    S : 3darray
+        Complex (or hypercomplex, depending on ``FnMODE``) spectrum
+    x_f1 : 1darray
+        gradient list
+    x_f2 : 1darray
+        big delta list
+    freq_f2 : 1darray
+        Frequency scale of the direct dimension, in Hz
+    ppm_f2 : 1darray
+        ppm scale of the direct dimension
+    """
+
+    def __init__(self, in_file):
+        """
+        Initialize the class.
+
+        Parameters
+        ----------
+        in_file : str
+            path to file to read, or to the folder of the spectrum
+        """
+        self.datadir, self.filename = misc.get_datadir_filename(in_file, isexp=True)
+
+        with warnings.catch_warnings():   # Suppress errors due to CONVDTA in TopSpin
+            warnings.simplefilter("ignore")
+            # Read the data, acquisition parameters...
+            dic, data = ng.bruker.read(in_file, cplex=True)
+            self.ngdic = dic
+            self.fid = data
+            self.acqus = misc.makeacqus_pp3D(dic)
+            self.fid = np.reshape(self.fid, (self.acqus['TD1'], self.acqus['TD2'], -1))
+            self.acqus['BYTORDA'] = dic['acqus']['BYTORDA']
+            self.acqus['DTYPA'] = dic['acqus']['DTYPA']
+
+            del dic
+            del data
+
+        # Get group delay points
+        try:
+            self.acqus['GRPDLY'] = int(self.ngdic['acqus']['GRPDLY'])
+        except Exception:
+            self.acqus['GRPDLY'] = 0
+
+        # Load the difflist
+        self.x_f1 = np.loadtxt(self.datadir / 'difflist')
+        self.label_f1 = r'Gradient /G cm$^{-1}$'
+
+        # Load the F2 list
+        #   It should be the only file in lists/vd/ but we do not know its name
+        fqlistpath = next((self.datadir / 'lists' / 'f1').iterdir())
+        #   Print a notification
+        print(f'Found {fqlistpath} to be imported as FQLIST', c='tab:blue')
+        #   Actual loading and storage in an attribute
+        fqlist = np.loadtxt(fqlistpath)
+        self.x_f2 = fqlist
+        self.label_f2 = 'Freq /Hz'
+
+        # Procs dictionary
+        if (self.datadir / self.filename).with_suffix('.procs').exists():
+            self.procs = self.read_procs()
+        else:
+            self.procs = self._default_procs(self.acqus)
+            self.write_procs()

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez/__init__.py

@@ -17,4 +17,4 @@ from .config import CM, CM_2D, COLORS, cron, safe_kws, textcolor, _print, cprint
 
 print = cprint
 
-__version__ = "0.2.2.dev0"
+__version__ = "0.3.1"

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez/fit.py

@@ -5830,7 +5830,7 @@ class DosyFit_pp3D(fit.DosyFit):
         Same structure and shape of ``self.i_guess``
 
     """
-    def __init__(self, S, datadir=None, filename=None):
+    def __init__(self, S, datadir=None, filename=None, keys=None):
         """
         Initialize the class.
         This function will slice ``S`` along the DOSY dimension (`31`) and store the planes in the ``self.planes`` attribute.
@@ -5845,6 +5845,8 @@ class DosyFit_pp3D(fit.DosyFit):
             Custom path where to save files and figures. If ``None``, *./``filename``* is created
         filename : str
             Custom filename for files and figures. If ``None``, ``S.filename`` is used.
+        keys : list of str
+            Keys that identify the regions to integrate. If None, the integration is performed interactively through GUI
         """
         # Filename
         if filename is None:    # Same name of the input dataset
@@ -5871,7 +5873,7 @@ class DosyFit_pp3D(fit.DosyFit):
         self.planes = [S.getplane(k, dim='31') for k in range(len(S.x_f2))]
 
         # Compute the integrals for all the planes
-        self.integrate_planes()
+        self.integrate_planes(keys=keys)
 
     def integrate_planes(self, keys=None, use_bas=False):
         """

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez/misc.py

@@ -8,6 +8,7 @@ import scipy.io.wavfile as WF
 import math
 import warnings
 import scipy.linalg as slinalg
+import yaml
 from copy import deepcopy
 from pathlib import Path
 
@@ -74,7 +75,7 @@ def read_fid_acqus_1D(in_file, spect='bruker'):
     in_file : str or Path
         Path where to find the data
     spect : str
-        Data format. Valid options are: ``'bruker'``, ``'varian'``, ``'magritek'``, ``'oxford'``, ``'jeol'``
+        Data format. Valid options are: ``'bruker'``, ``'varian'``, ``'magritek'``, ``'oxford'``, ``'jeol'``, ``'nana'``
 
     Returns
     -------
@@ -129,6 +130,13 @@ def read_fid_acqus_1D(in_file, spect='bruker'):
         data = cplx[0] + 1j*cplx[1]
         return data, acqus, dic
 
+    def read_nana(path):
+        """ .dx files nanalysis """
+        dic, cplx = ng.jcampdx.read(path)
+        acqus = misc.makeacqus_1D_nana(dic)
+        data = cplx[0] + 1j*cplx[1]
+        return data, acqus, dic
+
     def read_jeol(path):
         """ Jeol files """
         dic = jeol_parser.parse(path)
@@ -158,6 +166,8 @@ def read_fid_acqus_1D(in_file, spect='bruker'):
                 fid, acqus, ngdic = read_magritek(in_file)
             case 'oxford':
                 fid, acqus, ngdic = read_oxford(in_file)
+            case 'nana':
+                fid, acqus, ngdic = read_nana(in_file)
             case 'jeol':
                 fid, acqus, ngdic = read_jeol(in_file)
             case _:
@@ -166,10 +176,11 @@ def read_fid_acqus_1D(in_file, spect='bruker'):
     # Add the file version to acqus
     acqus['spect'] = spect
     # Look for group delay points: if there are not, put it to 0
-    try:
-        acqus['GRPDLY'] = int(ngdic['acqus']['GRPDLY'])
-    except Exception:
-        acqus['GRPDLY'] = 0
+    if 'GRPDLY' not in acqus.keys():
+        try:
+            acqus['GRPDLY'] = int(ngdic['acqus']['GRPDLY'])
+        except Exception:
+            acqus['GRPDLY'] = 0
 
     return fid, acqus, ngdic
 
@@ -339,6 +350,7 @@ def makeacqus_1D_spinsolve(dic):
 def makeacqus_1D_oxford(dic):
     """
     Given a NMRGLUE dictionary from a 1D spectrum (generated by :func:`nmrglue.jcampdx.read`), this function builds the acqus file with only the "important" parameters.
+    For Oxford Instruments benchtop NMR.
 
     Parameters
     ----------
@@ -371,6 +383,41 @@ def makeacqus_1D_oxford(dic):
     return acqus
 
 
+def makeacqus_1D_nana(dic):
+    """
+    Given a NMRGLUE dictionary from a 1D spectrum (generated by :func:`nmrglue.jcampdx.read`), this function builds the acqus file with only the "important" parameters.
+    For NANALYSIS benctop NMR
+
+    Parameters
+    ----------
+    dic : dict
+        NMRglue dictionary returned by ng.jcampdx.read
+
+    Returns
+    -------
+    acqus : dict
+        Dictionary with only few parameters
+    """
+    acqus = {}
+
+    acqus['nuc'] = dic['.OBSERVENUCLEUS'][-1].replace('^', '')
+    acqus['SFO1'] = eval(dic['$SFO1'][-1])
+    acqus['SW'] = eval(dic['$SWH'][-1])
+    acqus['TD'] = int(eval(dic['$TD'][-1]) // 2)  # Fuckin' Nana
+    acqus['o1'] = eval(dic['$O1'][-1])
+
+    acqus['SWp'] = acqus['SW'] / np.abs(acqus['SFO1'])
+    acqus['B0'] = acqus['SFO1'] / sim.gamma[acqus['nuc']]
+    acqus['o1p'] = acqus['o1'] / acqus['SFO1']
+    acqus['dw'] = 1 / acqus['SW']
+    acqus['t1'] = np.linspace(0, acqus['TD']*acqus['dw'], acqus['TD'])
+    acqus['AQ'] = acqus['t1'][-1]
+    acqus['fidres'] = 1 / (acqus['TD'] * acqus['dw'])
+
+    acqus['GRPDLY'] = - eval(dic['$GRPDLY'][-1])
+    return acqus
+
+
 def makeacqus_1D_jeol(dic):
     """
     Given a dictionary from a 1D spectrum (generated by ``jeol_parser.parse``), this function builds the acqus file with only the "important" parameters.
@@ -496,7 +543,7 @@ def makeacqus_pp3D(dic):
     return acqus
 
 
-def write_acqus_1D(acqus, path='sim_in_1D'):
+def write_acqus(acqus, filename='sim_in', ext='acqus'):
     """
     Writes the input file for a simulated spectrum, basing on a dictionary of parameters.
 
@@ -504,51 +551,29 @@ def write_acqus_1D(acqus, path='sim_in_1D'):
     ----------
     acqus : dict
         The dictionary containing the parameters for the simulation
-    path : str, optional
+    filename : str
         Directory where the file will be saved.
+    ext : str
+        Extension of the filename
     """
-    f = open(path, 'w')
-    keylist = acqus.keys()
-    for key in keylist:
-        if key[:1] == 't':
-            pass
-        else:
-            if isinstance(acqus[key], (list, tuple)):
-                f.write('{}\t'.format(key))
-                for w in acqus[key]:
-                    f.write('{}, '.format(w))
-                f.write('\n')
-            else:
-                f.write('{}\t{}\n'.format(key, acqus[key]))
-
-    f.close()
+    path = Path(filename)
 
+    # Remove the acquistion timescales as they can be recomputed easily
+    exclude = ['t1', 't2', 't3']
+    acqus_to_write = {key: value for key, value in acqus.items()
+                      if key not in exclude}
 
-def write_acqus_2D(acqus, path='sim_in_2D'):
-    """
-    Writes the input file for a simulated spectrum, basing on a dictionary of parameters.
+    # If there are the parameters for the simulated peaks, move them at the end
+    if 'shifts' in acqus.keys():
+        move = ['shifts', 'fwhm', 'amplitudes', 'b', 'phases', 'mult', 'Jconst', ]
+        reordered = {k: v for k, v in acqus_to_write.items()
+                     if k not in move}
+        for key in move:
+            if key in acqus_to_write:
+                reordered[key] = acqus_to_write[key]
+        acqus_to_write = reordered
 
-    Parameters
-    ----------
-    acqus : dict
-        The dictionary containing the parameters for the simulation
-    path : str, optional
-        Directory where the file will be saved.
-    """
-    f = open(path, 'w')
-    keylist = acqus.keys()
-    for key in keylist:
-        if key[:1] == 't':
-            pass
-        else:
-            if isinstance(acqus[key], (list, tuple)):
-                f.write('{}\t'.format(key))
-                for w in acqus[key]:
-                    f.write('{}, '.format(w))
-                f.write('\n')
-            else:
-                f.write('{}\t{}\n'.format(key, acqus[key]))
-    f.close()
+    misc.write_yml(acqus_to_write, path, ext, sort_keys=False)
 
 
 def calcres(fqscale):
@@ -1901,3 +1926,75 @@ def get_extent(data):
         ``max(data) - min(data)``
     """
     return np.max(data) - np.min(data)
+
+
+def safe_convert(obj):
+    """
+    Transforms strange pythonic objects like
+    numpy arrays and scalars into something writable.
+    """
+    # Called in loop in order to work also for nested objects
+    if isinstance(obj, dict):               # for dictionaries
+        return {k: safe_convert(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple, set)):  # for lists
+        return [safe_convert(v) for v in obj]
+    if isinstance(obj, np.ndarray):         # for arrays
+        return safe_convert(obj.tolist())
+    if isinstance(obj, np.generic):         # for np.float64 and similar
+        return obj.item()
+    return obj
+
+
+def write_yml(obj, filename, ext='yml', sort_keys=True):
+    """
+    Write ``obj`` in a yml-styled text file, with one entry per line.
+
+    Parameters
+    ----------
+    obj : list or dict
+        Object to write
+    filename : str or Path
+        Path for the file to write
+    ext : str
+        Extension of the filename
+    sort_keys : bool
+        ``False`` to keep the insertion order
+
+    Returns
+    -------
+    None
+
+    .. seealso::
+
+        :func:`klassez.misc.read_yml`
+
+    """
+
+    # Convert if str, then add/replace correct extension
+    path = Path(filename).with_suffix(f'.{ext}')
+    # Open file and write
+    with path.open('w') as f:
+        # default_flow_style if True writes all obj in only one line
+        yaml.safe_dump(misc.safe_convert(obj), f,
+                       default_flow_style=False,
+                       sort_keys=sort_keys)
+
+
+def read_yml(filename):
+    """
+    Reads a yml-styled text file.
+
+    Parameters
+    ----------
+    filename : str or Path
+        Path to the file to be read
+
+    Returns
+    -------
+    obj : object
+        Read file
+    """
+    path = Path(filename)
+    with path.open('r') as f:
+        obj = yaml.safe_load(f)
+    return obj

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez/processing.py

@@ -2701,7 +2701,7 @@ def rpbc(data, split_imag=False, n=5, basl_method='huber', basl_thresh=0.2, basl
 
         :func:`klassez.fit.SINC_phase`
 
-        :func:`klassez.processing.polyn_basl`
+        :func:`klassez.fit.polyn_basl`
 
         :class:`klassez.fit.CostFunc`
     """
@@ -2881,14 +2881,15 @@ def align(ppm_scale, data, lims, u_off=0.5, ref_idx=0):
 
         # Circular-shift the spectrum (first shift then abs)
         roll_s = np.abs(processing.roll_dirac(s, ppm_scale, par['u']))
-        # Compute its integral
-        int_roll_s = processing.integral(roll_s)
 
         # Normalize the spectra in the calibration region
         A, _ = fit.fit_int(s_ref_abs, roll_s, q=0)
         roll_s *= A
-        A_int, _ = fit.fit_int(int_s_ref, int_roll_s, q=0)
-        int_roll_s *= A_int
+        # Compute its integral
+        int_roll_s = processing.integral(roll_s)
+        if 0:
+            A_int, _ = fit.fit_int(int_s_ref, int_roll_s, q=0)
+            int_roll_s *= A_int
 
         # Compute the residuals
         res = s_ref_abs - roll_s
@@ -3430,6 +3431,10 @@ def apk(ppm, data, SFO1, alpha=3, winsize=50, ap1=True, seethrough=False):
 
     # -----------------------------------------------------------------------------------
 
+    if not np.iscomplexobj(data):
+        # TODO warning
+        data = processing.hilbert(data)
+
     # Get the peak-only regions
     slices, _ = processing.mask_sgn_basl(ppm, data, SFO1, alpha, winsize)
 
@@ -3448,7 +3453,11 @@ def apk(ppm, data, SFO1, alpha=3, winsize=50, ap1=True, seethrough=False):
         plt.show()
 
     # Smooth the data with a 5 Hz gaussian filter
-    gbdata = processing.smooth_g(data, 1/misc.hz2pt(misc.ppm2freq(ppm, SFO1), 5))
+    fqscale = misc.ppm2freq(ppm, SFO1)
+    # Minimum must be 1 pt width otherwise error div by 0
+    fw_min_width = misc.calcres(fqscale)
+    fw = max(fw_min_width, misc.hz2pt(fqscale, 5))
+    gbdata = processing.smooth_g(data, 1/fw)
     # Phase each region independently with only p0
     p0s = phase0(gbdata, slices)
 
@@ -3491,7 +3500,7 @@ def apk(ppm, data, SFO1, alpha=3, winsize=50, ap1=True, seethrough=False):
         p1 = 0
 
     # Apply the correction
-    datap, *_ = processing.ps(data, p0=p0, p1=p1)
+    datap, *_ = processing.ps(data, ppm, p0=p0, p1=p1)
 
     print('APK: p0: {:.3f}, p1: {:.3f}\n'.format(p0, p1), c='violet')
 
@@ -4338,3 +4347,55 @@ def roll_dirac(y, x, off=0, onfid=False):
         y_t_roll = y_t * dirac_t
         y_roll = processing.ft(y_t_roll)
     return y_roll
+
+
+def adjph_rowwise(ppm, data, SFO1, alpha=3, winsize=50, ap1=True):
+    """
+    Performs automatic phase correction of a pseudo_2D dataset, with :func:`klassez.processing.apk`, each row independently.
+    Returns the phased spectrum and the employed values.
+
+    Parameters
+    ----------
+    ppm : 1darray
+        ppm scale of the spectrum
+    data : 2darray
+        Spectrum
+    SFO1 : float
+        Nucleus' Larmor frequency /MHz
+    alpha : float
+        Factor that multiplies the std of the spectrum to set the threshold
+    winsize : float
+        Minimum size of the window that can contain peaks /Hz
+    ap1 : bool
+        True to adjust both zero and first order, False for only phase zero
+
+    Returns
+    -------
+    new_data : 2darray
+        Phased spectrum
+    phases : 2darray
+        Employed values for phasing, in the form ``[p0, p1, pivot]``
+
+    .. seealso::
+
+        :func:`klassez.processing.apk`
+    """
+    # Make a shallow copy while checking to have the imaginary part
+    if np.iscomplexobj(data):
+        new_data = deepcopy(data)
+    else:
+        warnings.warn('data is not complex. Performing Hilbert transform.', stacklevel=3)
+        new_data = processing.hilbert(data)
+
+    # Placeholder
+    phases = []
+    # Start the loop
+    for k, transient in enumerate(new_data):
+        print(f'Phasing transient {k+1} of {new_data.shape[0]}', c='violet')
+        # Call apk for each transient and save the values
+        new_data[k], values = processing.apk(ppm, transient, SFO1, alpha=alpha, winsize=winsize, ap1=ap1)
+        phases.append(values)
+
+    # apk uses as pivot the mean of the ppm scale --> add this info
+    phases = np.column_stack([phases, [round(np.mean(ppm), 3) for w in range(data.shape[0])]])
+    return new_data, phases

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez/sim.py

@@ -2,7 +2,9 @@
 
 import sys
 import numpy as np
-
+from copy import deepcopy
+import re
+import ast
 from importlib.resources import open_text, files
 from pathlib import Path
 from scipy import special
@@ -120,13 +122,13 @@ def multiplet(u, Int, m='s', J=[]):
     return u_in, I_in
 
 
-def load_sim_1D(File):
+def load_sim_1D(filename):
     """
     Creates a dictionary from the spectral parameters listed in the input file.
 
     Parameters
     ----------
-    File : str
+    filename : str
         Path to the input file location
 
     Returns
@@ -134,51 +136,56 @@ def load_sim_1D(File):
     dic : dict
         Dictionary of the parameters, ready to be read from the simulation functions.
     """
-    inp = Path(File).read_text().splitlines(keepends=True)
-    keys = []
-    vals = []
-    for i in range(len(inp)):
-        if inp[i] == '\n' or inp[i][0] == '#':
-            continue    # skip empty lines or comments
-        inp[i] = inp[i].replace('\t', ' ')
-        line = inp[i].split(' ', 1)    # separate key from the rest
-        line[0] = line[0].replace(' ', '')
-        line[0] = line[0].replace('x_g', 'b')
-        keys.append(line[0])
-
-        rest = line[1].strip()
-        if '#' in rest:
-            rest = rest.split('#')[0]
-        try:
-            value = eval(rest)
-        except Exception:
-            value = (f'{rest}')
-        vals.append(value)
-
-    dic = {}
-    for i, key in enumerate(keys):
-        if 'nuc' in key:    # Remove unwanted spaces
-            vals[i] = vals[i].replace(' ', '')
-        dic[key] = vals[i]
-    if 'phases' not in keys:
-        dic['phases'] = tuple([0 for w in dic['shifts']])
-    else:
-        dic['phases'] = tuple([w * np.pi / 180 for w in dic['phases']])
-    if 'mult' not in keys:      # Multiplicity
-        dic['mult'] = tuple(['s' for w in dic['shifts']])
-    else:
-        dic['mult'] = tuple(dic['mult'].strip(',').replace(' ', '').split(','))
-    if 'Jconst' not in keys:    # Coupling constants
-        dic['Jconst'] = tuple([0 for w in dic['shifts']])
-
+    # Remove tabulations because they kill everything
+    path = Path(filename)
+    text = path.read_text()
+    if '\t' in text:
+        text = text.replace('\t', 4*' ')
+        with path.open('w') as f:
+            f.write(text)
+
+    # Make the dictionary
+    dic = misc.read_yml(path)
+    # Correct aliases
+    alias = {'shifts': 'cs', 'fwhm': 'lw', 'amplitudes': 'A', 'b': 'x_g',
+             'phases': 'ph', 'mult': 'm', 'Jconst': 'J', }
+    newdic = deepcopy(dic)
+    for key, item in alias.items():
+        if item in dic:
+            newdic[key] = dic[item]
+            newdic.pop(item)
+    dic = newdic
+
+    # Check if the mandatory keys are all there
+    for key in ['shifts', 'fwhm', 'amplitudes']:
+        if key not in dic:
+            raise NameError(f'Missing {key} in the input file.')
+    # Add the non-mandatory keys if missing with default values
+    defaults = {'b': 0, 'phases': 0, 'mult': 's', 'Jconst': 0, }
+    for key in alias:
+        # Check if there is
+        if key in dic:
+            if key == 'mult':
+                # ddd --> "ddd" so that ast.literal_eval does not raise error
+                if isinstance(dic[key], str):
+                    dic[key] = re.sub(r'[^\[\],\s]+', r'"\g<0>"', dic[key])
+            # Convert a string into a list
+            dic[key] = list(ast.literal_eval(f'{dic[key]}'))
+        elif key in defaults:
+            # Use default value
+            dic[key] = [defaults[key] for w in range(len(dic['amplitudes']))]
+
+    # Compute extra
     dic['B0'] = np.abs(dic['B0']) * np.sign(sim.gamma[dic['nuc']])
-    dic['TD'] = int(dic['TD'])
     dic['SFO1'] = dic['B0'] * sim.gamma[dic['nuc']]
+    dic['o1'] = dic['o1p'] * dic['SFO1']
+    if isinstance(dic['TD'], str):
+        dic['TD'] = eval(dic['TD'])
+    dic['TD'] = int(dic['TD'])
     dic['SW'] = dic['SWp'] * np.abs(dic['SFO1'])
     dic['dw'] = 1/dic['SW']
     dic['t1'] = np.linspace(0, dic['TD']*dic['dw'], dic['TD'])
     dic['AQ'] = dic['t1'][-1]
-    dic['o1'] = dic['o1p'] * dic['SFO1']
 
     return dic
 
@@ -211,8 +218,8 @@ def sim_1D(File, pv=False):
     shifts = np.array(in_file['shifts'])    # Chemical shift /ppm
     amplitudes = in_file['amplitudes']      # Relative intensity of the signals
     fwhm = np.array(in_file['fwhm'])        # Full width at half maximum of the signals
-    b = in_file['b']                    # Fraction of gaussianity of the FID
-    phases = in_file['phases']
+    b = np.array(in_file['b'])                    # Fraction of gaussianity of the FID
+    phases = np.array(in_file['phases']) * np.pi / 180    # Convert to radians
 
     freq = misc.ppm2freq(shifts, B0=in_file['SFO1'], o1p=in_file['o1p'])     # peaks center frequency
 
@@ -229,13 +236,13 @@ def sim_1D(File, pv=False):
     return fid
 
 
-def load_sim_2D(File, states=True):
+def load_sim_2D(filename, states=True):
     """
     Creates a dictionary from the spectral parameters listed in the input file.
 
     Parameters
     ----------
-    File : str
+    filename : str
         Path to the input file location
     states : bool
         If FnMODE is States or States-TPPI, set it to True to get the correct timescale.
@@ -245,36 +252,48 @@ def load_sim_2D(File, states=True):
     dic : dict
         Dictionary of the parameters, ready to be read from the simulation functions.
     """
-    inp = Path(File).read_text().splitlines(keepends=True)
-    keys = []
-    vals = []
-    for i in range(len(inp)):
-        if inp[i] == '\n' or inp[i][0] == '#':
-            continue
-        inp[i] = inp[i].replace('\t', ' ')
-        line = inp[i].split(' ', 1)    # separate key from the rest
-        line[0] = line[0].replace(' ', '')
-        line[0] = line[0].replace('x_g', 'b')
-        keys.append(line[0])
-
-        rest = line[1].strip()
-        if '#' in rest:
-            rest = rest.split('#')[0]
-        try:
-            value = eval(rest)
-        except Exception:
-            value = (f'{rest}')
-        vals.append(value)
-
-    dic = {}
-    for i, key in enumerate(keys):
-        if 'nuc' in key:    # Remove unwanted spaces
-            vals[i] = vals[i].replace(' ', '')
-        dic[key] = vals[i]
-
-    for key, value in dic.items():
-        if 'TD' in key:
-            dic[key] = int(value)
+    # Remove tabulations because they kill everything
+    path = Path(filename)
+    text = path.read_text()
+    if '\t' in text:
+        text = text.replace('\t', 4*' ')
+        with path.open('w') as f:
+            f.write(text)
+
+    # Make the dictionary
+    dic = misc.read_yml(path)
+
+    # Correct aliases
+    alias = {'shifts_f1': 'csf1', 'shifts_f2': 'csf2',
+             'fwhm_f1': 'lwf1', 'fwhm_f2': 'lwf2',
+             'amplitudes': 'A', 'b': 'x_g', }
+    newdic = deepcopy(dic)
+    for key, item in alias.items():
+        if item in dic:
+            newdic[key] = dic[item]
+            newdic.pop(item)
+    dic = newdic
+
+    # Check if the mandatory keys are all there
+    for key in ['shifts_f1', 'shifts_f2',
+                'fwhm_f1', 'fwhm_f2', 'amplitudes']:
+        if key not in dic:
+            raise NameError(f'Missing {key} in the input file.')
+    # Add the non-mandatory keys if missing with default values
+    defaults = {'b': 0, }
+    for key in alias:
+        # Check if there is
+        if key in dic:
+            # Convert a string into a list
+            dic[key] = list(ast.literal_eval(f'{dic[key]}'))
+        elif key in defaults:
+            # Use default value
+            dic[key] = [defaults[key] for w in range(len(dic['amplitudes']))]
+
+    for key in ['TD1', 'TD2']:
+        if isinstance(dic[key], str):
+            dic[key] = eval(dic[key])
+        dic[key] = int(dic[key])
     dic['SFO1'] = dic['B0'] * sim.gamma[dic['nuc1']]       # Larmor frequency /MHz
     dic['SFO2'] = dic['B0'] * sim.gamma[dic['nuc2']]       # Larmor frequency /MHz
     dic['SW1'] = np.abs(dic['SW1p'] * dic['SFO1'])       # spectral width

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: klassez
-Version: 0.2.2.dev0
+Version: 0.3.1
 Summary: A collection of functions for NMR data handling
 Author: Letizia Fiorucci
 Author-email: Francesco Bruno <bruno@cerm.unifi.it>
@@ -22,6 +22,7 @@ Requires-Dist: seaborn
 Requires-Dist: nmrglue
 Requires-Dist: matplotlib>=3.8
 Requires-Dist: csaps
+Requires-Dist: pyyaml
 Provides-Extra: jeolproc
 Requires-Dist: jeol_parser; extra == "jeolproc"
 Provides-Extra: docs

{klassez-0.2.2.dev0 → klassez-0.3.1}/klassez.egg-info/requires.txt

@@ -6,6 +6,7 @@ seaborn
 nmrglue
 matplotlib>=3.8
 csaps
+pyyaml
 
 [docs]
 sphinx

{klassez-0.2.2.dev0 → klassez-0.3.1}/pyproject.toml

@@ -29,6 +29,7 @@ dependencies = [
     'nmrglue',
     'matplotlib>=3.8',
     'csaps',
+    'pyyaml',
 ]
 [project.optional-dependencies]
 jeolproc = ['jeol_parser']