t1t2ne 0.0.2.dev0__tar.gz → 0.0.2.dev1__tar.gz

{t1t2ne-0.0.2.dev0/t1t2ne.egg-info → t1t2ne-0.0.2.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t1t2ne
-Version: 0.0.2.dev0
+Version: 0.0.2.dev1
 Project-URL: Homepage, https://github.com/enricoravera/t1ttune
 Project-URL: Repository, https://github.com/enricoravera/t1ttune.git
 Project-URL: Documentation, https://t1ttune.readthedocs.io
@@ -19,7 +19,7 @@ Requires-Dist: csaps
 Dynamic: license-file
 
 # **T1-T2-ne**
-
+<img src='https://github.com/enricoravera/T1T2ne/blob/main/docs/source/_static/t1t2ne_logo.png' alt='logo' width=300 />
 This software computes the optimal delays for protein dynamics experiments.
 
 Full documentation is available at [https://t1ttune.readthedocs.io/en/latest/](https://t1ttune.readthedocs.io/en/latest/).

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/README.md

@@ -1,5 +1,5 @@
 # **T1-T2-ne**
-
+<img src='https://github.com/enricoravera/T1T2ne/blob/main/docs/source/_static/t1t2ne_logo.png' alt='logo' width=300 />
 This software computes the optimal delays for protein dynamics experiments.
 
 Full documentation is available at [https://t1ttune.readthedocs.io/en/latest/](https://t1ttune.readthedocs.io/en/latest/).

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "t1t2ne"
-version = "0.0.2.dev0"
+version = "0.0.2.dev1"
 description = ""
 requires-python = ">=3.10"
 dependencies = [
@@ -29,12 +29,12 @@ where = ['.']
 include = ['t1t2ne*']
 
 [tool.setuptools.package-data]
-t1ttune = ['*.txt', '*.md', '*.yaml']
+t1ttune = ['*.txt', '*.md', '*.yaml', 'examples/**']
 
 [project.readme]
 file = "README.md"
 content-type = "text/markdown"
 
 [project.scripts]
-t1ttune = "t1t2ne.cli:main"
+t1t2ne = "t1t2ne.cli:main"
 

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/cli.py

@@ -9,7 +9,7 @@ from .scripts.__init__ import registry
 def main():
     # Top-level parser — mostra i sottocomandi disponibili nell'help
     parser = argparse.ArgumentParser(
-        prog="t1ttune",
+        prog="t1t2ne",
         description="Main program. Select a subcommand to start.",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog=_build_commands_epilog(),
@@ -47,5 +47,5 @@ def _build_commands_epilog() -> str:
     for name, cmd in registry.items():
         lines.append(f"  {name:<12} {cmd.SHORT_HELP}")
     lines.append("")
-    lines.append("Use 't1ttune <command> --help' for details on each command.")
+    lines.append("Use 't1t2ne <command> --help' for details on each command.")
     return "\n".join(lines)

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/f_ParaMeters_relax.py

@@ -237,7 +237,12 @@ def SBM(r, B, taue=1e-9, taur=1e-9, tau_M=np.inf, S=0.5, tauv=None, deltat=None,
 
 def transient_zfs(deltat, B, tauv, S):
     """
-    Calculate the transient zero-field splitting (ZFS) contributions to the electron relaxation rates T1e and T2e using the Bloembergen-Morgan model.
+    Calculate the transient zero-field splitting (ZFS) contributions to the electron relaxation rates T1e and T2e using the Bloembergen-Morgan model:
+    
+    .. math::
+    
+        R_{1e} = \frac{2}{15} \Delta_t^2 \left(4S(S+1) - 3\right) \left(J(\omega_e) + 2J(2\omega_e)\right) \\
+        R_{2e} = \frac{1}{15} \Delta_t^2 \left(4S(S+1) - 3\right) \left(3J(0) + 5J(\omega_e) + J(2\omega_e)\right)
     
     Parameters
     ----------
@@ -373,7 +378,21 @@ def rotational_taue(g, B, tauv, A=None, I=None):
 
 def OuterSphere(B, c=1, d=3.6e-10, D_target = 1e-10, D_cosolute = 2.6e-10, f=0.5, taue=1e-9, tauv=2.6e-11, deltat=0.014, AMe=None, I=None, g=None, S=3.5, nuc='1H'):
     """
-    Calculate the outer sphere relaxation rates R1 and R2 using the Freed model, with optional transient zero-field splitting (ZFS) contributions.
+    Calculate the outer sphere relaxation rates R1 and R2 using the Freed model:
+
+    .. math:: 
+    
+        k_{outer} = \frac{16\pi}{81} \left( \frac{\mu_0}{4\pi} \right)^2 h^2 \gamma_n^2 \gamma_e^2 S(S+1) N_A f \frac{c}{d(D_{target}+D_{cosolute})}\\
+        R_1 = k_{outer} [7 J_{outer} (\omega_S) + 3 J_{outer} (\omega_I)]\\
+        R_2 = \frac{1}{2} k_{outer} [13 J_{outer} (\omega_S) + 3 J_{outer} (\omega_I) + 4 J_{outer} (0)]
+        
+    Optionally, the transient zero-field splitting (ZFS) contribution to electron relaxation is included with the Bloembergen-Morgan model:
+
+    .. math::
+    
+        R_{1e} = \frac{2}{15} \Delta_t^2 \left(4S(S+1) - 3\right) \left(J(\omega_e) + 2J(2\omega_e)\right)\\
+        R_{2e} = \frac{1}{15} \Delta_t^2 \left(4S(S+1) - 3\right) \left(3J(0) + 5J(\omega_e) + J(2\omega_e)\right)
+    
     Default values are for 1 mM Gd-DOTA and a protein of 10 kDa at room temperature. Values for Gd-DOTA are taken from `Li et al. 2002`_.
     
     .. _Li et al. 2002: https://pubs.acs.org/doi/full/10.1021/ic0200390
@@ -423,7 +442,7 @@ def OuterSphere(B, c=1, d=3.6e-10, D_target = 1e-10, D_cosolute = 2.6e-10, f=0.5
     mu_0 = constants.mu_0
     gamma_nuc = kz.sim.gamma[nuc]*(2*np.pi)*1e6 # in rad/s/T
     gamma_e = -1 * constants.physical_constants['electron gyromag. ratio'][0]
-    k_outer = (16./81.) * np.pi * (mu_0/(4*np.pi))**2 * (h**2) * (gamma_nuc**2) * (gamma_e**2 / (4*np.pi**2)) * S*(S+1.) * N_A * c / (d * (D_target + D_cosolute))
+    k_outer = (16./81.) * np.pi * (mu_0/(4*np.pi))**2 * (h**2) * (gamma_nuc**2) * (gamma_e**2 / (4*np.pi**2)) * S*(S+1.) * N_A * c * f / (d * (D_target + D_cosolute))
     
     omegai = gamma_nuc * B
     omegas = gamma_e * B

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/fun_hetrelax_models.py

@@ -217,6 +217,14 @@ def J_Freed(w, d, D_target, D_cosolute, tau_1=1e-9, tau_2=None):
     Freed spectral density function for outer sphere relaxation. Equations 6.42, 6.48 and 6.50 in `Bertini et al. 2016`_.
  
     .. _Bertini et al. 2016: https://www.sciencedirect.com/science/chapter/monograph/pii/B9780444634368000065
+    
+    .. math::
+    
+        \tau_D = \frac{d^2}{D_{target} + D_{cosolute}}
+        z = \sqrt{2 |\omega| \tau_D + \frac{\tau_D}{\tau_1}}
+        J(\omega) = \frac{2}{5} \frac{1 + \frac{5 z}{8} + \frac{z^2}{8}}{1 + z + \frac{z^2}{2} + \frac{z^3}{6} + \frac{4 z^4}{81} + \frac{z^5}{81} + \frac{z^6}{648}}
+        
+    
 
     Parameters
     -----------

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/t1t2ne_interactive.py

@@ -8,6 +8,7 @@ from .textcolor import textcolor
 import klassez as kz
 from . import t1t2ne_utils, fun_hetrelax_models, f_findfs
 import random
+from scipy.special import lambertw
 
 class InteractiveCmd(BaseCommand):
     SHORT_HELP = "Interactive setup of the experiment"
@@ -36,7 +37,7 @@ class InteractiveCmd(BaseCommand):
         parser.add_argument('--Deltasigma', type=float, default=-160, help='The chemical shift anisotropy of the 15N nucleus in ppm. Default is -160 ppm.')
         parser.add_argument('--theta', type=float, default=17, help='The angle between the 1H-15N bond and the principal axis of the CSA tensor in degrees. Default is 17 degrees.')
         parser.add_argument('--B0', nargs='*', help='The magnetic field strength in Tesla. If not provided, the script will try to load it from the config file. If it is not found in the config file, an error will be raised.')
-        parser.add_argument('--Larmor', type=float, help='The Larmor frequency of the nucleus in MHz. If not provided, the script will try to load it from the config file. If it is not found in the config file, an error will be raised.')
+        parser.add_argument('--Larmor', nargs=1, type=float, help='The Larmor frequency of the nucleus in MHz. If not provided, the script will try to load it from the config file. If it is not found in the config file, an error will be raised.')
         parser.add_argument('--logscale', action='store_true', help='Whether to use a logarithmic scale for the vdlist and vclist. Default is False, which means a linear scale will be used.')
         parser.add_argument('--nucs', nargs='*', default=['1H', '15N'], help='The nuclei to use for the calculation of the relaxation rates. Default is 1H and 15N.')
         parser.add_argument('--large', action='store_true', help='Whether to create the lists for the "large" sequence, which is optimized for short T2 times. If True, the d21 value is set to 450 us and only 8 cycles per CPMG block are used instead of 16. Default is False.')
@@ -70,13 +71,15 @@ def interactive_setup(CO):
     CO.add_ref('klassez')    
 
     CO.get_B0()
+    
+    expectedratio = np.real(np.exp(-(1+lambertw(1/np.e)))) # maximum reduction achievable with the optimal CPMG block, which is 1+lambertw(1/e) times the T2 time of the system
 
     if hasattr(CO, 'tau') and CO.tau is not None:
         CO.add_ref('fushman')
         R1, R2, nOe = fun_hetrelax_models.R1R2nOe(CO.B_0, r=CO.r, nuc1=CO.nucs[0], nuc2=CO.nucs[1], Deltasigma=CO.Deltasigma, func=fun_hetrelax_models.LS_iso, f_args=(CO.S2, CO.tau))
         print(textcolor('Based on the provided parameters, the estimated R1 is {:.2f} s^-1 and R2 is {:.2f} s^-1.'.format(R1, R2), 'green'))
-        T1_30 = -np.log(0.3)/R1
-        T2_30 = -np.log(0.3)/R2
+        T1_30 = -np.log(expectedratio)/R1
+        T2_30 = -np.log(expectedratio)/R2
     else:
         T1_30 = 0.5
         T2_30 = 0.065
@@ -92,6 +95,7 @@ def interactive_setup(CO):
     else:
         CO.T1red = float(input('Enter percent residual signal for the longest delay of the T1 experiment (default 5%): ').strip() or "5")*0.01
         CO.T2red = float(input('Enter percent residual signal for the longest CPMG block of the T2 experiment (default 10%): ').strip() or "10")*0.01        
+
     logscale = CO.options['logscale']
     nT1 = CO.nT[0]
     if len(CO.nT) == 1:
@@ -109,7 +113,8 @@ def interactive_setup(CO):
     
         
     print('\nStarting the interactive setup of the T1 experiment...')
-    print('Acquire the reference spectrum first with d7 = 20u.')
+    d29 = -np.log(CO.T1red)/R1 
+    print(f'Acquire the reference spectrum first with d31 = 20u and d29 = {d29:.3f} s.')
     refno = input('Please enter the reference spectrum number (default is 1): ') or '1'
 
     path_ref = os.path.join(CO.basedir, refno)
@@ -119,6 +124,9 @@ def interactive_setup(CO):
         S_ref = kz.Spectrum_1D(path_ref)
     except Exception as e:
         raise RuntimeError(f'Error occurred while loading the reference spectrum: {e}')
+    version = t1t2ne_utils.fs_version(S_ref)
+    if version == 'topspin3':
+        S_ref.acqus['GRPDLY'] += 1
     S_ref.procs['wf']['mode'] = 'em'
     S_ref.procs['wf']['lb'] = 1/S_ref.acqus['AQ']
     print(f'Line broadening applied: {S_ref.procs["wf"]["lb"]:.2g} Hz')
@@ -132,11 +140,11 @@ def interactive_setup(CO):
     S_ref.integrate(filename='refspec')
     limits = kz.misc.key_to_limits(list(S_ref.integrals.keys()))
 
-    ta = S_ref.ngdict['acqus']['D'][7]
+    ta = S_ref.ngdic['acqus']['D'][31]
     whilecontrol = True
     iteration = 0
     while whilecontrol:
-        print(textcolor(f'To achieve a reduction of the signal intensity of about {(1-CO.T1red)*100:.0f}%, try setting d7 to ' + t1t2ne_utils.f4(T1_30), 'blue'))
+        print(textcolor(f'To achieve a reduction of the signal intensity of about {expectedratio*100:.0f}%, try setting d31 to ' + t1t2ne_utils.f4(T1_30), 'blue'))
         expno = input('Please enter the experiment number for the T1 experiment once it is done (default is 2): ') or '2'
         path_t1 = os.path.join(CO.basedir, expno)
         if not os.path.exists(path_t1):
@@ -145,27 +153,29 @@ def interactive_setup(CO):
             S_t1 = kz.Spectrum_1D(path_t1)
         except Exception as e:
             raise RuntimeError(f'Error occurred while loading the T1 spectrum: {e}')
+        if version == 'topspin3':
+            S_t1.acqus['GRPDLY'] += 1
         S_t1.procs['wf']['mode'] = 'em'
         S_t1.procs['wf']['lb'] = 1/S_t1.acqus['AQ']
         S_t1.procs['zf'] = 2 * S_t1.fid.shape[-1]
         S_t1.process()
         S_t1.pknl()
         S_t1.adjph()
-        S_t1.integrate(filename='t1spec', limits=limits)
-        tb = S_t1.ngdict['acqus']['D'][7]
+        S_t1.integrate(filename='t1spec', lims=limits)
+        tb = S_t1.ngdic['acqus']['D'][31]
         ratio = 0
         for key in S_t1.integrals.keys():
             ratio += S_t1.integrals[key] / S_ref.integrals[key] * (1/len(S_t1.integrals.keys()))
         R1_ave = -np.log(ratio) / (tb-ta)
-        print(f'Iteration {iteration}: Estimated R1 from the reference and T1 spectra: {R1_ave:.2f} s^-1')
-        T1_30_est = -np.log(0.3)/R1_ave
+        print(f'Iteration {iteration}: Estimated R1 from the reference ({ta*1e6:.2f} u) and T1 spectra ({tb:.3f} s) with a ratio of {ratio:.2f}: {R1_ave:.2f} s^-1')
+        T1_30_est = -np.log(expectedratio)/R1_ave
         if abs(T1_30_est - T1_30) / T1_30 > 0.1:
             T1_30 = T1_30_est
         else:
             whilecontrol = False
         iteration += 1
     print(textcolor(f'Convergence achieved for T1 estimation. Estimated $R1_{{ave}}$ is {R1_ave:.2f} s.', 'green'))
-    print(textcolor(f'Set the recovery delay for the hetnOe experiment to at least {6/R1_ave:.3f}.\n', 'blue', bold=False))       
+    print(textcolor(f'Set the recovery delay for the hetnOe experiment in the range {4/R1_ave:.3f} - {6/R1_ave:.3f}.\n', 'blue', bold=False))       
     T1max = -np.log(CO.T1red)/R1_ave
     if logscale:
         vdlist_T1 = [2e-5 - 1/R1_ave * np.log(1-(1-CO.T1red)*i/(nT1-1)) for i in range(nT1)] #logarithmically spaced list from 20u to to T1max
@@ -179,18 +189,35 @@ def interactive_setup(CO):
 
 
     print('\nStarting the interactive setup of the T2 experiment...')
-    print('Acquire the reference spectrum first with l1 = 0.')
+    T2max = -np.log(CO.T2red)/R2
+    
     if CO.options['idp'] and not CO.options['small']:
         CO.options['small'] = True
+    if T2max > 0.250:
+        print(textcolor(f'Alert: the longest CPMG block for a residual signal of {T2red*100:.0f}% is {T2max:.2f} s, which is likely too long for any equipment.', 'red', bold=True))
+        print('Setting the maximum CPMG block to to 250ms')
+        T2max = 0.250
+        T2red = 1 - np.exp(-R2*T2max)
+        print(textcolor(f'With this maximum CPMG block, the expected residual signal is {T2red*100:.0f}%.', 'yellow', bold=True))
+        if CO.options['large']:
+            print(textcolor('You chose the "large" sequence, which is optimized for short T2 times, this option will be disabled.', 'yellow', bold=True))
+            CO.options['large'] = False
+
     if CO.options['small']:
-        print(textcolor('Using ".idp" sequence, which is optimized for long T2 times. d21 = 600u', 'blue'))
-        d21 = 600
+        print(textcolor('Using ".idp" sequence, which is optimized for long T2 times. d21 = 750u', 'blue'))
+        d21 = 750
     else:
         d21 = float(input('Enter the d21 value in microseconds (default 450): ').strip() or "450")
-    p30 = float(input('Enter the p30 value in microseconds (default 80): ').strip() or "80")
+    p30 = float(input('Enter the p30 value in microseconds (default 160): ').strip() or "160")
     d31 = (p30*16+d21*32)
     if CO.options['large']:
         d31 = d31/2
+    T2red_max = 1 - np.exp(-R2*0.250)
+    T2_30 = min(T2_30, 0.250)
+    l29 = int(T2_30/(d31*1e-6))
+    l31_hl = int(0.250/(d31*1e-6))
+
+    print(f'Acquire the reference spectrum first with l31 = 0 and l29={l29:d}.')
 
     
     refno = input('Please enter the reference spectrum number (default is 1): ') or '1'
@@ -202,6 +229,9 @@ def interactive_setup(CO):
         S_ref = kz.Spectrum_1D(path_ref)
     except Exception as e:
         raise RuntimeError(f'Error occurred while loading the reference spectrum: {e}')
+    version = t1t2ne_utils.fs_version(S_ref)
+    if version == 'topspin3':
+        S_ref.acqus['GRPDLY'] += 1
     S_ref.procs['wf']['mode'] = 'em'
     S_ref.procs['wf']['lb'] = 1/S_ref.acqus['AQ']
     print(f'Line broadening applied: {S_ref.procs["wf"]["lb"]:.2g} Hz')
@@ -215,15 +245,18 @@ def interactive_setup(CO):
     S_ref.integrate(filename='refspec')
     limits = kz.misc.key_to_limits(list(S_ref.integrals.keys()))
 
-    ta = S_ref.ngdict['acqus']['L'][1]*d31*1e-6
+    ta = S_ref.ngdic['acqus']['L'][31]*d31*1e-6
     whilecontrol = True
     iteration = 0
     l1_30 = int(T2_30/(d31*1e-6))
     if l1_30 <= 0:
         l1_30 = 1
-
+    if l1_30 >= l31_hl:
+        l1_30 = l31_hl
+    R2ave = R2
     while whilecontrol:
-        print(textcolor(f'To achieve a reduction of the signal intensity of about {(1-CO.T2red)*100:.0f}%, try setting l1 to {l1_30:.0f}'))
+        T2red_30 = max(1 - np.exp(-R2ave*l1_30*d31*1e-6), T2red_max)
+        print(textcolor(f'To achieve a reduction of the signal intensity of about {T2red_30*100:.0f}%, try setting l31 to {l1_30:.0f}', 'blue'))
         expno = input('Please enter the experiment number for the T2 experiment once it is done (default is 2): ') or '2'
         path_t2 = os.path.join(CO.basedir, expno)
         if not os.path.exists(path_t2):
@@ -232,47 +265,54 @@ def interactive_setup(CO):
             S_t2 = kz.Spectrum_1D(path_t2)
         except Exception as e:
             raise RuntimeError(f'Error occurred while loading the T2 spectrum: {e}')
+        if version == 'topspin3':
+            S_t2.acqus['GRPDLY'] += 1
         S_t2.procs['wf']['mode'] = 'em'
         S_t2.procs['wf']['lb'] = 1/S_t2.acqus['AQ']
         S_t2.procs['zf'] = 2 * S_t2.fid.shape[-1]
         S_t2.process()
         S_t2.pknl()
         S_t2.adjph()
-        S_t2.integrate(filename='t2spec', limits=limits)
-        tb = S_t2.ngdict['acqus']['L'][1]*d31*1e-6
+        S_t2.integrate(filename='t2spec', lims=limits)
+        tb = S_t2.ngdic['acqus']['L'][31]*d31*1e-6
         ratio = 0
         for key in S_t2.integrals.keys():
             ratio += S_t2.integrals[key] / S_ref.integrals[key] * (1/len(S_t2.integrals.keys()))
         R2_ave = -np.log(ratio) / (tb-ta)
-        print(f'Iteration {iteration}: Estimated R2 from the reference and T2 spectra: {R2_ave:.2f} s^-1')
-        l1_30_est = int((-np.log(0.3)/R2_ave)/(d31*1e-6))
+        print(f'Iteration {iteration}: Estimated R2 from the reference ({ta*1e6:.2f} us) and T2 ({tb*1e3:.2f} ms), with ratio of {ratio:.3f}: {R2_ave:.2f} s^-1')
+        l1_30_est = int((-np.log(expectedratio)/R2_ave)/(d31*1e-6))
         if l1_30_est == 0:
             l1_30_est = 1
-        if l1_30_est != l1_30:
+        if l1_30_est >= l31_hl:
+            l1_30_est = l31_hl
+        if np.abs(l1_30_est - l1_30) > 1:
             l1_30 = l1_30_est
         else:
             whilecontrol = False
         iteration += 1
     
     print(textcolor(f'Convergence achieved for T2 estimation. Estimated $R2_{{ave}}$ is {R2_ave:.2f} s.', 'green'))
-    T2max = -np.log(CO.T2red)/R2_ave
+    T2max = -np.log(T2red)/R2_ave
     nmax = int(T2max/(d31*1e-6))
     if T2max > 0.250:
-        print(textcolor(f'Alert: the longest CPMG block for a residual signal of {CO.T2red*100:.0f}% is {T2max:.2f} s, which is likely too long for any equipment.', 'red', bold=True))
+        print(textcolor(f'Alert: the longest CPMG block for a residual signal of {T2red*100:.0f}% is {T2max:.2f} s, which is likely too long for any equipment.', 'red', bold=True))
         print('Setting the maximum CPMG block to to 250ms')
         T2max = 0.250
+        T2red = 1 - np.exp(-R2*T2max)
+        print(textcolor(f'With this maximum CPMG block, the expected residual signal is {T2red*100:.0f}%.', 'yellow', bold=True))
+
         if CO.options['large']:
             print(textcolor('You chose the "large" sequence, which is optimized for short T2 times, this option will be disabled.', 'yellow', bold=True))
             CO.options['large'] = False
 
     #print(f'd21 = {d21} us, p30 = {p30} us, cpmgblock = {d31} us')
     print('\n')
-    print(textcolor(f'The longest CPMG block for T2 for a residual signal of {CO.T2red*100:.0f}% should be {T2max:.2f} s, with {nmax} loops.' , 'default', bold=True)) #grassetto
+    print(textcolor(f'The longest CPMG block for T2 for a residual signal of {T2red*100:.0f}% should be {T2max:.2f} s, with {nmax} loops.' , 'default', bold=True)) #grassetto
     print(textcolor('Check if this is too long for your equipment before running the experiment', 'red')) #rosso
     if nT2 > nmax:
         print(textcolor(f'Warning: the number of increments you chose for the CPMG experiment is {nT2}, which is more than the recommended number of loops {nmax} for a longest CPMG block of {T2max:.2f} s. The list will contain duplicates.', 'yellow')) #giallo
     if logscale:
-        vclist_T2 = [-1/R2 * np.log(1-(1-CO.T2red)*i/(nT2-1))/(d31*1e-6) for i in range(nT2)]
+        vclist_T2 = [-1/R2 * np.log(1-(1-T2red)*i/(nT2-1))/(d31*1e-6) for i in range(nT2)]
         vclist_T2 = np.array(vclist_T2, dtype=np.uint64) #convert to np.uint64
     else:
         vclist_T2 = np.linspace(0,nmax, num=int(nT2), dtype=np.uint64) #linearly spaced list from 0 to nmax

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/t1t2ne_ns.py

@@ -21,9 +21,9 @@ class NSCmd(BaseCommand):
     
     @staticmethod
     def add_arguments(parser):
-        parser.add_argument('--basedir', nargs=1, help='Base directory for the experiment (where the reference spectrum is located)')
-        parser.add_argument('--tract', nargs=1, help='expno of the TRACT experiment (used to estimate the SNR). Either this or --hsqc should be provided')
-        parser.add_argument('--hsqc', nargs=1, help='expno of the reference HSQC spectrum (used to estimate the SNR). Either this or --tract should be provided')
+        parser.add_argument('--basedir', type=str, help='Base directory for the experiment (where the reference spectrum is located)')
+        parser.add_argument('--tract', type=str, help='expno of the TRACT experiment (used to estimate the SNR). Either this or --hsqc should be provided')
+        parser.add_argument('--hsqc', type=str, help='expno of the reference HSQC spectrum (used to estimate the SNR). Either this or --tract should be provided')
         parser.add_argument('--nres', type=int, help='The number of non-proline residues in the protein. If not provided, it will be estimated from the molecular weight.')
         parser.add_argument('--lw', type=float, help='The linewidth of the peaks in the reference spectrum in Hz. If not provided, it will be estimated from the reference spectrum.')
         parser.add_argument('--xred', nargs='*', help='The percent residual signal for the longest delay of the experiment, or NOE efficiency as percentage. Accepts a list, computes the optimal number of scans for each value')
@@ -39,9 +39,7 @@ class NSCmd(BaseCommand):
     @staticmethod
     def run(args: argparse.Namespace) -> None:
         CO = t1t2ne_utils.Conf_Optns(args, module='NS')
-        CO.get_B0(config_p=t1t2ne_utils.load_config())
-        CO.get_experiments(config_p=t1t2ne_utils.load_config())
-        SNR = estimate_snr(args)
+        SNR = estimate_snr(CO)
         suggest_scans(CO, SNR)
         t1t2ne_utils.the_end(CO)
         
@@ -64,9 +62,9 @@ def estimate_snr(CO):
             The order parameters to use for the calculation of tau_c. In IDP mode, two values should be provide, else only one.
         *   tau : list of float
             The correlation times to use for the calculation of tau_c. In IDP mode, two values should be provide, else only one.
-        *   hsqcexpno : str, optional
+        *   hsqc : str, optional
             The experiment number of the HSQC reference spectrum to use for the SNR estimation.
-        *   tractexpno : str, optional
+        *   tract : str, optional
             The experiment number of the TRACT spectrum to use for the SNR estimation. 
         *   T : float, optional
             The temperature in Kelvin, used to recompute tau_c based on temperature.
@@ -81,23 +79,23 @@ def estimate_snr(CO):
     """
 
 
-    if CO.hasattr('MW'):
+    if hasattr(CO, 'MW') and CO.MW is not None:
         MW = CO.MW
     else:
-        if CO.hasattr('lw'):
+        if hasattr(CO, 'lw') and CO.lw is not None:
             print('No value provided for the molecular weight. Estimating it from the linewidth provided. This is a rough estimate, but it should be sufficient for our purposes.')
             MW = (CO.lw*np.pi/7.42 - 0.1674)/0.5998
             CO.add_ref('bermel')
             CO.add_ref('cavanagh')
-        elif CO.hasattr('nres'):
+        elif hasattr(CO, 'nres') and CO.nres is not None:
             MW = CO.nres*0.110/0.937 #average mass of an amino acid is 110 Da, and we multiply by 0.937 to account for the fact that prolines do not have an amide proton and therefore do not contribute to the signal in the HSQC spectrum. This is a rough estimate, but it should be sufficient for our purposes.
-        elif CO.hasattr('tau'):
+        elif hasattr(CO, 'tau') and CO.tau is not None:
             CO.add_ref('cavanagh')
             MW = (hydrodynamics_utils.tau(CO.tau[0]*1e9, 298.15, T_old=CO.T)- 0.1674)/0.5998
         else:   
             raise ValueError('No value provided for the molecular weight or linewidth. Cannot estimate molecular weight.')
     
-    if CO.hasattr('nres'):
+    if hasattr(CO, 'nres') and CO.nres is not None:
         nres = CO.nres
     else:
         nres = np.rint(MW/0.110)*(0.937) #average mass of an amino acid is 110 Da, and we multiply by 0.937 to account for the fact that prolines do not have an amide proton and therefore do not contribute to the signal in the HSQC spectrum. This is a rough estimate, but it should be sufficient for our purposes.
@@ -113,7 +111,7 @@ def estimate_snr(CO):
         tau_average = S2_slow*tau_slow + S2_int*tau_int
     else:
         tau_average = CO.tau[0]
-    if CO.lw is None:
+    if not hasattr(CO, 'lw') or CO.lw is None:
         R2H = tau_average*7.42e9 
         CO.add_ref('bermel')
         amidelinewidth = R2H/(np.pi)    
@@ -122,9 +120,12 @@ def estimate_snr(CO):
     amidelinewidth_p = kz.misc.freq2ppm(amidelinewidth, CO.B_0*kz.sim.gamma['1H'])
 
     #estimate signal to noise ratio. if HSQC is provided, use it. Else, use the TRACT
-    if CO.hsqcexpno is not None:
-        path_hsqc = os.path.join(CO.basedir, f'{CO.hsqcexpno}')
+    if CO.hsqc is not None:
+        path_hsqc = os.path.join(CO.basedir, f'{CO.hsqc}')
         S_hsqc = kz.Spectrum_2D(path_hsqc)
+        version = t1t2ne_utils.fs_version(S_hsqc)
+        if version == 'topspin3':
+            S_hsqc.acqus['GRPDLY'] += 1
         S_hsqc.procs['wf'][-1]['mode'] = 'em'
         S_hsqc.procs['wf'][-1]['lb'] = 1/S_hsqc.acqus['AQ2']
         S_hsqc.procs['zf'][-1] = 2 * S_hsqc.fid.shape[-1]
@@ -151,6 +152,9 @@ def estimate_snr(CO):
         S = kz.Pseudo_2D(path)
         if not t1t2ne_utils.istract(S):
             raise NameError(f'Experiment {CO.tract} is not a TRACT experiment')
+        version = t1t2ne_utils.fs_version(S_hsqc)
+        if version == 'topspin3':
+            S_hsqc.acqus['GRPDLY'] += 1
         Sa, Sb = split_tract(S)
         if CO.options['phase']:
             Sb.adjph(ref=0)

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/t1t2ne_setuptract.py

@@ -1,11 +1,14 @@
 #! /usr/bin/env python3
 
+from unittest import result
 import numpy as np
 
 from .base import BaseCommand
 from .textcolor import textcolor
 from . import t1t2ne_utils, fun_hetrelax_models
 import random
+from scipy.optimize import differential_evolution
+from scipy.special import lambertw
 
 class SetupTractCmd(BaseCommand):
     SHORT_HELP = "Setup the vdlist for a TRACT experiment"
@@ -44,6 +47,23 @@ class SetupTractCmd(BaseCommand):
         suggest_tract_vdlist(CO)
         t1t2ne_utils.the_end(CO)    
         exit()        
+        
+
+
+
+def d_optimal_criterion(t, lam1, lam2):
+    """Returns -log det(FIM); minimize this."""
+    t = np.asarray(t)
+    F11 = np.sum(t**2 * np.exp(-2 * lam1 * t))
+    F22 = np.sum(t**2 * np.exp(-2 * lam2 * t))
+    F12 = np.sum(t**2 * np.exp(-(lam1 + lam2) * t))
+    return -(F11 * F22 - F12**2)          # negative det (we minimise)
+
+
+def decode(u, t_max, n, min_gap):
+    """Map unconstrained u in [0,1]^n to sorted times with min_gap enforced."""
+    gaps = min_gap + u * (t_max - n * min_gap) / n  # each gap >= min_gap
+    return np.cumsum(gaps)
 
 def suggest_tract_vdlist(CO):
     r"""
@@ -77,12 +97,48 @@ def suggest_tract_vdlist(CO):
     if CO.options['idp']:
         CO.add_ref('rezaei-ghaleh')
     CO.add_ref('fushman')
+    print(textcolor('\nCalculating the optimal vdlist for the TRACT experiment...', 'blue'))
     R1, R2, nOe = fun_hetrelax_models.R1R2nOe(CO.B_0, r=CO.r, nuc1=CO.nucs[0], nuc2=CO.nucs[1], Deltasigma=CO.Deltasigma, func=fun_hetrelax_models.LS_iso, f_args=(CO.S2, CO.tau))
     CO.add_ref('salvi')
     eta_z, eta_xy = fun_hetrelax_models.eta_z_eta_xy(CO.B_0, r=CO.r, nuc1=CO.nucs[0], nuc2=CO.nucs[1], Deltasigma=CO.Deltasigma, theta=CO.theta, func=fun_hetrelax_models.LS_iso, f_args=(CO.S2, CO.tau))
     Rb = R2 + eta_xy
     Ra = R2 - eta_xy
-    vdlist_TRACT = np.geomspace(2e-5, 2/Rb, num=nT) #geometrically spaced list from 20us to 2*tau_average
+    print(textcolor('\nProvided parameters:', 'blue'))
+    print(f'Correlation time(s): {CO.tau} s')
+    print(f'Order parameter(s) S2: {CO.S2}')
+
+    print(textcolor('\nEstimated relaxation rates:', 'blue'))
+    print(f'R1:  {R1:.2f} s^-1, R2: {R2:.2f} s^-1, nOe: {nOe:.2f}')
+    print(f'Ra:  {Ra:.2f} s^-1')
+    print(f'Rb:  {Rb:.2f} s^-1')
+
+    factor = np.real(1 + lambertw(1/np.e))
+
+    t_a = factor / Ra
+    t_b = factor / Rb
+    
+    # Time range
+    t_min = 2e-5
+    t_max = 2 * max(t_a, t_b)
+    
+    # Logarithmically spaced grid (covers both fast and slow scales)
+    log_times = np.logspace(np.log10(t_min), np.log10(t_max), nT)
+    
+    # Force the two exact optimal points into the grid
+    # (this guarantees the schedule "touches" the FIM-optimal locations)
+    idx_a = np.argmin(np.abs(log_times - t_a))
+    idx_b = np.argmin(np.abs(log_times - t_b))
+    
+    # Avoid overwriting the same index if t_a ≈ t_b
+    if idx_a == idx_b:
+        idx_b = (idx_b + 1) % nT
+    
+    log_times[idx_a] = t_a
+    log_times[idx_b] = t_b
+    
+    # Return sorted distinct times
+    vdlist_TRACT = np.sort(log_times)
+    
     vdlist_TRACT /= 2
     if CO.options['randomize']:
         random.shuffle(vdlist_TRACT)

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/t1t2ne_solventpre.py

@@ -7,6 +7,7 @@ from .textcolor import textcolor
 from . import t1t2ne_utils, f_ParaMeters_relax
 import klassez as kz
 import random
+from scipy.special import lambertw
 
 class SPREListsCmd(BaseCommand):
     SHORT_HELP = "Setup the time increment for solvent PRE experiments"
@@ -18,7 +19,7 @@ class SPREListsCmd(BaseCommand):
     def add_arguments(parser):
         parser.add_argument('--MW', type=float, help='The molecular weight of the protein in kDa, to be used for estimating the linewidth.')
         parser.add_argument('--lw', type=float, default=10, help='The expected linewidth in Hz, to be used for estimating the tau_slow in the IDP model. Default is 10 Hz.')
-        parser.add_argument('--T1', type=float, default=1, help='The expected T1 in seconds, to be used for estimating the tau_slow in the IDP model. If not provided, it will be estimated from the molecular weight if provided, otherwise a default value of 1 s will be used.')
+        parser.add_argument('--T1', type=float, default=1, help='The expected intrinsic T1 in seconds.')
         parser.add_argument('--T', type=float, help='The Temperature in Kelvin')
         parser.add_argument('--nT', nargs='*', help='The number of increments in the suggested vdlist. For this module only one value must be provided. Default is 8.')
         parser.add_argument('--r', type=float, default=3.6, help='The distance of closest approach in Angstroms. Default is 3.6e-10 m, corresponding to the sum of the ionic radius of Gd^3+ and the van der Waals radius of water.')
@@ -110,7 +111,28 @@ def solventpre(CO):
     R2 = Gamma2 + amidelinewidth/np.pi
     print(textcolor(f"\nEstimated R1 at the closest approach distance: {R1:.2f} s^-1", "blue"))
     print(textcolor(f"Estimated R2 at the closest approach distance: {R2:.2f} s^-1", "blue"))
-    vdlist_PRE = np.geomspace(2e-5, 2/R1, num=nT1) #geometrically spaced list from 20us to 2*tau_average
+    
+    factor = np.real(1 + lambertw(1/np.e))
+
+    t_1 = factor / R1
+    t_2 = factor / R2
+    
+    # Time range
+    t_1_min = 2e-5
+    t_1_max = 2 * t_1
+    
+    # Logarithmically spaced grid (covers both fast and slow scales)
+    log_times = np.logspace(np.log10(t_1_min), np.log10(t_1_max), nT1)
+    
+    # Force the two exact optimal points into the grid
+    # (this guarantees the schedule "touches" the FIM-optimal locations)
+    idx_a = np.argmin(np.abs(log_times - t_1))
+    
+    log_times[idx_a] = t_1
+    
+    # Return sorted distinct times
+    vdlist_PRE = np.sort(log_times)
+    
     if CO.options['randomize']:
         random.shuffle(vdlist_PRE)
     print(textcolor('\nSuggested vdlist for T1 experiment:', 'blue'))
@@ -119,7 +141,12 @@ def solventpre(CO):
     if nT2 == 2:
         print(textcolor(f"Optimal Tb-Ta difference for optimizing Gamma2 measurement: {1.15/(R2):.5f} s", "blue"))
     else:
-        vdlist_PRE_R2 = np.geomspace(2e-5, 2/(R2), num=nT2)
+        t_2_min = 2e-5
+        t_2_max = 2 * t_2
+        log_times = np.logspace(np.log10(t_2_min), np.log10(t_2_max), nT2)
+        idx_b = np.argmin(np.abs(log_times - t_2))
+        log_times[idx_b] = t_2
+        vdlist_PRE_R2 = np.sort(log_times)
         if CO.options['randomize']:
             random.shuffle(vdlist_PRE_R2)
         print(textcolor('\nSuggested vdlist for R2 experiment:', 'blue'))

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/t1t2ne_tract.py

@@ -13,6 +13,7 @@ from matplotlib.widgets import MultiCursor
 
 from .base import BaseCommand
 from . import f_fit, t1t2ne_utils, fun_hetrelax_models
+from .tract_extra import split_tract
 
 class TractCmd(BaseCommand):
     SHORT_HELP = "Fit a TRACT experiment to extract the average tau_c of the system"
@@ -135,7 +136,7 @@ def make_plot(CO, xaxis, y_rec, yerr_rec, y_ave, yerr_ave, Ra, Rb, sigma_Ra, sig
         ax.set_yscale('log')
     else:
         ax.set_ylabel(r'$S^2$ estimate')        
-    ax.text(0.05, 0.95, f'expected $T_1$ = {1/R1:.2f} s\nexpected $T_2$ = {1/R2:.2f} s\nexpected hetnOe = {nOe:.2f}\nexpected $\eta_z$ = {eta_z:.2f}\nexpected $\eta_{{xy}}$ = {eta_xy:.2f}', transform=ax.transAxes, verticalalignment='top', bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
+    ax.text(0.05, 0.95, f'expected $T_1$ = {1/R1:.2f} s\nexpected $T_2$ = {1/R2:.2f} s\nexpected hetnOe = {nOe:.2f}\nexpected $\\eta_z$ = {eta_z:.2f}\nexpected $\\eta_{{xy}}$ = {eta_xy:.2f}', transform=ax.transAxes, verticalalignment='top', bbox=dict(boxstyle='round', facecolor='white', alpha=0.8))
 
     kz.misc.pretty_scale(axr, (0, R2+4*np.abs(eta_xy)), 'y')
     axr.set_ylabel('Relaxation rates (Hz)')
@@ -177,6 +178,11 @@ def s2(w_N, c, tau_slow, S2_slow = 0.15, tau_int = 1.6e-9):
     The slow motion is assumed to correspond to the tumbling of a protein of the same size of the one under study, and the order parameter of the slow motion is assumed to be 0.15.
     The intermediate motion is assumed to have a correlation time of a peptide of 20 residues (1.6 ns).
     
+    .. math::
+
+        S^2 = \frac{|\eta_{xy}/(d*c*B_0*P_2(\cos(\theta)))| - 4(S^2_{slow} J(0, \tau_{slow}) + (1-S^2_{slow}) J(0, \tau_{fast})) - 3(S^2_{slow} J(\omega_N, \tau_{slow}) + (1-S^2_{slow}) J(\omega_N, \tau_{fast}))}{4(1-S^2_{slow})(J(0, \tau_{int}) - J(0, \tau_{fast})) + 3(1-S^2_{slow})(J(\omega_N, \tau_{int}) - J(\omega_N, \tau_{fast}))}
+    
+
     Parameters
     ----------
     w_N : float
@@ -298,9 +304,16 @@ def tract_fit_Ra_Rb(CO):
 
     path = os.path.join(CO.basedir, f'{CO.tract}')
     # find vdlist in path
-    file = os.listdir(os.path.join(path, 'lists', 'vd'))[0]
+
     #   Connect the name of the file to the path
-    vdlistpath = os.path.join(path, 'lists', 'vd', file)
+    S = kz.Pseudo_2D(path)
+    if not t1t2ne_utils.istract(S):
+        raise NameError(f'Experiment {CO.tract} is not a TRACT experiment')
+    try:
+        file = os.listdir(os.path.join(path, 'lists', 'vd'))[0]
+        vdlistpath = os.path.join(path, 'lists', 'vd', file)
+    except:
+        vdlistpath = os.path.join(path, 'vdlist')
     #   Print a notification
     print(f'Found {vdlistpath} to be imported as VDLIST')
     #   Actual loading and storage in an attribute
@@ -319,18 +332,11 @@ def tract_fit_Ra_Rb(CO):
         slw = CO.options['slw']
 
     #load the dataset and check if it's a TRACT experiment
-    S = kz.Pseudo_2D(path)
-    if not t1t2ne_utils.istract(S):
-        raise NameError(f'Experiment {CO.tract} is not a TRACT experiment')
-    
+
+    CO.B0 = S.acqus['SFO1'] / kz.sim.gamma[CO.nucs[0]]
+    print(f'Magnetic field strength: {CO.B0:.2f} T')
     #splitcomb-like operation to separate the two interleaved datasets (TROSY and ANTITROSY)
-    S.fid = np.reshape(S.fid.flatten(), (2*S.fid.shape[0], -1))
-    Sa = deepcopy(S)
-    Sb = deepcopy(S)
-    Sb.fid = S.fid[::2]
-    Sa.fid = S.fid[1::2]
-    Sa.acqus['TD1'] = Sa.fid.shape[0]
-    Sb.acqus['TD1'] = Sb.fid.shape[0]
+    Sa, Sb = split_tract(S)
     if smooth_data or smooth_rates:
         slw_windowlength = int(S.acqus['TD'] * slw[0] / 100)
 
@@ -344,18 +350,24 @@ def tract_fit_Ra_Rb(CO):
         # Zerofill to twice the size
         s.procs['zf'] = 2 * s.fid.shape[-1]
         # Apply and do FT
+        if phase:
+            s.procs['p0'] = 0
+            s.procs['p1'] = 0
         s.process()
 
         # Remove digital filter
         s.pknl()
+
         # Phase the spectrum
         if phase:
+
             if s == Sa:
                 s.adjph()
             else:
-                s.adjph(p0=Sa.procs['p0'], p1=Sa.procs['p1'], pv=Sa.procs['pv'])
+                s.adjph(p0=Sa.procs['p0'], p1=Sa.procs['p1'], pv=Sa.procs['pv'], update=False)
         # Qfil the solvent peak
         s.acqus['FnMODE'] = 'No'
+        #s.abs_v2()
         if s==Sa:
             s.qfil()
         else:
@@ -375,7 +387,7 @@ def tract_fit_Ra_Rb(CO):
         filenames = 's_b', 's_a'
 
     #       Integrals
-        for k, (filename, s) in enumerate(zip(filenames, [Sb, Sa])):
+        for k, (filename, s) in enumerate(zip(filenames, [Sa, Sb])):
             if k == 0:    # => TROSY component
                 if not readints:       # compute the integrals  
                     s.integrate(filename=filename)
@@ -383,7 +395,7 @@ def tract_fit_Ra_Rb(CO):
                     s.read_integrals(filename=f'{filename}.igrl')
             else:       # => ANTITROSY component
                 # Get the integration regions from the TROSY spectrum
-                limits = kz.misc.key_to_limits(list(Sb.integrals.keys()))
+                limits = kz.misc.key_to_limits(list(Sa.integrals.keys()))
                 if not readints:       # integrate in the same regions of the TROSY
                     s.integrate(filename=filename, lims=limits)
                 else:       # read an integrals file
@@ -405,7 +417,7 @@ def tract_fit_Ra_Rb(CO):
     else:
         xaxis = []
         if selectregion:
-            signalregion = kz.fit.get_region(Sb.ppm_f2, Sb.rr[0])
+            signalregion = kz.fit.get_region(Sa.ppm_f2, Sa.rr[0])
         else:
             if CO.options['idp']:
                 signalregion = [[8.6, 7.4]]
@@ -414,7 +426,7 @@ def tract_fit_Ra_Rb(CO):
         # Sb.strip(signalregion)
         # Sa.strip(signalregion)
         for sreg in signalregion:
-            start, end = [kz.misc.ppmfind(Sb.ppm_f2, w)[0] for w in sreg]
+            start, end = [kz.misc.ppmfind(Sa.ppm_f2, w)[0] for w in sreg]
             for i in range(start, end):
                 Rb.append(f_fit.fit_exponential(vdlist, Sb.rr[:, i], multi=1).params['k'].value)
                 Ra.append(f_fit.fit_exponential(vdlist, Sa.rr[:, i], multi=1).params['k'].value)
@@ -507,8 +519,8 @@ def tract_compute_tau(B0, Ra, Rb, sigma_Ra, sigma_Rb, S2=0.9, r=1.02e-10, Deltas
     print('angle theta = {:.2f} degrees'.format(theta*180/np.pi))
     Rb_avg = np.mean(Rb)
     Ra_avg = np.mean(Ra)
-    sigma_Rb_avg = np.std(Rb)
-    sigma_Ra_avg = np.std(Ra)
+    sigma_Rb_avg = np.mean(Rb)
+    sigma_Ra_avg = np.mean(Ra)
     c_avg = np.average(c, weights=c**2/sigma_c**2)  #(Rb_avg - Ra_avg)/(dN*p*(3*np.cos(theta)**2-1))
     sigma_eta_avg = 0.5 * np.sqrt(sigma_Rb_avg**2 + sigma_Ra_avg**2)
     sigma_c_avg = np.abs(dc_deta) * sigma_eta_avg
@@ -645,4 +657,4 @@ def tract(CO):
         make_plot(CO, xaxis, y, yerr, y_ave, yerr_ave, Ra, Rb, sigma_Ra, sigma_Rb, values, name=name, idx = idx)
     
     print(textcolor('Use this command to create the lists for your system', 'green'))
-    print(f't1t2ne makelists --tau {CO.tau[0]*1e9:.2e} {CO.tau[1]*1e9:.2e} --S2 {CO.S2[0]:.2f} {CO.S2[1]:.2f} --idp' if CO.options['idp'] else f't1t2ne makelist --tau {CO.tau[0]*1e9:.2e} --S2 {CO.S2[0]:.2f}')     
+    print(f't1t2ne makelists --tau {CO.tau[0]*1e9:.2e} {CO.tau[1]*1e9:.2e} --S2 {CO.S2[0]:.2f} {CO.S2[1]:.2f} --idp' if CO.options['idp'] else f't1t2ne makelists --tau {CO.tau[0]*1e9:.2e} --S2 {CO.S2[0]:.2f}')     

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/t1t2ne_utils.py

@@ -5,11 +5,34 @@ import socket
 import configparser
 import numpy as np
 import klassez as kz
+from importlib.resources import files, as_file
+from pathlib import Path
 
 from . import hydrodynamics_utils, f_findfs
 from .textcolor import textcolor
 
 
+def fs_version(S):
+    """
+    Determines the version of TopSpin used to acquire the spectrum S by looking at the '_coreheader' parameter in the acqus dictionary of the spectrum. 
+
+    Parameters
+    ----------
+    S : kz.Pseudo_2D
+        The spectrum for which to determine the TopSpin version.
+
+    Returns
+    -------
+    str
+        The version of TopSpin used to acquire the spectrum if the '_coreheader' parameter is found, otherwise None.
+    """
+    if 'TopSpin 4' in S.ngdic['acqus']['_coreheader'][0]:
+        return 'topspin4'
+    elif 'TopSpin 3' in S.ngdic['acqus']['_coreheader'][0]:
+        return 'topspin3'
+    else:
+        return None
+
 def config_exists():
     """
     Checks if the config file exists in the curdir folder of topspin for any of the users in the nmrsuperuser list. 
@@ -440,7 +463,10 @@ class Conf_Optns:
                 if self.T != 298.15:
                     self.tau[0] = hydrodynamics_utils.recompute_tau(self.tau[0], self.T)
             if len(self.tau) == 1:
-                self.tau.append((self.MWi * 0.5998 + 0.1674) * 1e-9 if hasattr(self, 'MWi') else 1.6e-9) # default value for the correlation time of the intermediate motion in the IDP model is 1.6 ns
+                taui = (self.MWi * 0.5998 + 0.1674) * 1e-9 if hasattr(self, 'MWi') else 1.6e-9
+                if self.T != 298.15:
+                    taui = hydrodynamics_utils.recompute_tau(taui, self.T)
+                self.tau.append(taui) # default value for the correlation time of the intermediate motion in the IDP model is 1.6 ns
                 self.add_ref('rezaei-ghaleh')
         if hasattr(self, 'tau'):
             self.tau.append(1e-11) # the fast motion is always set to 10 ps.
@@ -634,7 +660,10 @@ class Conf_Optns:
         elif hasattr(parser, 'Larmor') and parser.Larmor is not None:
             self.B_0 = float(parser.Larmor[0]) / (42.57747892) # convert from MHz to Tesla using the gyromagnetic ratio of the first nucleus in the list
         else:
-            self.get_B0()
+            if self.module in ['tract', 'interactive']:
+                pass
+            else:
+                self.get_B0()
         
     def get_B0(self):
         """
@@ -654,7 +683,7 @@ class Conf_Optns:
 
         findfs_info = f_findfs.find_topspin()
         if findfs_info["spectrometer"]:
-            fspath = findfs_info["fspath"]
+            fspath = findfs_info["install_path"]
         else:
             fspath = None
             if self.module == 'interactive':
@@ -718,9 +747,11 @@ class Conf_Optns:
                 self.tract = None
                 self.hsqc = None
             else:
-                self.basedir = 'tract'
-                self.tract = '36'
-                self.hsqc = '411'
+                example_resource = files('t1t2ne') / 'examples'
+                with as_file(example_resource) as example_path:
+                    self.basedir = example_path
+                self.tract = '11'
+                self.hsqc = '4'
                 print(f'Experiment parameters set for internal test environment: basedir={self.basedir}, tract={self.tract}, hsqc={self.hsqc}')
         else:
             if hasattr(self, 'MW') and self.MW is not None:

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1}/t1t2ne/scripts/tract_extra.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 from copy import deepcopy
+from . import t1t2ne_utils
 
 def split_tract(S):
     """Split the interleaved TROSY and ANTITROSY datasets of a TRACT experiment.
@@ -16,11 +17,15 @@ def split_tract(S):
     Sa, Sb : Spectrum objects
         The two Spectrum objects containing the TROSY and ANTITROSY datasets, respectively.
     """
-    S.fid = np.reshape(S.fid.flatten(), (2*S.fid.shape[0], -1))
+    version = t1t2ne_utils.fs_version(S)
+    if version == 'topspin3':
+        S.acqus['GRPDLY'] += 1
+    else:
+        S.fid = np.reshape(S.fid.flatten(), (2*S.fid.shape[0], -1))
     Sa = deepcopy(S)
     Sb = deepcopy(S)
-    Sa.fid = S.fid[::2]
-    Sb.fid = S.fid[1::2]
+    Sb.fid = S.fid[::2]
+    Sa.fid = S.fid[1::2]
     Sa.acqus['TD1'] = Sa.fid.shape[0]
     Sb.acqus['TD1'] = Sb.fid.shape[0]
     return Sa, Sb

{t1t2ne-0.0.2.dev0 → t1t2ne-0.0.2.dev1/t1t2ne.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t1t2ne
-Version: 0.0.2.dev0
+Version: 0.0.2.dev1
 Project-URL: Homepage, https://github.com/enricoravera/t1ttune
 Project-URL: Repository, https://github.com/enricoravera/t1ttune.git
 Project-URL: Documentation, https://t1ttune.readthedocs.io
@@ -19,7 +19,7 @@ Requires-Dist: csaps
 Dynamic: license-file
 
 # **T1-T2-ne**
-
+<img src='https://github.com/enricoravera/T1T2ne/blob/main/docs/source/_static/t1t2ne_logo.png' alt='logo' width=300 />
 This software computes the optimal delays for protein dynamics experiments.
 
 Full documentation is available at [https://t1ttune.readthedocs.io/en/latest/](https://t1ttune.readthedocs.io/en/latest/).

t1t2ne-0.0.2.dev1/t1t2ne.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+t1t2ne = t1t2ne.cli:main

t1t2ne-0.0.2.dev0/t1t2ne.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-t1ttune = t1t2ne.cli:main