def test_2D_area():
data = np.zeros((256, 128), dtype=float)
data[128, 64] = 1.0
csdm_obj = cp.as_csdm(data)
# test00
PS = [
sp.IFFT(dim_index=(0, 1)),
sp.apodization.Gaussian(FWHM="35", dim_index=0),
sp.apodization.Gaussian(FWHM="55", dim_index=1),
sp.FFT(dim_index=(0, 1)),
]
post_sim = sp.SignalProcessor(operations=PS)
data_new = post_sim.apply_operations(data=csdm_obj.copy())
_, __, y1 = data_new.to_list()
assert np.allclose(y1.sum(), data.sum())
# test01
PS = [
sp.IFFT(dim_index=(0, 1)),
sp.apodization.Gaussian(FWHM="35", dim_index=0),
sp.apodization.Exponential(FWHM="55", dim_index=1),
sp.FFT(dim_index=(0, 1)),
]
post_sim = sp.SignalProcessor(operations=PS)
data_new = post_sim.apply_operations(data=csdm_obj.copy())
_, __, y1 = data_new.to_list()
assert np.allclose(y1.sum(), data.sum())
def setup_sim_and_processor():
site = Site(isotope="1H", shielding_symmetric={"zeta": -100, "eta": 0.3})
spin_sys = SpinSystem(sites=[site, site], abundance=45)
method = BlochDecaySpectrum(channels=["1H"])
sim = Simulator(spin_systems=[spin_sys, spin_sys],
methods=[method, method])
sim.run(method_index=0)
processor = sp.SignalProcessor(operations=[
sp.IFFT(),
sp.apodization.Exponential(FWHM="2500 Hz"),
sp.FFT(),
sp.Scale(factor=20),
])
processors = [processor] * 2
application = {
"com.github.DeepanshS.mrsimulator": {
"foo": "This is some metadata"
},
"com.github.DeepanshS.mrsimulator-app": {
"params": "The JSON string of params"
},
}
return sim, processors, application
def test_serialization_and_parse():
processor = sp.SignalProcessor(operations=[
sp.IFFT(dim_index=1),
sp.affine.Shear(factor="-1 K/s", dim_index=1, parallel=0),
sp.FFT(dim_index=1),
])
serialize = processor.json()
expected = {
"operations": [
{
"dim_index": 1,
"function": "IFFT"
},
{
"dim_index": 1,
"factor": "-1.0 K / s",
"function": "affine",
"parallel": 0,
"type": "Shear",
},
{
"dim_index": 1,
"function": "FFT"
},
],
}
assert serialize == expected
recovered = sp.SignalProcessor.parse_dict_with_units(serialize)
assert recovered == processor
def test_Gaussian():
FWHM = 200 * 2.354820045030949
PS_2 = [
sp.IFFT(dim_index=0),
sp.apodization.Gaussian(FWHM=f"{FWHM} Hz",
dim_index=0,
dv_index=[0, 1]),
sp.FFT(dim_index=0),
]
PS_3 = [
sp.IFFT(dim_index=0),
sp.apodization.Gaussian(FWHM=f"{FWHM} Hz", dim_index=0, dv_index=None),
sp.FFT(dim_index=0),
]
post_sim = sp.SignalProcessor(operations=PS_2)
data = post_sim.apply_operations(data=sim.methods[0].simulation.copy())
_, y0, y1, _ = data.to_list()
sigma = 200
test = (1 /
(sigma * np.sqrt(2 * np.pi))) * np.exp(-((freqHz / sigma)**2) / 2)
assert np.allclose(y0, y1), "Gaussian apodization on two dv are not equal."
assert np.allclose(test / test.sum(), y0 / y0.sum(),
atol=1e-04), "Gaussian apodization amplitude failed"
# test None for dv_index
post_sim = sp.SignalProcessor(operations=PS_3)
data = post_sim.apply_operations(data=sim.methods[0].simulation.copy())
_, y0, y1, y2 = data.to_list()
assert np.allclose(
y0, y1), "Gaussian apodization on dv at 0 and 1 are unequal."
assert np.allclose(
y0, y2), "Gaussian apodization on dv at 0 and 2 are unequal."
assert np.allclose(test / test.sum(), y0 / y0.sum(),
atol=1e-04), "Gaussian apodization amplitude failed"
def test_shear_01():
processor = sp.SignalProcessor(operations=[
sp.IFFT(dim_index=1),
af.Shear(factor="-1 K/s", dim_index=1, parallel=0),
sp.FFT(dim_index=1),
])
shear_data = processor.apply_operations(data=csdm_object)
index = np.where(
shear_data.dependent_variables[0].components[0] > 0.99999999)
a = np.arange(40)
assert np.allclose(index, [a, a])
# complex_fft dim=0 to false
csdm_object.dimensions[0].complex_fft = False
csdm_object.dimensions[1].complex_fft = True
shear_data = processor.apply_operations(data=csdm_object)
index = np.where(
shear_data.dependent_variables[0].components[0] > 0.99999999)
a1 = np.arange(20)
b1 = a1 + 20
b = np.append(b1, a1)
assert np.allclose(index, [a, b])
# complex_fft dim=1 to false
csdm_object.dimensions[0].complex_fft = True
csdm_object.dimensions[1].complex_fft = False
shear_data = processor.apply_operations(data=csdm_object)
index = np.where(
shear_data.dependent_variables[0].components[0] > 0.99999999)
b = np.arange(40)
b[1:] = a[::-1][:-1]
assert np.allclose(index, [a, b])
# both complex_fft set to false
csdm_object.dimensions[0].complex_fft = False
csdm_object.dimensions[1].complex_fft = False
shear_data = processor.apply_operations(data=csdm_object)
index = np.where(
shear_data.dependent_variables[0].components[0] > 0.99999999)
a1 = np.arange(21)[::-1]
b1 = a1[1:-1] + 20
b = np.append(a1, b1)
assert np.allclose(index, [a, b])
def setup_signal_processor():
op_list1 = [
sp.IFFT(dim_index=0),
sp.apodization.Exponential(FWHM=100),
sp.apodization.Gaussian(FWHM=200),
sp.FFT(dim_index=0),
sp.Scale(factor=10),
sp.baseline.ConstantOffset(offset=43.1),
sp.Linear(amplitude=32.9, offset=13.4),
]
op_list2 = [
sp.Scale(factor=20),
sp.baseline.ConstantOffset(offset=-43.1),
sp.Linear(amplitude=1.2, offset=0.4),
]
return [sp.SignalProcessor(operations=op) for op in [op_list1, op_list2]]
def test_SkewedGaussian():
# TODO: update this test for multiple skewes and using npp.convolve
skew = 2
FWHM = 200 * 2.354820045030949
PS_2 = [
sp.IFFT(dim_index=0),
sp.apodization.SkewedGaussian(skew=skew,
FWHM=f"{FWHM} Hz",
dim_index=0,
dv_index=[0, 1]),
sp.FFT(dim_index=0),
]
post_sim = sp.SignalProcessor(operations=PS_2)
data = post_sim.apply_operations(data=sim.methods[0].simulation.copy())
_, y0, y1, _ = data.to_list()
assert np.allclose(y0, y1), "Gaussian apodization on two dv are not equal."
def setup():
site = Site(isotope="1H", shielding_symmetric={"zeta": -100, "eta": 0.3})
spin_sys = SpinSystem(sites=[site, site], abundance=45)
method = BlochDecaySpectrum(channels=["1H"])
sim = Simulator(spin_systems=[spin_sys, spin_sys],
methods=[method, method])
sim.run(method_index=0)
processor = sp.SignalProcessor(operations=[
sp.IFFT(),
sp.apodization.Exponential(FWHM="2500 Hz"),
sp.FFT(),
sp.Scale(factor=20),
])
processors = [processor] * 2
return sim, processors
def test_Lorentzian():
PS_1 = [
sp.IFFT(dim_index=0),
sp.apodization.Exponential(FWHM="200 Hz", dim_index=0, dv_index=0),
sp.FFT(dim_index=0),
]
post_sim = sp.SignalProcessor(operations=PS_1)
data = post_sim.apply_operations(data=sim.methods[0].simulation.copy())
_, y0, y1, y2 = data.to_list()
FWHM = 200
test = (FWHM / 2) / (np.pi * (freqHz**2 + (FWHM / 2)**2))
assert np.allclose(y1, y2)
assert np.all(y0 != y1)
assert np.allclose(test / test.sum(), y0 / y0.sum(),
atol=1e-04), "Lorentzian apodization amplitude failed"
assert np.allclose(
y1.sum(), y0.sum()), "Area not conserved after Lorentzian apodization"
def test_01():
post_sim = sp.SignalProcessor()
operations = [
sp.IFFT(),
sp.apodization.Gaussian(FWHM="12 K", dim_index=0, dv_index=0),
sp.FFT(),
]
post_sim.operations = operations
with pytest.raises(ValueError, match="The data must be a CSDM object."):
post_sim.apply_operations([])
data = cp.as_csdm(np.arange(20))
data.x[0] = cp.LinearDimension(count=20, increment="10 K")
post_sim.apply_operations(data)
# to dict with units
dict_ = post_sim.json()
assert dict_ == {
"operations": [
{
"dim_index": 0,
"function": "IFFT"
},
{
"function": "apodization",
"type": "Gaussian",
"FWHM": "12.0 K",
"dim_index": 0,
"dv_index": 0,
},
{
"dim_index": 0,
"function": "FFT"
},
],
}
# parse dict with units
post_sim_2 = sp.SignalProcessor.parse_dict_with_units(dict_)
assert post_sim.operations == post_sim_2.operations
def test_Mask():
one_mask = np.zeros(shape=len(freqHz))
PS_5 = [
sp.IFFT(dim_index=0),
sp.apodization.Mask(mask=one_mask, dim_index=0, dv_index=[0, 1]),
sp.FFT(dim_index=0),
]
post_sim = sp.SignalProcessor(operations=PS_5)
data = post_sim.apply_operations(data=sim.methods[0].simulation.copy())
_, y0, y1, _ = data.to_list()
_, test_y0, test_y1, _ = sim.methods[0].simulation.to_list()
nonzero_y0 = np.count_nonzero(y0)
nonzero_y1 = np.count_nonzero(y1)
assert np.allclose(y0, y1), "Mask on two dv are not equal."
assert np.allclose(nonzero_y0, nonzero_y1,
atol=1e-04), "Mask apodization amplitude failed"
def test_7():
site = Site(isotope="23Na")
sys = SpinSystem(sites=[site], abundance=50)
sim = Simulator()
sim.spin_systems = [sys, sys]
sim.methods = [BlochDecayCTSpectrum(channels=["23Na"])]
sim.methods[0].experiment = cp.as_csdm(np.zeros(1024))
processor = sp.SignalProcessor(operations=[
sp.IFFT(dim_index=0),
sp.apodization.Gaussian(FWHM="0.2 kHz", dim_index=0),
sp.FFT(dim_index=0),
])
def test_array():
sim.run()
data = processor.apply_operations(sim.methods[0].simulation)
data_sum = 0
for dv in data.y:
data_sum += dv.components[0]
params = sf.make_LMFIT_params(sim, processor)
a = sf.LMFIT_min_function(params, sim, processor)
np.testing.assert_almost_equal(-a, data_sum, decimal=8)
dat = sf.add_csdm_dvs(data.real)
fits = sf.bestfit(sim, processor)
assert sf.add_csdm_dvs(fits[0]) == dat
res = sf.residuals(sim, processor)
assert res[0] == -dat
test_array()
sim.config.decompose_spectrum = "spin_system"
test_array()
ax = plt.subplot(projection="csdm")
cb = ax.imshow(data / data.max(), aspect="auto", cmap="gist_ncar_r")
plt.colorbar(cb)
ax.invert_xaxis()
ax.invert_yaxis()
plt.tight_layout()
plt.show()
# %%
# Add post-simulation signal processing.
processor = sp.SignalProcessor(operations=[
# Gaussian convolution along both dimensions.
sp.IFFT(dim_index=(0, 1)),
sp.apodization.Gaussian(FWHM="0.3 kHz", dim_index=0),
sp.apodization.Gaussian(FWHM="0.15 kHz", dim_index=1),
sp.FFT(dim_index=(0, 1)),
])
processed_data = processor.apply_operations(data=data)
processed_data /= processed_data.max()
# %%
# The plot of the simulation after signal processing.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
cb = ax.imshow(processed_data.real, cmap="gist_ncar_r", aspect="auto")
plt.colorbar(cb)
ax.invert_xaxis()
ax.invert_yaxis()
plt.tight_layout()
plt.show()
experiment=synthetic_experiment, # add the measurement to the method.
)
# %%
# **Step 3:** Create the Simulator object, add the method and spin system objects, and
# run the simulation.
sim = Simulator(spin_systems=[spin_system], methods=[MAS])
sim.run()
# %%
# **Step 4:** Create a SignalProcessor class and apply post simulation processing.
processor = sp.SignalProcessor(
operations=[
sp.IFFT(), # inverse FFT to convert frequency based spectrum to time domain.
sp.apodization.Exponential(FWHM="200 Hz"), # apodization of time domain signal.
sp.FFT(), # forward FFT to convert time domain signal to frequency spectrum.
sp.Scale(factor=3), # scale the frequency spectrum.
]
)
processed_data = processor.apply_operations(data=sim.methods[0].simulation).real
# %%
# **Step 5:** The plot the spectrum. We also plot the synthetic dataset for comparison.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
ax.plot(synthetic_experiment, "k", linewidth=1, label="Experiment")
ax.plot(processed_data, "r", alpha=0.75, linewidth=1, label="guess spectrum")
ax.set_xlim(50, -200)
plt.legend()
plt.grid()
plt.tight_layout()
# %%
# **Step 4:** Simulate the spectrum.
sim.run()
# The plot of the simulation before signal processing.
ax = plt.subplot(projection="csdm")
ax.plot(sim.methods[0].simulation.real, color="black", linewidth=1)
ax.invert_xaxis()
plt.tight_layout()
plt.show()
# %%
# **Step 5:** Add post-simulation signal processing.
processor = sp.SignalProcessor(
operations=[sp.IFFT(), apo.Exponential(
FWHM="10 Hz"), sp.FFT()])
processed_data = processor.apply_operations(data=sim.methods[0].simulation)
# The plot of the simulation after signal processing.
ax = plt.subplot(projection="csdm")
ax.plot(processed_data.real, color="black", linewidth=1)
ax.invert_xaxis()
plt.tight_layout()
plt.show()
# %%
# .. [#f3] Moudrakovski, I., Lang, S., Patchkovskii, S., and Ripmeester, J. High field
# :math:`^{33}\text{S}` solid state NMR and first-principles calculations in
# potassium sulfates. J. Phys. Chem. A, 2010, **114**, *1*, 309–316.
# `DOI: 10.1021/jp908206c <https://doi.org/10.1021/jp908206c>`_
# %%
# **Step 5:** Simulate the spectrum.
sim.run()
# The plot of the simulation before signal processing.
ax = plt.subplot(projection="csdm")
ax.plot(sim.methods[0].simulation.real, color="black", linewidth=1)
ax.invert_xaxis()
plt.tight_layout()
plt.show()
# %%
# **Step 6:** Add post-simulation signal processing.
processor = sp.SignalProcessor(
operations=[sp.IFFT(), apo.Exponential(
FWHM="70 Hz"), sp.FFT()])
processed_data = processor.apply_operations(data=sim.methods[0].simulation)
# The plot of the simulation after signal processing.
ax = plt.subplot(projection="csdm")
ax.plot(processed_data.real, color="black", linewidth=1)
ax.invert_xaxis()
plt.tight_layout()
plt.show()
# %%
# .. [#f1] Hansen, M. R., Jakobsen, H. J., Skibsted, J., :math:`^{29}\text{Si}`
# Chemical Shift Anisotropies in Calcium Silicates from High-Field
# :math:`^{29}\text{Si}` MAS NMR Spectroscopy, Inorg. Chem. 2003,
# **42**, *7*, 2368-2377.
# `DOI: 10.1021/ic020647f <https://doi.org/10.1021/ic020647f>`_
sys.transition_pathways = PASS.get_transition_pathways(sys)
# %%
# **Guess Spectrum**
# Simulation
# ----------
sim = Simulator(spin_systems=spin_systems, methods=[PASS])
sim.run()
# Post Simulation Processing
# --------------------------
processor = sp.SignalProcessor(
operations=[
# Lorentzian convolution along the isotropic dimensions.
sp.FFT(axis=0),
sp.apodization.Exponential(FWHM="50 Hz"),
sp.IFFT(axis=0),
sp.Scale(factor=60),
]
)
processed_data = processor.apply_operations(data=sim.methods[0].simulation).real
# Plot of the guess Spectrum
# --------------------------
plt.figure(figsize=(8, 3.5))
ax = plt.subplot(projection="csdm")
ax.contour(mat_data, colors="k", **options)
ax.contour(processed_data, colors="r", linestyles="--", **options)
ax.set_xlim(180, 15)
plt.grid()
# Run the simulation.
sim.run()
# Get the simulation data from the respective methods.
data_13C = sim.methods[
0].simulation # method at index 0 is 13C Bloch decay method.
data_15N = sim.methods[
1].simulation # method at index 1 is 15N Bloch decay method.
# %%
# Add post-simulation signal processing.
processor = sp.SignalProcessor(
operations=[sp.IFFT(),
sp.apodization.Exponential(FWHM="10 Hz"),
sp.FFT()])
# apply post-simulation processing to data_13C
processed_data_13C = processor.apply_operations(data=data_13C).real
# apply post-simulation processing to data_15N
processed_data_15N = processor.apply_operations(data=data_15N).real
# %%
# The plot of the simulation after signal processing.
fig, ax = plt.subplots(1,
2,
subplot_kw={"projection": "csdm"},
sharey=True,
figsize=(9, 4))
ax[0].plot(processed_data_13C, color="black", linewidth=0.5)
# %%
# **Step 5:** Simulate the spectrum.
sim.run()
# The plot of the simulation before signal processing.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
ax.plot(sim.methods[0].simulation.real, color="black", linewidth=1)
ax.invert_xaxis()
plt.tight_layout()
plt.show()
# %%
# **Step 6:** Add post-simulation signal processing.
processor = sp.SignalProcessor(
operations=[sp.IFFT(), sp.apodization.Exponential(FWHM="70 Hz"), sp.FFT()]
)
processed_data = processor.apply_operations(data=sim.methods[0].simulation)
# The plot of the simulation after signal processing.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
ax.plot(processed_data.real, color="black", linewidth=1)
ax.invert_xaxis()
plt.tight_layout()
plt.show()
# %%
# .. [#f1] Hansen, M. R., Jakobsen, H. J., Skibsted, J., :math:`^{29}\text{Si}`
# Chemical Shift Anisotropies in Calcium Silicates from High-Field
# :math:`^{29}\text{Si}` MAS NMR Spectroscopy, Inorg. Chem. 2003,
# %%
# **Guess Spectrum**
# Simulation
# ----------
sim = Simulator(spin_systems=spin_systems, methods=[shifting_d])
sim.config.integration_volume = "hemisphere"
sim.run()
# Post Simulation Processing
# --------------------------
processor = sp.SignalProcessor(operations=[
# Gaussian convolution along both dimensions.
sp.IFFT(dim_index=0),
sp.apodization.Gaussian(FWHM="10 kHz", dim_index=0), # along dimension 0
sp.FFT(dim_index=0),
sp.Scale(factor=5e8),
])
processed_data = processor.apply_operations(
data=sim.methods[0].simulation).real
# Plot of the guess Spectrum
# --------------------------
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
ax.contour(experiment, colors="k", **options)
ax.contour(processed_data, colors="r", linestyles="--", **options)
ax.set_xlim(2500, -1500)
ax.set_ylim(2000, -2200)
plt.grid()
plt.tight_layout()
# ----------
# Add the spin systems and the three methods to the simulator object.
sim = Simulator(spin_systems=spin_systems, methods=[MAS1, MAS2, MAS3])
sim.config.decompose_spectrum = "spin_system"
sim.run()
# Post Simulation Processing
# --------------------------
# Add signal processing to simulation dataset from the three methods.
# Processor for dataset 1
processor1 = sp.SignalProcessor(operations=[
sp.IFFT(),
sp.apodization.Exponential(FWHM="20 Hz", dv_index=0), # spin system 0
sp.apodization.Exponential(FWHM="200 Hz", dv_index=1), # spin system 1
sp.FFT(),
sp.Scale(factor=10), # dataset is scaled independently using scale factor.
])
# Processor for dataset 2
processor2 = sp.SignalProcessor(operations=[
sp.IFFT(),
sp.apodization.Exponential(FWHM="30 Hz", dv_index=0), # spin system 0
sp.apodization.Exponential(FWHM="300 Hz", dv_index=1), # spin system 1
sp.FFT(),
sp.Scale(
factor=100), # dataset is scaled independently using scale factor.
])
# Processor for dataset 3
processor3 = sp.SignalProcessor(operations=[
def test_MQMAS():
site = Site(
isotope="87Rb",
isotropic_chemical_shift=-9,
shielding_symmetric={
"zeta": 100,
"eta": 0
},
quadrupolar={
"Cq": 3.5e6,
"eta": 0.36,
"beta": 70 / 180 * np.pi
},
)
spin_system = SpinSystem(sites=[site])
method = Method2D(
channels=["87Rb"],
magnetic_flux_density=9.4,
spectral_dimensions=[
{
"count": 128,
"spectral_width": 20000,
"events": [{
"transition_query": [{
"P": [-3],
"D": [0]
}]
}],
},
{
"count": 128,
"spectral_width": 20000,
"events": [{
"transition_query": [{
"P": [-1],
"D": [0]
}]
}],
},
],
)
sim = Simulator()
sim.spin_systems = [spin_system]
sim.methods = [method]
sim.config.integration_volume = "hemisphere"
sim.run()
# process
k = 21 / 27 # shear factor
processor = sp.SignalProcessor(operations=[
sp.IFFT(dim_index=1),
aft.Shear(factor=-k, dim_index=1, parallel=0),
aft.Scale(factor=1 + k, dim_index=1),
sp.FFT(dim_index=1),
])
processed_data = processor.apply_operations(
data=sim.methods[0].simulation).real
# Since there is a single site, after the shear and scaling transformations, there
# should be a single perak along the isotropic dimension at index 70.
# The isotropic coordinate of this peak is given by
# w_iso = (17.8)*iso_shift + 1e6/8 * (vq/v0)^2 * (eta^2 / 3 + 1)
# ref: D. Massiot et al. / Solid State Nuclear Magnetic Resonance 6 (1996) 73-83
iso_slice = processed_data[40, :]
assert np.argmax(iso_slice.y[0].components[0]) == 70
# calculate the isotropic coordinate
spin = method.channels[0].spin
w0 = method.channels[0].gyromagnetic_ratio * 9.4 * 1e6
wq = 3 * 3.5e6 / (2 * spin * (2 * spin - 1))
w_iso = -9 * 17 / 8 + 1e6 / 8 * (wq / w0)**2 * ((0.36**2) / 3 + 1)
# the coordinate from spectrum
w_iso_spectrum = processed_data.x[1].coordinates[70].value
np.testing.assert_almost_equal(w_iso, w_iso_spectrum, decimal=2)
# The projection onto the MAS dimension should be the 1D block decay central
# transition spectrum
mas_slice = processed_data.sum(axis=1).y[0].components[0]
# MAS spectrum
method = BlochDecayCTSpectrum(
channels=["87Rb"],
magnetic_flux_density=9.4,
rotor_frequency=1e9,
spectral_dimensions=[{
"count": 128,
"spectral_width": 20000
}],
)
sim = Simulator()
sim.spin_systems = [spin_system]
sim.methods = [method]
sim.config.integration_volume = "hemisphere"
sim.run()
data = sim.methods[0].simulation.y[0].components[0]
np.testing.assert_almost_equal(data / data.max(),
mas_slice / mas_slice.max(),
decimal=2,
err_msg="not equal")
for sys in spin_systems:
sys.transition_pathways = MAS_CT.get_transition_pathways(sys)
# %%
# **Step 3:** Create the Simulator object and add the method and spin system objects.
sim = Simulator(spin_systems=spin_systems, methods=[MAS_CT])
sim.config.decompose_spectrum = "spin_system"
sim.run()
# %%
# **Step 4:** Create a SignalProcessor class object and apply the post-simulation
# signal processing operations.
processor = sp.SignalProcessor(operations=[
sp.IFFT(),
sp.apodization.Gaussian(FWHM="100 Hz"),
sp.FFT(),
sp.Scale(factor=200.0),
])
processed_data = processor.apply_operations(
data=sim.methods[0].simulation).real
# %%
# **Step 5:** The plot of the data and the guess spectrum.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
ax.plot(experiment, color="black", linewidth=0.5, label="Experiment")
ax.plot(processed_data, linewidth=2, alpha=0.6)
ax.set_xlim(100, -50)
plt.legend()
plt.grid()
plt.tight_layout()
# Add the methods to the Simulator object and run the simulation
# Add the methods.
sim.methods = [method_13C, method_15N]
# Run the simulation.
sim.run()
# Get the simulation data from the respective methods.
data_13C = sim.methods[0].simulation # method at index 0 is 13C Bloch decay method.
data_15N = sim.methods[1].simulation # method at index 1 is 15N Bloch decay method.
# %%
# Add post-simulation signal processing.
processor = sp.SignalProcessor(
operations=[sp.IFFT(), apo.Exponential(FWHM="10 Hz"), sp.FFT()]
)
# apply post-simulation processing to data_13C
processed_data_13C = processor.apply_operations(data=data_13C).real
# apply post-simulation processing to data_15N
processed_data_15N = processor.apply_operations(data=data_15N).real
# %%
# The plot of the simulation after signal processing.
fig, ax = plt.subplots(1, 2, subplot_kw={"projection": "csdm"}, sharey=True)
ax[0].plot(processed_data_13C, color="black", linewidth=0.5)
ax[0].invert_xaxis()
ax[1].plot(processed_data_15N, color="black", linewidth=0.5)
