def test_method_exp_sim():
spin_system = SpinSystem(sites=[
Site(
isotope="27Al",
isotropic_chemical_shift=64.5, # in ppm
quadrupolar={
"Cq": 3.22e6,
"eta": 0.66
}, # Cq is in Hz
)
])
data = cp.as_csdm(np.random.rand(1024, 512))
method = ThreeQ_VAS(
channels=["27Al"],
magnetic_flux_density=7,
spectral_dimensions=[
{
"count": 1024,
"spectral_width": 5000,
"reference_offset": -3e3
},
{
"count": 512,
"spectral_width": 10000,
"reference_offset": 4e3
},
],
experiment=data,
)
sim = Simulator()
sim.spin_systems = [spin_system]
sim.methods = [method]
sim.run()
def pre_setup(isotope, shift, reference_offset):
spin_system = SpinSystem(
sites=[Site(isotope=isotope, isotropic_chemical_shift=shift)])
method = Method.parse_dict_with_units(
dict(
channels=[isotope],
spectral_dimensions=[{
"count":
2048,
"spectral_width":
"25 kHz",
"reference_offset":
f"{reference_offset} Hz",
"events": [{
"magnetic_flux_density": "9.4 T",
"transition_queries": [{
"ch1": {
"P": [-1]
}
}],
}],
}],
))
sim = Simulator()
sim.spin_systems.append(spin_system)
sim.methods = [method]
sim.run()
x, y = sim.methods[0].simulation.to_list()
return x[np.argmax(y)], abs(x[1] - x[0])
def test_empty_spin_sys_simulator():
sim = Simulator()
sim.methods = [
BlochDecaySpectrum(channels=["1H"], spectral_dimensions=[{"count": 10}])
]
sim.config.decompose_spectrum = "spin_system"
sim.run()
assert np.allclose(sim.methods[0].simulation.y[0].components[0], 0)
def test_simulator_assignments():
a = Simulator()
assert a.spin_systems == []
error = "value is not a valid list"
with pytest.raises(Exception, match=f".*{error}.*"):
a.spin_systems = ""
with pytest.raises(Exception, match=f".*{error}.*"):
a.methods = ""
def generate_simulator(spin_systems,
method,
integration_volume="octant",
number_of_sidebands=64):
sim = Simulator()
sim.spin_systems = spin_systems
sim.methods = [method]
sim.config.integration_volume = integration_volume
sim.config.number_of_sidebands = number_of_sidebands
return sim
def pre_setup():
site_1 = Site(isotope="13C", shielding_symmetric={"zeta": 50, "eta": 0.5})
spin_system = SpinSystem(sites=[site_1])
method = BlochDecaySpectrum(channels=["13C"],
spectral_dimensions=[{
"count": 1024,
"spectral_width": 25000
}])
sim = Simulator()
sim.spin_systems.append(spin_system)
sim.methods = [method]
return sim
def generate_shielding_kernel(zeta_,
eta_,
angle,
freq,
n_sidebands,
to_ppm=True):
method = BlochDecaySpectrum(
channels=["29Si"],
magnetic_flux_density=9.4,
spectral_dimensions=[
dict(count=96, spectral_width=208.33 * 96, reference_offset=0)
],
rotor_angle=angle,
rotor_frequency=freq,
)
if to_ppm:
larmor_frequency = -method.channels[
0].gyromagnetic_ratio * 9.4 # in MHz
zeta_ /= larmor_frequency
spin_systems = [
SpinSystem(sites=[
Site(isotope="29Si", shielding_symmetric={
"zeta": z,
"eta": e
})
]) for z, e in zip(zeta_, eta_)
]
sim = Simulator()
sim.spin_systems = spin_systems
sim.methods = [method]
sim.config.decompose_spectrum = "spin_system"
sim.config.number_of_sidebands = n_sidebands
sim.run(pack_as_csdm=False)
sim_lineshape = sim.methods[0].simulation.real
sim_lineshape = np.asarray(sim_lineshape).reshape(4, 4, 96)
sim_lineshape = sim_lineshape / sim_lineshape[0, 0].sum()
sim_lineshape[0, :, :] /= 2.0
sim_lineshape[:, 0, :] /= 2.0
sim_lineshape.shape = (16, 96)
return sim_lineshape
def test_simulator_2():
sim = Simulator()
sim.spin_systems = [
SpinSystem(
sites=[Site(isotope="1H"),
Site(isotope="23Na")],
couplings=[Coupling(site_index=[0, 1], isotropic_j=15)],
)
]
sim.methods = [
BlochDecaySpectrum(
channels=["1H"],
spectral_dimensions=[{
"count": 10
}],
experiment=cp.as_csdm(np.arange(10)),
)
]
sim.name = "test"
sim.label = "test0"
sim.description = "testing-testing 1.2.3"
sim.run()
# save
sim.save("test_sim_save.temp")
sim_load = Simulator.load("test_sim_save.temp")
sim_load_data = sim_load.methods[0].simulation
sim_data = sim.methods[0].simulation
sim_load_data._timestamp = ""
assert sim_load_data.dict() == sim_data.dict()
sim_load.methods[0].simulation = None
sim.methods[0].simulation = None
assert sim_load.spin_systems == sim.spin_systems
assert sim_load.methods == sim.methods
assert sim_load.name == sim.name
assert sim_load.description == sim.description
os.remove("test_sim_save.temp")
def kernel(self, supersampling=1):
"""
Return the NMR nuclear shielding anisotropic line-shape kernel.
Args:
supersampling: An integer. Each cell is supersampled by the factor
`supersampling` along every dimension.
Returns:
A numpy array containing the line-shape kernel.
"""
args_ = deepcopy(self.method_args)
method = BlochDecaySpectrum.parse_dict_with_units(args_)
isotope = args_["channels"][0]
zeta, eta = self._get_zeta_eta(supersampling)
x_csdm = self.inverse_kernel_dimension[0]
if x_csdm.coordinates.unit.physical_type == "frequency":
# convert zeta to ppm if given in frequency units.
zeta /= self.larmor_frequency # zeta in ppm
for dim_i in self.inverse_kernel_dimension:
if dim_i.origin_offset.value == 0:
dim_i.origin_offset = f"{abs(self.larmor_frequency)} MHz"
spin_systems = [
SpinSystem(sites=[
dict(isotope=isotope, shielding_symmetric=dict(zeta=z, eta=e))
]) for z, e in zip(zeta, eta)
]
sim = Simulator()
sim.config.number_of_sidebands = self.number_of_sidebands
sim.config.decompose_spectrum = "spin_system"
sim.spin_systems = spin_systems
sim.methods = [method]
sim.run(pack_as_csdm=False)
amp = sim.methods[0].simulation.real
return self._averaged_kernel(amp, supersampling)
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()
dataset = processor.apply_operations(sim.methods[0].simulation)
data_sum = 0
for dv in dataset.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(dataset.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()
def test_ThreeQ_VAS_spin_3halves():
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 = ThreeQ_VAS(
channels=["87Rb"],
magnetic_flux_density=9.4,
spectral_dimensions=[
{
"count": 1024,
"spectral_width": 20000
},
{
"count": 512,
"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
dat = data.y[0].components[0]
index = np.where(dat == dat.max())[0]
# The isotropic coordinate of this peak is given by
# v_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
spin = method.channels[0].spin
v0 = method.channels[0].gyromagnetic_ratio * 9.4 * 1e6
vq = (3 * 3.5e6) / (2 * spin * (2 * spin - 1))
v_iso = -9 * 17 / 8 + 1e6 / 8 * ((vq / v0)**2) * ((0.36**2) / 3 + 1)
# the coordinate from spectrum along the iso dimension must be equal to v_iso
v_iso_spectrum = data.x[1].coordinates[index[0]].value
np.testing.assert_almost_equal(v_iso, v_iso_spectrum, decimal=2)
# The projection onto the MAS dimension should be the 1D block decay central
# transition spectrum
mas_slice = 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": 512,
"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]
assert np.allclose(data / data.max(), mas_slice / mas_slice.max())
label="Fast MAS dimension",
),
],
)
# A graphical representation of the method object.
plt.figure(figsize=(5, 3.5))
qmat.plot()
plt.show()
# %%
# Create the Simulator object, add the method and spin system objects, and
# run the simulation.
sim = Simulator()
sim.spin_systems = spin_systems # add the spin systems
sim.methods = [qmat] # add the method.
# For 2D spinning sideband simulation, set the number of spinning sidebands in the
# Simulator.config object to `spectral_width/rotor_frequency` along the sideband
# dimension.
sim.config.number_of_sidebands = 32
sim.run()
# %%
# The plot of the simulation.
plt.figure(figsize=(4.25, 3.0))
data = sim.methods[0].simulation.real
ax = plt.subplot(projection="csdm")
cb = ax.imshow(data / data.max(), aspect="auto", cmap="gist_ncar_r", vmax=0.15)
plt.colorbar(cb)
ax.invert_xaxis()
"spectral_width": 50000, # in Hz
"label": r"$^{17}$O resonances",
}],
)
# %%
# The above method is set up to record the :math:`^{17}\text{O}` resonances at the
# magic angle, spinning at 14 kHz and 9.4 T (default, if the value is not provided)
# external magnetic flux density. The resonances are recorded over 50 kHz spectral
# width using 2048 points.
# %%
# **Step 4:** Create the Simulator object and add the method and spin system objects.
sim = Simulator()
sim.spin_systems = spin_systems # add the spin systems
sim.methods = [method] # add the method
# %%
# **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=[
2e4, # in Hz
"reference_offset":
0, # in Hz
"label":
"MAS dimension",
"events": [{
"rotor_angle": 54.735 * 3.14159 / 180,
"transition_query": [{
"P": [-1],
"D": [0]
}],
}],
},
],
)
sim.methods = [das] # add the method.
# %%
# Run the simulation
sim.run()
# %%
# The plot of the simulation.
data = sim.methods[0].simulation
plt.figure(figsize=(4.25, 3.0))
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()
},
{
"count": 512,
"spectral_width": 5e3, # in Hz
"reference_offset": -4e3, # in Hz
"label": "MAS dimension",
},
],
))
# %%
# Create the Simulator object, add the method and spin system objects, and
# run the simulation.
sim = Simulator()
sim.spin_systems = spin_systems # add the spin systems
sim.methods = method # add the methods.
sim.run()
# %%
# The plot of the simulation.
data = [sim.methods[0].simulation, sim.methods[1].simulation]
fig, ax = plt.subplots(1,
2,
figsize=(8.5, 3),
subplot_kw={"projection": "csdm"})
titles = ["STVAS @ magic-angle", "STVAS @ 0.0059 deg off magic-angle"]
for i, item in enumerate(data):
cb1 = ax[i].imshow(item / item.max(), aspect="auto", cmap="gist_ncar_r")
ax[i].set_title(titles[i])
plt.colorbar(cb1, ax=ax[i])
"reference_offset": -1.05e4, # in Hz
"label": "Isotropic dimension",
"events": [{
"rotor_angle": 54.735 * 3.14159 / 180
}],
},
],
affine_matrix=[[1, -1], [0, 1]],
)
# %%
# Create the Simulator object, add the method and spin system objects, and run the
# simulation.
sim = Simulator()
sim.spin_systems = spin_systems # add the spin systems
sim.methods = [maf] # add the method
sim.run()
# %%
# Add post-simulation signal processing.
csdm_data = sim.methods[0].simulation
processor = sp.SignalProcessor(operations=[
sp.IFFT(dim_index=(0, 1)),
apo.Gaussian(FWHM="50 Hz", dim_index=0),
apo.Gaussian(FWHM="50 Hz", dim_index=1),
sp.FFT(dim_index=(0, 1)),
])
processed_data = processor.apply_operations(data=csdm_data).real
processed_data /= processed_data.max()
# %%
rotor_frequency=2000,
spectral_dimensions=[
{
"count": 20 * 4,
"spectral_width": 2000 * 20, # value in Hz
"label": "Anisotropic dimension",
},
{
"count": 1024,
"spectral_width": 3e4, # value in Hz
"reference_offset": 1.1e4, # value in Hz
"label": "Isotropic dimension",
},
],
)
sim.methods = [PASS] # add the method.
# For 2D spinning sideband simulation, set the number of spinning sidebands in the
# Simulator.config object to `spectral_width/rotor_frequency` along the sideband
# dimension.
sim.config.number_of_sidebands = 20
# run the simulation.
sim.run()
# %%
# Apply post-simulation processing. Here, we apply a Lorentzian line broadening to the
# isotropic dimension.
data = sim.methods[0].simulation
processor = sp.SignalProcessor(operations=[
sp.IFFT(dim_index=0),
],
),
],
)
# A graphical representation of the method object.
plt.figure(figsize=(5, 3.5))
coaster.plot()
plt.show()
# %%
# Create the Simulator object, add the method and spin system objects, and
# run the simulation.
sim = Simulator()
sim.spin_systems = [spin_system] # add the spin systems
sim.methods = [coaster] # add the method.
# configure the simulator object. For non-coincidental tensors, set the value of the
# `integration_volume` attribute to `hemisphere`.
sim.config.integration_volume = "hemisphere"
sim.run()
# %%
# The plot of the simulation.
data = sim.methods[0].simulation
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
cb = ax.imshow(data.real / data.real.max(), aspect="auto", cmap="gist_ncar_r")
plt.colorbar(cb)
ax.invert_xaxis()
label="Isotropic dimension",
),
dict(
count=512,
spectral_width=2e4, # in Hz
reference_offset=2e3, # in Hz
label="MAS dimension",
),
],
)
# %%
# Create the simulator object, add the spin systems and method, and run the simulation.
sim = Simulator()
sim.spin_systems = spin_systems # add the spin systems
sim.methods = [mqvas] # add the method
sim.config.number_of_sidebands = 1
sim.run()
data = sim.methods[0].simulation.real
# %%
# The plot of the corresponding spectrum.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
cb = ax.imshow(data / data.max(), cmap="gist_ncar_r", aspect="auto")
plt.colorbar(cb)
ax.set_ylim(-20, -50)
ax.set_xlim(80, 20)
plt.tight_layout()
plt.show()
channels=["15N"],
magnetic_flux_density=11.74, # in T
rotor_frequency=3000, # in Hz
spectral_dimensions=[{
"count": 8192,
"spectral_width": 4e4, # in Hz
"reference_offset": 7e3, # in Hz
"label": r"$^{15}$N resonances",
}],
)
# %%
# 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(),
sp.apodization.Exponential(FWHM="10 Hz"),
def setup_simulation(site, affine_matrix, class_id=0):
isotope = site.isotope.symbol
spin_system = [SpinSystem(sites=[site])]
method_C = method_class[class_id]
method = method_C(
channels=[isotope],
magnetic_flux_density=7, # in T
rotor_angle=54.735 * np.pi / 180,
spectral_dimensions=[
{
"count": 512,
"spectral_width": 4e4, # in Hz
"reference_offset": -3e3, # in Hz
},
{
"count": 1024,
"spectral_width": 1e4, # in Hz
"reference_offset": -4e3, # in Hz
},
],
affine_matrix=affine_matrix,
)
method_1 = Method(
channels=[isotope],
magnetic_flux_density=7, # in T
rotor_angle=54.735 * np.pi / 180,
rotor_frequency=np.inf,
spectral_dimensions=[
{
"count": 1024,
"spectral_width": 1e4, # in Hz
"reference_offset": -4e3, # in Hz
"events": [
{
"fraction": 27 / 17,
"freq_contrib": ["Quad2_0"],
"transition_queries": [{"ch1": {"P": [-1], "D": [0]}}],
},
{
"fraction": 1,
"freq_contrib": ["Quad2_4"],
"transition_queries": [{"ch1": {"P": [-1], "D": [0]}}],
},
],
}
],
)
sim = Simulator()
sim.spin_systems = spin_system # add the spin-system
sim.methods = [method, method_1] # add the method
# run the simulation
sim.config.number_of_sidebands = 1
sim.run()
csdm_data1 = sim.methods[0].simulation.real.sum(axis=1)
csdm_data2 = sim.methods[1].simulation.real
csdm_data1 /= csdm_data1.max()
csdm_data2 /= csdm_data2.max()
np.testing.assert_almost_equal(
csdm_data1.y[0].components, csdm_data2.y[0].components, decimal=3
)
# '''''''''''''''''''''
#
# Create the spin systems from the above :math:`\zeta` and :math:`\eta` parameters.
systems = single_site_system_generator(isotopes="13C",
shielding_symmetric={
"zeta": z_dist,
"eta": e_dist
},
abundance=amp)
print(len(systems))
# %%
# Create a simulator object and add the above system.
sim = Simulator()
sim.spin_systems = systems # add the systems
sim.methods = [BlochDecaySpectrum(channels=["13C"])] # add the method
sim.run()
# %%
# The following is the static spectrum arising from a Czjzek distribution of the
# second-rank traceless shielding tensors.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
ax.plot(sim.methods[0].simulation, color="black", linewidth=1)
plt.tight_layout()
plt.show()
# %%
# Quadrupolar tensor
# ------------------
#
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")
}
method2 = {
"channels": ["1H"],
"magnetic_flux_density": "9.4 T",
"rotor_frequency": "1 kHz",
"rotor_angle": "54.735 deg",
"spectral_dimensions": [
{"count": 2048, "spectral_width": "25 kHz", "reference_offset": "0 Hz",}
],
}
sim = Simulator()
sim.spin_systems = [SpinSystem.parse_dict_with_units(item) for item in spin_systems]
sim.methods = [
BlochDecaySpectrum.parse_dict_with_units(method1),
BlochDecaySpectrum.parse_dict_with_units(method2),
]
sim.run()
freq1, amp1 = sim.methods[0].simulation.to_list()
freq2, amp2 = sim.methods[1].simulation.to_list()
fig, ax = plt.subplots(1, 2, figsize=(6, 3))
ax[0].plot(freq1, amp1, linewidth=1.0, color="k")
ax[0].set_xlabel(f"frequency ratio / {freq2.unit}")
ax[0].grid(color="gray", linestyle="--", linewidth=0.5, alpha=0.5)
ax[0].set_title("Static")
ax[1].plot(freq2, amp2, linewidth=1.0, color="k")
ax[1].set_xlabel(f"frequency ratio / {freq2.unit}")
ax[1].grid(color="gray", linestyle="--", linewidth=0.5, alpha=0.5)
def test_MQMAS_spin_5halves():
spin_system = SpinSystem(sites=[
Site(
isotope="27Al",
isotropic_chemical_shift=64.5, # in ppm
quadrupolar={
"Cq": 3.22e6,
"eta": 0.66
}, # Cq is in Hz
)
])
method = ThreeQ_VAS(
channels=["27Al"],
magnetic_flux_density=7,
spectral_dimensions=[
{
"count": 1024,
"spectral_width": 5000,
"reference_offset": -3e3
},
{
"count": 512,
"spectral_width": 10000,
"reference_offset": 4e3
},
],
)
sim = Simulator()
sim.spin_systems = [spin_system]
sim.methods = [method]
sim.run()
data = sim.methods[0].simulation
dat = data.y[0].components[0]
index = np.where(dat == dat.max())[0]
# The isotropic coordinate of this peak is given by
# v_iso = -(17/31)*iso_shift + 8e6/93 * (vq/v0)^2 * (eta^2 / 3 + 1)
# ref: D. Massiot et al. / Solid State Nuclear Magnetic Resonance 6 (1996) 73-83
spin = method.channels[0].spin
v0 = method.channels[0].gyromagnetic_ratio * 7 * 1e6
vq = 3 * 3.22e6 / (2 * spin * (2 * spin - 1))
v_iso = -(17 / 31) * 64.5 - (8e6 / 93) * (vq / v0)**2 * ((0.66**2) / 3 + 1)
# the coordinate from spectrum along the iso dimension must be equal to v_iso
v_iso_spectrum = data.x[1].coordinates[index[0]].value
np.testing.assert_almost_equal(v_iso, v_iso_spectrum, decimal=2)
# The projection onto the MAS dimension should be the 1D block decay central
# transition spectrum
mas_slice = data.sum(axis=1).y[0].components[0]
# MAS spectrum
method = BlochDecayCTSpectrum(
channels=["27Al"],
magnetic_flux_density=7,
rotor_frequency=1e9,
spectral_dimensions=[{
"count": 512,
"spectral_width": 10000,
"reference_offset": 4e3
}],
)
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]
assert np.allclose(data / data.max(), mas_slice / mas_slice.max())
def generate_simulator(spin_systems, method):
sim = Simulator()
sim.spin_systems = spin_systems
sim.methods = [method]
return sim
def SSB2D_setup(ist, vr, method_type):
sites = [
Site(
isotope=ist,
isotropic_chemical_shift=29,
shielding_symmetric={
"zeta": -70,
"eta": 0.000
},
),
Site(
isotope=ist,
isotropic_chemical_shift=44,
shielding_symmetric={
"zeta": -96,
"eta": 0.166
},
),
Site(
isotope=ist,
isotropic_chemical_shift=57,
shielding_symmetric={
"zeta": -120,
"eta": 0.168
},
),
]
spin_systems = [SpinSystem(sites=[s]) for s in sites]
B0 = 11.7
if method_type == "PASS":
method = SSB2D(
channels=[ist],
magnetic_flux_density=B0, # in T
rotor_frequency=vr,
spectral_dimensions=[
{
"count": 32,
"spectral_width": 32 * vr, # in Hz
"label": "Anisotropic dimension",
},
# The last spectral dimension block is the direct-dimension
{
"count": 2048,
"spectral_width": 2e4, # in Hz
"reference_offset": 5e3, # in Hz
"label": "Fast MAS dimension",
},
],
)
else:
method = Method2D(
channels=[ist],
magnetic_flux_density=B0, # in T
spectral_dimensions=[
{
"count": 64,
"spectral_width": 8e4, # in Hz
"label": "Anisotropic dimension",
"events": [{
"rotor_angle": 90 * 3.14159 / 180
}],
},
# The last spectral dimension block is the direct-dimension
{
"count": 2048,
"spectral_width": 2e4, # in Hz
"reference_offset": 5e3, # in Hz
"label": "Fast MAS dimension",
},
],
affine_matrix=[[1, -1], [0, 1]],
)
sim = Simulator()
sim.spin_systems = spin_systems # add spin systems
sim.methods = [method] # add the method.
sim.run()
data_ssb = sim.methods[0].simulation
dim_ssb = data_ssb.x[0].coordinates.value
if method_type == "PASS":
bloch = BlochDecaySpectrum(
channels=[ist],
magnetic_flux_density=B0, # in T
rotor_frequency=vr, # in Hz
spectral_dimensions=[
{
"count": 32,
"spectral_width": 32 * vr, # in Hz
"reference_offset": 0, # in Hz
"label": "MAS dimension",
},
],
)
else:
bloch = BlochDecaySpectrum(
channels=[ist],
magnetic_flux_density=B0, # in T
rotor_frequency=vr, # in Hz
rotor_angle=90 * 3.14159 / 180,
spectral_dimensions=[
{
"count": 64,
"spectral_width": 8e4, # in Hz
"reference_offset": 0, # in Hz
"label": "MAS dimension",
},
],
)
for i in range(3):
iso = spin_systems[i].sites[0].isotropic_chemical_shift
sys = spin_systems[i].copy()
sys.sites[0].isotropic_chemical_shift = 0
sim2 = Simulator()
sim2.spin_systems = [sys] # add spin systems
sim2.methods = [bloch] # add the method.
sim2.run()
index = np.where(dim_ssb < iso)[0][-1]
one_d_section = data_ssb.y[0].components[0][:, index]
one_d_section /= one_d_section.max()
one_d_sim = sim2.methods[0].simulation.y[0].components[0]
one_d_sim /= one_d_sim.max()
np.testing.assert_almost_equal(one_d_section, one_d_sim, decimal=6)
# As mentioned before, a method object is decoupled from the spin system object. Notice,
# when we get the transition pathways from this method for a single-site spin system, we
# get a single transition pathway.
print(hahn_echo.get_transition_pathways(spin_system_1))
# %%
# In the case of a homonuclear two-site spin 1/2 spin system, the same method returns
# four transition pathways.
print(hahn_echo.get_transition_pathways(spin_system_2))
# %%
# Create the Simulator object, add the method and spin system objects, and run the
# simulation.
sim = Simulator()
sim.spin_systems = [spin_system_1, spin_system_2] # add the spin systems
sim.methods = [hahn_echo] # add the method
sim.config.decompose_spectrum = "spin_system"
sim.run()
# %%
# The simulation from each spin system is stored as a dependent variable within the
# CSDM object. Use the `split` function to split the list of the dependent variables
# into a list of CSDM objects.
simulation_results = sim.methods[0].simulation.split()
# The plot of the two simulations.
fig, ax = plt.subplots(1,
2,
figsize=(8.0, 3.0),
subplot_kw={"projection": "csdm"})
# %%
# Simulate the spectrum
# '''''''''''''''''''''
#
# Create the spin systems from the above :math:`\zeta` and :math:`\eta` parameters.
systems = single_site_system_generator(
isotope="13C", shielding_symmetric={"zeta": z_dist, "eta": e_dist}, abundance=amp
)
print(len(systems))
# %%
# Create a simulator object and add the above system.
sim = Simulator()
sim.spin_systems = systems # add the systems
sim.methods = [BlochDecaySpectrum(channels=["13C"])] # add the method
sim.run()
# %%
# The following is the static spectrum arising from a Czjzek distribution of the
# second-rank traceless shielding tensors.
plt.figure(figsize=(4.25, 3.0))
ax = plt.subplot(projection="csdm")
ax.plot(sim.methods[0].simulation.real, color="black", linewidth=1)
plt.tight_layout()
plt.show()
# %%
# Quadrupolar tensor
# ------------------
#
abundance=pdf,
)
# %%
# Static spectrum
# ---------------
# Observe the static :math:`^{27}\text{Al}` NMR spectrum simulation. First,
# create a central transition selective Bloch decay spectrum method.
static_method = BlochDecayCTSpectrum(
channels=["27Al"], spectral_dimensions=[dict(spectral_width=80000)])
# %%
# Create the simulator object and add the spin systems and method.
sim = Simulator()
sim.spin_systems = spin_systems # add the spin systems
sim.methods = [static_method] # add the method
sim.run()
# %%
# The plot of the corresponding spectrum.
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()
# %%
# Spinning sideband simulation at the magic angle
# -----------------------------------------------
# Simulation of the same spin systems at the magic angle and spinning at 25 kHz.
