def test_calc_enhancement(self):
nmr.remove_offset(self.ws)
nmr.window(self.ws, linewidth=15)
nmr.fourier_transform(self.ws, zero_fill_factor=2)
nmr.autophase(self.ws, method="arctan")
ws = copy.deepcopy(self.ws)
nmr.calculate_enhancement(
self.ws,
off_spectrum=1,
on_spectra="all",
integrate_center=0,
integrate_width="full",
method="integrate",
dim="f2",
)
self.assertAlmostEqual(self.ws["enhancements"].values[0], 1.0, places=6)
self.assertAlmostEqual(
self.ws["enhancements"].values[-1], -1.3615844024369856, places=6
)
nmr.remove_offset(self.ws_off)
nmr.window(self.ws_off, linewidth=15)
nmr.fourier_transform(self.ws_off, zero_fill_factor=2)
nmr.autophase(self.ws_off, method="arctan")
nmr.calculate_enhancement(
self.ws_off,
off_spectrum=self.ws_off["proc"],
on_spectra=self.ws["proc"],
integrate_center="max",
integrate_width="full",
method="amplitude",
dim="f2",
)
self.assertAlmostEqual(
self.ws_off["enhancements"].values[0], -0.005967949713665632, places=6
)
self.assertAlmostEqual(
self.ws_off["enhancements"].values[-1], 0.004154668257187268, places=6
)
dnp.dnpTools.integrate(ws, integrate_center=0, integrate_width="full")
nmr.calculate_enhancement(ws, off_spectrum=1)
self.assertAlmostEqual(ws["enhancements"].values[0], 1.0, places=6)
self.assertAlmostEqual(
ws["enhancements"].values[-1], -1.3615844024369856, places=6
)
def test_integrate(self):
ws = copy.deepcopy(self.ws)
nmr.remove_offset(ws)
nmr.window(ws, linewidth=15)
nmr.fourier_transform(ws, zero_fill_factor=2)
nmr.autophase(ws, method="arctan")
ws2 = copy.deepcopy(ws)
ws3 = copy.deepcopy(ws)
dnp.dnpTools.integrate(ws,
dim="f2",
integrate_center=0,
integrate_width=50)
self.assertEqual((8, ), np.shape(ws["integrals"].values))
self.assertAlmostEqual(max(ws["integrals"].values.real),
6170.447249940133,
places=4)
self.assertAlmostEqual(min(ws["integrals"].values.real),
-7188.897892203664,
places=4)
dnp.dnpTools.integrate(ws2,
dim="f2",
integrate_center=[-10, 0, 10],
integrate_width=50)
self.assertEqual((3, 8), np.shape(ws2["integrals"].values))
self.assertAlmostEqual(max(ws2["integrals"].values.real[1]),
6170.447249940133,
places=4)
self.assertAlmostEqual(min(ws2["integrals"].values.real[1]),
-7188.897892203664,
places=4)
dnp.dnpTools.integrate(ws3,
dim="f2",
integrate_center=[-10, 0, 10],
integrate_width=[10, 50, 10])
self.assertEqual((3, 8), np.shape(ws2["integrals"].values))
self.assertAlmostEqual(max(ws3["integrals"].values.real[1]),
6170.447249940133,
places=4)
self.assertAlmostEqual(min(ws3["integrals"].values.real[1]),
-7188.897892203664,
places=4)
def test_fit_functions(self):
nmr.remove_offset(self.ws)
nmr.window(self.ws, type="lorentz_gauss", linewidth=[5, 10])
nmr.fourier_transform(self.ws, zero_fill_factor=2)
nmr.autophase(self.ws, method="search", order="zero")
tools.baseline(self.ws, type="polynomial", order=2, reference_slice=None)
tools.integrate(self.ws, dim="f2", integrate_center=0, integrate_width=50)
efit.exponential_fit(self.ws, type="T1")
self.assertAlmostEqual(self.ws["fit"].attrs["T1"], 2.140702947551208, places=4)
efit.exponential_fit(self.ws, type="T2")
self.assertAlmostEqual(self.ws["fit"].attrs["T2"], 1.0682212598985381, places=4)
efit.exponential_fit(self.ws, type="T2", stretched=True)
self.assertAlmostEqual(self.ws["fit"].attrs["T2"], 0.8938213879865939, places=4)
efit.exponential_fit(self.ws, type="mono")
self.assertAlmostEqual(self.ws["fit"].attrs["tau"], 2.140702798915825, places=4)
def test_signal_to_noise(self):
ws = copy.deepcopy(self.ws)
nmr.remove_offset(ws)
nmr.window(ws, linewidth=15)
nmr.fourier_transform(ws, zero_fill_factor=2)
nmr.autophase(ws, method="arctan")
dnp.dnpTools.signal_to_noise(
ws,
signal_center=0,
signal_width="full",
noise_center="default",
noise_width="default",
)
self.assertEqual(len(ws["proc"].attrs["s_n"]), 8)
self.assertAlmostEqual(ws["proc"].attrs["s_n"][4],
10.91728842,
places=6)
nmr.remove_offset(self.ws_off)
nmr.window(self.ws_off, linewidth=15)
nmr.fourier_transform(self.ws_off, zero_fill_factor=2)
nmr.autophase(self.ws_off, method="search")
dnp.dnpTools.signal_to_noise(
self.ws_off,
signal_center=-10,
signal_width=100,
noise_center=200,
noise_width=50,
)
self.assertAlmostEqual(self.ws_off["proc"].attrs["s_n"],
3.3986939859030096,
places=6)
def test_baseline(self):
ws = copy.deepcopy(self.ws)
shape_data = np.shape(ws)
nmr.remove_offset(ws)
nmr.window(ws, linewidth=15)
nmr.fourier_transform(ws, zero_fill_factor=2)
nmr.autophase(ws, method="search")
dnp.dnpTools.baseline(ws,
type="polynomial",
order=1,
reference_slice=None)
self.assertEqual(shape_data, np.shape(ws))
self.assertAlmostEqual(max(ws["proc"].values[:, 2].real),
29.894686521140628,
places=4)
self.assertAlmostEqual(min(ws["proc"].values[:, 2].real),
-921.7417731961074,
places=4)
self.assertAlmostEqual(len(ws["proc"].attrs["baseline"]),
len(ws["proc"].values))
def test_basic_nmr_processing(self):
shape_data = np.shape(self.ws)
n_pts = np.shape(self.ws["proc"])
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 1].real), 5.447918664876271, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 1].real), -4.128415225672084, places=4
)
nmr.remove_offset(self.ws)
self.assertAlmostEqual(shape_data, np.shape(self.ws))
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 1].real), 5.445267326190019, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 1].real), -4.131066564358336, places=4
)
self.ws.copy("proc", "temp")
nmr.left_shift(self.ws, shift_points=100)
shifted_n_pts = np.shape(self.ws["proc"])
self.assertEqual(shifted_n_pts[0], n_pts[0] - 100)
self.ws.copy("temp", "proc")
wf = nmr.hamming_window(len(self.ws["proc"].values))
self.assertEqual(max(wf), 1.0)
self.assertAlmostEqual(min(wf), 0.07671999999999995, places=4)
wf = nmr.hann_window(len(self.ws["proc"].values))
self.assertEqual(max(wf), 1.0)
self.assertEqual(min(wf), 0.0)
wf = nmr.lorentz_gauss_window(self.ws["proc"], dim="t2", exp_lw=5, gauss_lw=10)
self.assertAlmostEqual(max(wf), 1.1895922020471337, places=4)
self.ws.copy("proc", "temp")
nmr.window(self.ws, type="hamming", inverse=True)
self.assertAlmostEqual(
max(self.ws["proc"].values[0]),
2.5727782192869477 - 4.397983406867447j,
places=4,
)
self.ws.copy("temp", "proc")
wf = nmr.sin2_window(len(self.ws["proc"]))
self.assertEqual(max(wf), 1.0)
wf = nmr.traf_window(self.ws["proc"], dim="t2", exp_lw=1, gauss_lw=1)
wf = nmr.exponential_window(self.ws["proc"], "t2", 5)
self.assertAlmostEqual(min(wf), 0.00035733315645396175, places=4)
self.ws.copy("proc", "temp")
nmr.window(self.ws, type="gaussian", linewidth=[2, 10])
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 1].real),
5.456135803263017,
places=4,
)
self.ws.copy("temp", "proc")
self.ws.pop("temp")
nmr.window(self.ws, type="exponential", linewidth=5)
self.assertEqual(shape_data, np.shape(self.ws))
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 1].real), 5.390978190372195, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 1].real), -3.9647928998767163, places=4
)
nmr.fourier_transform(self.ws, zero_fill_factor=2)
self.assertEqual(shape_data, np.shape(self.ws))
self.assertEqual(len(self.ws["proc"].values[:, 4].real), 15844)
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 4].real), 61.3994271072369, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 4].real), -76.53300374124703, places=4
)
self.ws.copy("proc", "temp")
nmr.autophase(
self.ws,
method="search",
order="first",
pivot=len(self.ws["proc"].values[:, 7]) / 2,
delta=np.pi / 2,
reference_slice=None,
force_positive=False,
)
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 3].real), 242.36299886442168, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 3].real), -65.59778997862813, places=4
)
phs0 = self.ws["proc"].attrs["phase0"]
phs1 = self.ws["proc"].attrs["phase1"]
self.assertEqual(len(phs1), len(self.ws["proc"].values))
self.ws.copy("proc", "keep")
self.ws.copy("temp", "proc")
nmr.autophase(
self.ws,
method="arctan",
order="zero",
reference_slice=1,
force_positive=True,
)
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 7].real), 398.66277628048533, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 7].real), -47.32339420356964, places=4
)
self.ws.copy("temp", "proc")
nmr.autophase(
self.ws,
method="manual",
order="first",
pivot=len(self.ws["proc"].values[:, 7]) / 2,
delta=np.pi / 2,
phase=phs1 * (45 * np.pi / 180),
)
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 3].real), 239.3422920589204, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 3].real), -64.37971134351001, places=4
)
self.ws.copy("temp", "proc")
nmr.autophase(
self.ws,
method="manual",
order="zero",
phase=phs0 * (45 * np.pi / 180),
)
self.assertAlmostEqual(
max(self.ws["proc"].values[:, 3].real), 238.27990936049952, places=4
)
self.assertAlmostEqual(
min(self.ws["proc"].values[:, 3].real), -66.28951430959444, places=4
)
def test_basic_nmr_processing(self):
self.ws = nmr.remove_offset(self.ws, {})
self.ws = nmr.window(self.ws, {})
self.ws = nmr.fourier_transform(self.ws, {})
self.ws = nmr.autophase(self.ws, {})