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