def setUp(self):
path = os.path.join(".", "data", "topspin", "304")
self.data = wrapper.load(path, data_type="topspin")
self.ws = dnp.create_workspace()
self.ws["raw"] = self.data
self.ws.copy("raw", "proc")
path = os.path.join(".", "data", "topspin", "5")
data = wrapper.load(path, data_type="topspin")
self.ws_off = dnp.create_workspace()
self.ws_off.add("raw", data)
self.ws_off.copy("raw", "proc")
def setUp(self):
p1 = np.array([0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0])
p2 = np.array([0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0, 0, 0])
p3 = np.array([0, 0, 0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0])
self.data = dnpdata(
np.array([p1, p2, p3]).T,
[np.arange(0, len(p1)), np.arange(0, 3)], ['x', 't2'])
self.ws = dnp.create_workspace()
self.ws['raw'] = self.data
self.ws.copy('raw', 'proc')
def setUp(self):
p1 = np.array([0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0])
p2 = np.array([0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0, 0, 0])
p3 = np.array([0, 0, 0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0])
self.data = dnpdata(
np.array([p1, p2, p3]).T,
[np.arange(0, len(p1)), np.arange(0, 3)],
["x", "t2"],
)
self.ws = dnp.create_workspace()
self.ws["raw"] = self.data
self.ws.copy("raw", "proc")
def test_h5_save_ws(self):
saver.save(
self.testdata_wsob,
os.path.join(".", "unittests", "test_ob.h5"),
overwrite=True,
)
saved_data_ob = wrapper.load(
os.path.join(".", "unittests", "test_ob.h5"))
self.assertEqual(
max(self.testdata_wsob.values[0]),
max(saved_data_ob["data"].values[0]),
)
self.assertEqual(self.testdata_wsob.values.shape,
saved_data_ob["data"].shape)
self.assertEqual(self.testdata_wsob.dims, saved_data_ob["data"].dims)
os.remove(os.path.join(".", "unittests", "test_ob.h5"))
ws_ws = create_workspace()
ws_ws.add("raw", self.testdata_wsob)
ws_ws.copy("raw", "proc")
saver.save(ws_ws,
os.path.join(".", "unittests", "test_ws.h5"),
overwrite=True)
saved_data_ws = wrapper.load(
os.path.join(".", "unittests", "test_ws.h5"))
self.assertEqual(
saved_data_ws["raw"].attrs.keys(),
saved_data_ws["proc"].attrs.keys(),
)
self.assertEqual(
ws_ws["proc"].attrs.keys(),
saved_data_ws["proc"].attrs.keys(),
)
self.assertEqual(ws_ws["proc"].shape, saved_data_ws["proc"].shape)
self.assertEqual(ws_ws["proc"].dims, saved_data_ws["proc"].dims)
os.remove(os.path.join(".", "unittests", "test_ws.h5"))
path = '../data/prospa/toluene_10mM_Tempone/'
exp_list = [str(x) for x in range(1,43)]
#exp_list = ['1','2','3','4']
power_list = 10.**(np.r_[0:40:len(exp_list)*1j] / 10) / 1000.
for ix, exp_num in enumerate(exp_list):
tmp = dnplab.dnpImport.prospa.import_prospa(path + '%s'%exp_num)
tmp.new_dim('power', power_list[ix])
if ix == 0:
data = tmp
else:
data.concatenate(tmp, 'power')
ws = dnplab.create_workspace()
ws.add('raw', data)
ws.copy('raw', 'proc')
ws = dnplab.dnpNMR.window(ws, {})
ws = dnplab.dnpNMR.fourier_transform(ws, {})
ws['proc'] = ws['proc']['t2',(-100,100)]
ws = dnplab.dnpNMR.align(ws, {})
ws.copy('proc', 'ft')
ws = dnplab.dnpNMR.integrate(ws, {'integrate_width': 40})
ws = dnplab.dnpFit.enhancementFit(ws)
dnplab.dnpResults.plot(ws['ft'])
dnplab.dnpResults.xlim(20,-20)
dnplab.dnpResults.figure()
=====================================================
06 - Calculate T1 from Inversion-Recovery Experiments
=====================================================
This example demonstrates how to import data from an inversion recovery NMR experiment and determine the T1 relaxation rate through a fit.
"""
# %%
# Load Inversion Recovery Spectra
# -------------------------------
# Start with importing data and create the DNPLab workspace
import dnplab as dnp
file_name_path = "../data/topspin/304"
data = dnp.dnpImport.load(file_name_path)
ws = dnp.create_workspace()
ws.add("raw", data)
ws.copy("raw", "proc")
# %%
# Next, we process the FIDs to obtain the NMR spectrum
dnp.dnpNMR.remove_offset(ws)
dnp.dnpNMR.window(ws, linewidth=10)
dnp.dnpNMR.fourier_transform(ws, zero_fill_factor=2)
dnp.dnpNMR.autophase(ws)
dnp.dnpResults.plot(ws["proc"].real)
dnp.dnpResults.xlim([-50, 30])
dnp.dnpResults.plt.xlabel("Chemical Shift [ppm]")
dnp.dnpResults.plt.ylabel("Signal Amplitude [a.u.]")
def hanlab_calculate_odnp(directory: str, pars: dict, verbose=True):
'''
Args:
directory: A string of the odnp experiment folder. e.g. '../data/topspin/'
pars: A dictionary of the processing parameters (including integration width etc)
Attr:
({integration_width : int, # set the default starting point to 20
spin_C : float,
field : float,
T100 : float,
smax_model : str, # ('tethered' or 'free')
t1_interp_method : str # ('linear' or 'second_order'),
drop_e_powers : list # a list of Enhancement powers to drop
drop_t1_powers : list # a list of T1 powers to drop
})
verbose: whether print intermediate outputs or not
Returns:
HydrationResults: A dnplab.hydration.HydrationResults object.
'''
# folder number for p=0 point in ODNP set
folder_p0 = 5
# folder number for T1(0) in ODNP set
folder_T10 = 304
# list of folder numbers for Enhancement(p) points in ODNP set
folders_Enhancements = list(range(6, 27))
# list of folder numbers for T1(p) points in ODNP set
folders_T1s = list(range(28, 33))
# get powers from .mat files
# for E(p)
powerfile = 'power'
bufferVal = 2.5
ExpNums = folders_Enhancements
## SEPARATE FUNCTION ##
Epowers = get_powers(directory, powerfile, ExpNums, bufferVal)
Epowers = np.add(Epowers, 21.9992)
Epowers = np.divide(Epowers, 10)
Epowers = np.power(10, Epowers)
Epowers = np.multiply(1e-3, Epowers)
# for T1(p)
powerfile = 't1_powers'
bufferVal = 20 * 2.5
ExpNums = folders_T1s
## SEPARATE FUNCTION ##
T1powers = get_powers(directory, powerfile, ExpNums, bufferVal)
T1powers = np.add(T1powers, 21.9992)
T1powers = np.divide(T1powers, 10)
T1powers = np.power(10, T1powers)
T1powers = np.multiply(1e-3, T1powers)
# Filter corrupted data points
Epowers = Epowers.tolist()
T1powers = T1powers.tolist()
if 'drop_e_powers' in pars.keys():
print("Dropping corrupted E(p) data ...") if verbose else None
E_indexs = [
i for i, x in enumerate(Epowers)
if any([abs(x - y) < 1e-6 for y in pars['drop_e_powers']])
]
[Epowers.pop(i) and folders_Enhancements.pop(i) for i in E_indexs]
if 'drop_t1_powers' in pars.keys():
print("Dropping corrupted T1(p) data ...") if verbose else None
T1_indexs = [
i for i, x in enumerate(T1powers)
if any([abs(x - y) < 1e-6 for y in pars['drop_t1_powers']])
]
[T1powers.pop(i) and folders_T1s.pop(i) for i in T1_indexs]
total_folders = [
folder_p0
] + list(folders_Enhancements) + list(folders_T1s) + [folder_T10]
T1 = []
T1_stdd = []
E = []
for i, folder in enumerate(total_folders):
data = dnplab.dnpImport.topspin.import_topspin(directory, folder)
workspace = dnplab.create_workspace('raw', data)
workspace.copy('raw', 'proc')
dnplab.dnpNMR.remove_offset(workspace, {})
dnplab.dnpNMR.window(workspace, {'linewidth': 10})
dnplab.dnpNMR.fourier_transform(workspace, {'zero_fill_factor': 2})
if workspace['proc'].ndim == 2:
workspace = dnplab.dnpNMR.align(workspace, {})
## phase opt: optimize the phase
curve = workspace['proc'].values
phases = np.linspace(-np.pi / 2, np.pi / 2, 100).reshape(1, -1)
rotated_data = (curve.reshape(-1, 1)) * np.exp(-1j * phases)
success = (np.real(rotated_data)**2).sum(axis=0) / (
(np.imag(rotated_data)**2).sum(axis=0))
bestindex = np.argmax(success)
phase = phases[0, bestindex]
workspace['proc'] *= np.exp(-1j * phase)
## optCenter: find the optimized integration center
def f_int(indx: int):
y = sum(
abs(
dnplab.dnpNMR.integrate(workspace['proc'], {
'integrate_center': indx,
'integrate_width': 10
}).values))
return y
center, _ = find_peak(f_int, -50, 51)
workspace = dnplab.dnpNMR.integrate(
workspace, {
'integrate_center': center,
'integrate_width': pars['integration_width']
})
if folder == folder_p0:
p0 = np.real(workspace['proc'].values[0])
print('Done with p0 folder...') if verbose else None
elif folder == folder_T10:
workspace = dnplab.dnpFit.t1Fit(workspace)
T10 = workspace['fit'].attrs['t1']
T10_stdd = workspace['fit'].attrs['t1_stdd']
print('Done with T1(0) folder...') if verbose else None
elif folder in folders_T1s:
workspace = dnplab.dnpFit.t1Fit(workspace)
T1.append(workspace['fit'].attrs['t1'])
T1_stdd.append(workspace['fit'].attrs['t1_stdd'])
print('Done with T1(p) folder ' + str(folder) +
'...') if verbose else None
elif folder in folders_Enhancements:
E.append(np.real(workspace['proc'].values[0]) / p0)
print('Done with Enhancement(p) folder ' + str(folder) +
'...') if verbose else None
else:
raise Exception('UnknownException')
# Sort enhancements based on E_powers
E = np.array([Epowers, E])
E = np.transpose(E)
E = E[E[:, 0].argsort()]
Enhancement_powers = E[:, 0]
Enhancements = E[:, 1]
# Sort T1 based on T1_powers
T1 = np.array([T1powers, T1, T1_stdd])
T1 = np.transpose(T1)
T1 = T1[T1[:, 0].argsort()]
T1_powers = T1[:, 0]
T1p = T1[:, 1]
T1_stdd = T1[:, 2]
hydration = {
'E': np.array(Enhancements),
'E_power': np.array(Enhancement_powers),
'T1': np.array(T1p),
'T1_power': np.array(T1_powers),
'T10': T10,
'T100': pars['T100'],
'spin_C': pars['spin_C'],
'field': pars['field'],
'smax_model': pars['smax_model'],
't1_interp_method': pars['t1_interp_method']
}
hydration_workspace = dnplab.create_workspace()
hydration_workspace.add('hydration_inputs', hydration)
hydration_results = dnplab.dnpHydration.hydration(hydration_workspace)
hydration_results.update({
'E': np.array(Enhancements),
'E_power': np.array(Enhancement_powers),
'T1_std': np.array(T1_stdd),
'T1': np.array(T1p),
'T1_power': np.array(T1_powers),
'T10': T10,
'T10_std': T10_stdd
})
return hydration_results
total_folders = []
total_folders.append(folder_p0)
for e in folders_Enhancements:
total_folders.append(e)
for t in folders_T1s:
total_folders.append(t)
total_folders.append(folder_T10)
T1 = []
T1_stdd = []
E = []
for f in range(0, len(total_folders)):
data = dnplab.dnpImport.topspin.import_topspin(directory, total_folders[f])
workspace = dnplab.create_workspace('raw', data)
workspace.copy('raw', 'proc')
dnplab.dnpNMR.remove_offset(workspace, {})
dnplab.dnpNMR.window(workspace,
{'linewidth': proc_params['window_linewidth']})
dnplab.dnpNMR.fourier_transform(
workspace, {'zero_fill_factor': proc_params['zero_fill_factor']})
if workspace['proc'].ndim == 2:
workspace = dnplab.dnpNMR.align(workspace, {})
phase = workupPhaseOpt(workspace)
workspace['proc'] *= np.exp(-1j * phase)
int_params['integrate_center'] = optCenter(workspace)
total_folders = []
total_folders.append(folder_p0)
for e in folders_Enhancements:
total_folders.append(e)
for t in folders_T1s:
total_folders.append(t)
total_folders.append(folder_T10)
T1 = []
T1_stdd = []
E = []
for f in range(0, len(total_folders)):
data = dnplab.dnpImport.topspin.import_topspin(directory, total_folders[f])
workspace = dnplab.create_workspace("raw", data)
workspace.copy("raw", "proc")
dnplab.dnpNMR.remove_offset(workspace, {})
dnplab.dnpNMR.window(workspace,
{"linewidth": proc_params["window_linewidth"]})
dnplab.dnpNMR.fourier_transform(
workspace, {"zero_fill_factor": proc_params["zero_fill_factor"]})
if workspace["proc"].ndim == 2:
workspace = dnplab.dnpNMR.align(workspace, {})
phase = workupPhaseOpt(workspace)
workspace["proc"] *= np.exp(-1j * phase)
int_params["integrate_center"] = optCenter(workspace)
import sys
sys.path.append('..')
import dnplab
exp_num = 40
path = '../data/prospa/toluene_10mM_Tempone/%i/'
data = dnplab.dnpImport.prospa.import_prospa(path % exp_num)
ws = dnplab.create_workspace('raw', data)
ws.copy('raw')
ws = dnplab.dnpNMR.window(ws, {})
ws = dnplab.dnpNMR.fourier_transform(ws, {})
ws = dnplab.dnpNMR.autophase(ws, {})
ws.copy('proc', 'ft')
ws = dnplab.dnpNMR.integrate(ws, {})
dnplab.dnpResults.plot(ws['ft'].real, label='toluene')
dnplab.dnpResults.legend()
#dnplab.plot(ws['proc'].imag)
dnplab.dnpResults.xlim(20, -20)
dnplab.dnpResults.show()
def setUp(self):
path = './data/vnmrj/10mM_tempol_in_water_array.fid'
self.data = vnmrj.import_vnmrj(path)
self.ws = dnp.create_workspace()
self.ws['raw'] = self.data
self.ws.copy('raw', 'proc')
def hanlab_calculate_odnp(directory: str, pars: dict, verbose=True):
"""
Args:
directory: A string of the odnp experiment folder. e.g. '../data/topspin/'
pars: A dictionary of the processing parameters (including integration width etc)
Attr:
({integration_width : int,
spin_C : float,
field : float,
T100 : float,
smax_model : str, # ('tethered' or 'free')
t1_interp_method : str, # ('linear' or 'second_order')
drop_first_T1 : bool # (True or False)
})
verbose: whether print intermediate outputs or not
Returns:
HydrationResults: A dnplab.hydration.HydrationResults object.
"""
# folder number for p=0 point in ODNP set
folder_p0 = 5
# folder number for T1(0) in ODNP set
folder_T10 = 304
# list of folder numbers for Enhancement(p) points in ODNP set
folders_Enhancements = list(range(6, 27))
# list of folder numbers for T1(p) points in ODNP set
folders_T1s = list(range(28, 33))
# get powers from .mat files
# for E(p)
powerfile = "power"
bufferVal = 2.5
ExpNums = folders_Enhancements
## SEPARATE FUNCTION ##
Epowers = get_powers(directory, powerfile, ExpNums, bufferVal)
Epowers = np.add(Epowers, 21.9992)
Epowers = np.divide(Epowers, 10)
Epowers = np.power(10, Epowers)
Epowers = np.multiply(1e-3, Epowers)
# for T1(p)
powerfile = "t1_powers"
bufferVal = 20 * 2.5
ExpNums = folders_T1s
## SEPARATE FUNCTION ##
T1powers = get_powers(directory, powerfile, ExpNums, bufferVal)
T1powers = np.add(T1powers, 21.9992)
T1powers = np.divide(T1powers, 10)
T1powers = np.power(10, T1powers)
T1powers = np.multiply(1e-3, T1powers)
# Drop first T1(p)
if pars["drop_first_T1"]:
print("Dropping First T1(p).")
T1powers = T1powers[1 : len(T1powers) + 1]
folders_T1s = folders_T1s[1 : len(folders_T1s) + 1]
total_folders = (
[folder_p0] + list(folders_Enhancements) + list(folders_T1s) + [folder_T10]
)
T1 = []
T1_stdd = []
E = []
for i, folder in enumerate(total_folders):
data = dnplab.dnpImport.topspin.import_topspin(directory, folder)
workspace = dnplab.create_workspace("raw", data)
workspace.copy("raw", "proc")
dnplab.dnpNMR.remove_offset(workspace, {})
dnplab.dnpNMR.window(workspace, {"linewidth": 10})
dnplab.dnpNMR.fourier_transform(workspace, {"zero_fill_factor": 2})
if workspace["proc"].ndim == 2:
workspace = dnplab.dnpNMR.align(workspace, {})
## phase opt: optimize the phase
curve = workspace["proc"].values
phases = np.linspace(-np.pi / 2, np.pi / 2, 100).reshape(1, -1)
rotated_data = (curve.reshape(-1, 1)) * np.exp(-1j * phases)
success = (np.real(rotated_data) ** 2).sum(axis=0) / (
(np.imag(rotated_data) ** 2).sum(axis=0)
)
bestindex = np.argmax(success)
phase = phases[0, bestindex]
workspace["proc"] *= np.exp(-1j * phase)
## optCenter: find the optimized integration center
def f_int(indx: int):
y = sum(
abs(
dnplab.dnpNMR.integrate(
workspace["proc"],
{"integrate_center": indx, "integrate_width": 10},
).values
)
)
return y
center, _ = find_peak(f_int, -50, 51)
workspace = dnplab.dnpNMR.integrate(
workspace,
{"integrate_center": center, "integrate_width": pars["integration_width"]},
)
if folder == folder_p0:
p0 = np.real(workspace["proc"].values[0])
print("Done with p0 folder 5...") if verbose else None
elif folder == folder_T10:
workspace = dnplab.dnpFit.t1Fit(workspace)
T10 = workspace["fit"].attrs["t1"]
T10_stdd = workspace["fit"].attrs["t1_stdd"]
print("Done with T1(0) folder 304...") if verbose else None
elif folder in folders_T1s:
workspace = dnplab.dnpFit.t1Fit(workspace)
T1.append(workspace["fit"].attrs["t1"])
T1_stdd.append(workspace["fit"].attrs["t1_stdd"])
print("Done with T1(p) folder " + str(folder) + "...") if verbose else None
elif folder in folders_Enhancements:
E.append(np.real(workspace["proc"].values[0]) / p0)
print(
"Done with Enhancement(p) folder " + str(folder) + "..."
) if verbose else None
else:
raise Exception("UnknownException")
# Sort enhancements based on E_powers
E = np.array([Epowers, E])
E = np.transpose(E)
E = E[E[:, 0].argsort()]
Enhancement_powers = E[:, 0]
Enhancements = E[:, 1]
# Sort T1 based on T1_powers
T1 = np.array([T1powers, T1, T1_stdd])
T1 = np.transpose(T1)
T1 = T1[T1[:, 0].argsort()]
T1_powers = T1[:, 0]
T1p = T1[:, 1]
T1_stdd = T1[:, 2]
hydration = {
"E": np.array(Enhancements),
"E_power": np.array(Enhancement_powers),
"T1": np.array(T1p),
"T1_power": np.array(T1_powers),
"T10": T10,
"T100": pars["T100"],
"spin_C": pars["spin_C"],
"field": pars["field"],
"smax_model": pars["smax_model"],
"t1_interp_method": pars["t1_interp_method"],
}
hydration_workspace = dnplab.create_workspace()
hydration_workspace.add("hydration_inputs", hydration)
hydration_results = dnplab.dnpHydration.hydration(hydration_workspace)
hydration_results.update(
{
"E": np.array(Enhancements),
"E_power": np.array(Enhancement_powers),
"T1_std": np.array(T1_stdd),
"T1": np.array(T1p),
"T1_power": np.array(T1_powers),
"T10": T10,
"T10_std": T10_stdd,
}
)
return hydration_results
