From 7ba6b82e9a275688988473ab7f51140bf18b90ed Mon Sep 17 00:00:00 2001 From: "Documenter.jl" Date: Wed, 23 Aug 2023 18:07:46 +0000 Subject: [PATCH] build based on 5597145 --- dev/examples/fei2_classical/index.html | 6 +- dev/examples/fei2_tutorial/index.html | 6 +- dev/examples/ising2d/index.html | 64 +++++++++++----------- dev/examples/one_dim_chain/index.html | 16 +++--- dev/examples/out_of_equilibrium/index.html | 2 +- dev/examples/powder_averaging/index.html | 4 +- dev/index.html | 2 +- dev/library/index.html | 46 ++++++++-------- dev/search/index.html | 2 +- dev/structure-factor/index.html | 2 +- dev/versions/index.html | 2 +- dev/writevtk/index.html | 2 +- 12 files changed, 77 insertions(+), 77 deletions(-) diff --git a/dev/examples/fei2_classical/index.html b/dev/examples/fei2_classical/index.html index 31ed49e92..bb4a95551 100644 --- a/dev/examples/fei2_classical/index.html +++ b/dev/examples/fei2_classical/index.html @@ -24,7 +24,7 @@ [-1/4, 1/4, 0] 2.41% [1/4, -1/4, 0] 2.41% [0, 1/4, 0] 1.64% - ... ...

The wide distribution of intensities indicates an imperfect magnetic order. The defects are immediately apparent in the real-space spin configuration.

plot_spins(sys)

In this case, we can find the correct ground state simply by running the Langevin dynamics for longer.

for _ in 1:10_000
+    ...                     ...

The wide distribution of intensities indicates an imperfect magnetic order. The defects are immediately apparent in the real-space spin configuration.

plot_spins(sys)

In this case, we can find the correct ground state simply by running the Langevin dynamics for longer.

for _ in 1:10_000
     step!(sys, langevin)
 end
 minimize_energy!(sys)
@@ -33,7 +33,7 @@
     [-1/4, 1/4, 1/4]       50.00% weight
     [1/4, -1/4, -1/4]      50.00%

This is the perfect single-$𝐐$ ground state. This worked because the temperature kT = 0.2 was carefully selected. It is below the magnetic ordering temperature, but still large enough that the Langevin dynamics could quickly overcome local energy barriers. More complicated magnetic orderings will frequently require more sophisticated sampling schemes. One possibility is simulated annealing, where kT is slowly lowered over the course of the sampling procedure.

Calculating Thermal-Averaged Correlations $\langle S^{\alpha\beta}(𝐪,ω)\rangle$

Now that we have identified an appropriate ground state, we will adjust the temperature so that the system still remains near the ground state, but still has thermal fluctuations.

kT = 3.5 * meV_per_K     # 3.5K ≈ 0.30 meV
 langevin.kT = kT;

Additionally, since these classical simulations are conducted on a finite-sized lattice, obtaining acceptable resolution in momentum space requires the use of a larger system size. We resize the magnetic supercell to a much larger simulation volume, provided as multiples of the original unit cell.

sys_large = resize_supercell(sys, (16,16,4)) # 16x16x4 copies of the original unit cell
-plot_spins(sys_large)

As stressed above, we need to sample multiple spin configurations from the thermal equilibrium distribution. We therefore begin by using Langevin dynamics to bring the system into thermal equilibrium at the new temperature.

# At the new temperature
+plot_spins(sys_large)

As stressed above, we need to sample multiple spin configurations from the thermal equilibrium distribution. We therefore begin by using Langevin dynamics to bring the system into thermal equilibrium at the new temperature.

# At the new temperature
 for _ in 1:10_000
     step!(sys_large, langevin)
 end

Now that we are in a state drawn from thermal equilibrium, we are ready to begin collecting correlation data $S^{\alpha\beta}$.

To collect one sample of spin-spin correlation data, we integrate the Hamiltonian dynamics of SU(N) coherent states. This generates trajectories $S^\alpha(\vec r,t)$. However, note that the spins are only defined at the finitely-many lattice sites, so $\vec r$ is discrete. From the trajectories, Sunny computes fourier-transformed correlations $S^{\alpha\beta}(q,\omega)$, where $q$ is discrete for the same reason.

The correlation data from this sample is now ready to be averaged together with data from other samples to form the thermal average. Samples of correlation data are accumulated and averaged into a SampledCorrelations, which is initialized by calling dynamical_correlations:

sc = dynamical_correlations(sys_large; Δt=2Δt, nω=120, ωmax=7.5)
SampledCorrelations (37.348 MiB)
@@ -191,4 +191,4 @@
     )
 )
 Colorbar(hm.figure[1,2], hm.plot)
-hm

This page was generated using Literate.jl.

+hm

This page was generated using Literate.jl.

diff --git a/dev/examples/fei2_tutorial/index.html b/dev/examples/fei2_tutorial/index.html index 413862d11..0b731ed7a 100644 --- a/dev/examples/fei2_tutorial/index.html +++ b/dev/examples/fei2_tutorial/index.html @@ -100,7 +100,7 @@ 0.0 0.0 J′2azz], Bond(1,1,[1,2,1]))

The function set_onsite_coupling! assigns a single-ion anisotropy operator. It can be constructed, e.g., from the matrices given by spin_operators or stevens_operators. Here we construct an easy-axis anisotropy along the direction $\hat{z}$.

D = 2.165
 S = spin_operators(sys, 1)
 set_onsite_coupling!(sys, -D*S[3]^2, 1)

Any anisotropy operator can be converted to a linear combination of Stevens operators with print_stevens_expansion.

Calculating structure factor intensities

In the remainder of this tutorial, we will examine Sunny's tools for calculating the dynamical structure factor using a multi-boson generalization of linear spin wave theory (LSWT). This theory describes non-interacting quasi-particle excitations that hybridize dipolar and quadrupolar modes.

Finding the ground state

Begin with a random configuration and use minimize_energy! to find a configuration of the SU(3) coherent states (i.e. spin dipoles and quadrupoles) that locally minimizes energy.

randomize_spins!(sys)
-minimize_energy!(sys);

The expected ground state for FeI$_2$ is an antiferrogmanetic striped phase with a period of four spins (two up, two down). Visualizing the result of optimization, however, may indicate the system got stuck in a local minimum with defects.

plot_spins(sys)

A better understanding of the magnetic ordering can often be obtained by moving to Fourier space. The 'instant' structure factor $𝒮(𝐪)$ is an experimental observable. To investigate $𝒮(𝐪)$ as true 3D data, Sunny provides instant_correlations and related functions. Here, however, we will use the lighter weight function print_wrapped_intensities to get a quick understanding of the periodicities present in the spin configuration.

print_wrapped_intensities(sys)
Dominant wavevectors for spin sublattices:
+minimize_energy!(sys);

The expected ground state for FeI$_2$ is an antiferrogmanetic striped phase with a period of four spins (two up, two down). Visualizing the result of optimization, however, may indicate the system got stuck in a local minimum with defects.

plot_spins(sys)

A better understanding of the magnetic ordering can often be obtained by moving to Fourier space. The 'instant' structure factor $𝒮(𝐪)$ is an experimental observable. To investigate $𝒮(𝐪)$ as true 3D data, Sunny provides instant_correlations and related functions. Here, however, we will use the lighter weight function print_wrapped_intensities to get a quick understanding of the periodicities present in the spin configuration.

print_wrapped_intensities(sys)
Dominant wavevectors for spin sublattices:
 
     [-1/4, 1/4, 1/4]       37.33% weight
     [1/4, -1/4, -1/4]      37.33%
@@ -120,7 +120,7 @@
 for wavevectors [[0, -1/4, 1/4]].

The function reshape_supercell allows an arbitrary reshaping of the system's supercell. We select the supercell appropriate to the broken-symmetry ground-state, which makes optimization much easier.

sys_min = reshape_supercell(sys, [1 0 0; 0 1 -2; 0 1 2])
 randomize_spins!(sys_min)
 minimize_energy!(sys_min)
-plot_spins(sys_min; ghost_radius=3)

Linear spin wave theory

Now that we have found the ground state for a magnetic supercell, we can immediately proceed to perform zero-temperature calculations using linear spin wave theory. We begin by instantiating a SpinWaveTheory type using the supercell.

swt = SpinWaveTheory(sys_min)
SpinWaveTheory [Dipole correlations]
+plot_spins(sys_min; ghost_radius=3)

Linear spin wave theory

Now that we have found the ground state for a magnetic supercell, we can immediately proceed to perform zero-temperature calculations using linear spin wave theory. We begin by instantiating a SpinWaveTheory type using the supercell.

swt = SpinWaveTheory(sys_min)
SpinWaveTheory [Dipole correlations]
 Atoms in magnetic supercell: 4

Select a sequence of wavevectors that will define a piecewise linear interpolation in reciprocal lattice units (RLU).

q_points = [[0,0,0], [1,0,0], [0,1,0], [1/2,0,0], [0,1,0], [0,0,0]];

The function reciprocal_space_path will linearly sample a path between the provided $q$-points with a given density. The xticks return value provides labels for use in plotting.

density = 50
 path, xticks = reciprocal_space_path(cryst, q_points, density);

The dispersion function defines the quasiparticle excitation energies $ω_i(𝐪)$ for each point $𝐪$ along the reciprocal space path.

disp = dispersion(swt, path);

In addition to the band energies $ω_i(𝐪)$, Sunny can calculate the inelastic neutron scattering intensity $I_i(𝐪)$ for each band $i$ according to an intensity_formula. We choose to apply a polarization correction $(1 - 𝐪⊗𝐪)$ by setting the mode argument to :perp. Selecting delta_function_kernel specifies that we want the energy and intensity of each band individually.

formula = intensity_formula(swt, :perp; kernel=delta_function_kernel)
Quantum Scattering Intensity Formula
@@ -156,4 +156,4 @@
 fig = Figure()
 ax = Axis(fig[1,1]; xlabel="(H,0,0)", ylabel="Energy (meV)", xticks, xticklabelrotation=π/6)
 heatmap!(ax, 1:size(is_averaged, 1), energies, is_averaged)
-fig

This result can be directly compared to experimental neutron scattering data from Bai et al.

(The publication figure accidentally used a non-standard coordinate system to label the wave vectors.)

To get this agreement, the use of SU(3) coherent states is essential. In other words, we needed a theory of multi-flavored bosons. The lower band has large quadrupolar character, and arises from the strong easy-axis anisotropy of FeI$_2$. By setting mode = :SUN, the calculation captures this coupled dipole-quadrupole dynamics.

An interesting exercise is to repeat the same study, but using mode = :dipole instead of :SUN. That alternative choice would constrain the coherent state dynamics to the space of dipoles only.

The full dynamical spin structure factor (DSSF) can be retrieved as a $3×3$ matrix with the dssf function, for a given path of $𝐪$-vectors.

disp, is = dssf(swt, path);

The first output disp is identical to that obtained from dispersion. The second output is contains a list of $3×3$ matrix of intensities. For example, is[q,n][2,3] yields the $(ŷ,ẑ)$ component of the structure factor intensity for nth mode at the qth wavevector in the path.

What's next?

The multi-boson linear spin wave theory, applied above, can be understood as the quantization of a certain generalization of the Landau-Lifshitz spin dynamics. Rather than dipoles, this dynamics takes places on the space of SU(N) coherent states.

The full SU(N) coherent state dynamics, with appropriate quantum correction factors, can be useful to model finite temperature scattering data. In particular, it captures certain anharmonic effects due to thermal fluctuations. This is the subject of our Structure Factors with Classical Dynamics tutorial.

The classical dynamics is also a good starting point to study non-equilibrium phenomena. Empirical noise and damping terms can be used to model coupling to a thermal bath. This yields a Langevin dynamics of SU(N) coherent states. Our CP$^2$ Skyrmion Quench tutorial shows how this dynamics gives rise to the formation of novel topological defects in a temperature quench.

Relative to LSWT calculations, it can take much more time to estimate $\mathcal{S}(𝐪,ω)$ intensities using classical dynamics simulation. See the SunnyTutorials notebooks for examples of "production-scale" simulations.

This page was generated using Literate.jl.

+fig

This result can be directly compared to experimental neutron scattering data from Bai et al.

(The publication figure accidentally used a non-standard coordinate system to label the wave vectors.)

To get this agreement, the use of SU(3) coherent states is essential. In other words, we needed a theory of multi-flavored bosons. The lower band has large quadrupolar character, and arises from the strong easy-axis anisotropy of FeI$_2$. By setting mode = :SUN, the calculation captures this coupled dipole-quadrupole dynamics.

An interesting exercise is to repeat the same study, but using mode = :dipole instead of :SUN. That alternative choice would constrain the coherent state dynamics to the space of dipoles only.

The full dynamical spin structure factor (DSSF) can be retrieved as a $3×3$ matrix with the dssf function, for a given path of $𝐪$-vectors.

disp, is = dssf(swt, path);

The first output disp is identical to that obtained from dispersion. The second output is contains a list of $3×3$ matrix of intensities. For example, is[q,n][2,3] yields the $(ŷ,ẑ)$ component of the structure factor intensity for nth mode at the qth wavevector in the path.

What's next?

The multi-boson linear spin wave theory, applied above, can be understood as the quantization of a certain generalization of the Landau-Lifshitz spin dynamics. Rather than dipoles, this dynamics takes places on the space of SU(N) coherent states.

The full SU(N) coherent state dynamics, with appropriate quantum correction factors, can be useful to model finite temperature scattering data. In particular, it captures certain anharmonic effects due to thermal fluctuations. This is the subject of our Structure Factors with Classical Dynamics tutorial.

The classical dynamics is also a good starting point to study non-equilibrium phenomena. Empirical noise and damping terms can be used to model coupling to a thermal bath. This yields a Langevin dynamics of SU(N) coherent states. Our CP$^2$ Skyrmion Quench tutorial shows how this dynamics gives rise to the formation of novel topological defects in a temperature quench.

Relative to LSWT calculations, it can take much more time to estimate $\mathcal{S}(𝐪,ω)$ intensities using classical dynamics simulation. See the SunnyTutorials notebooks for examples of "production-scale" simulations.

This page was generated using Literate.jl.

diff --git a/dev/examples/ising2d/index.html b/dev/examples/ising2d/index.html index 1152c6d85..74c70742a 100644 --- a/dev/examples/ising2d/index.html +++ b/dev/examples/ising2d/index.html @@ -17,45 +17,45 @@ end

Plot the Ising spins by extracting the $z$-component of the dipoles

heatmap(reshape([s.z for s in sys.dipoles], (L,L)))
- + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + - + - + - + -

This page was generated using Literate.jl.

+

This page was generated using Literate.jl.

diff --git a/dev/examples/one_dim_chain/index.html b/dev/examples/one_dim_chain/index.html index 0137dc65f..2c41170da 100644 --- a/dev/examples/one_dim_chain/index.html +++ b/dev/examples/one_dim_chain/index.html @@ -28,11 +28,11 @@ Sunny.Plotting.plot_coherents(sys;quantization_axis = [0,0,1],kwargs...) randomize_spins!(spin_one_chain) -viz_chain(spin_one_chain)

In this plot, the z-axis has been used as the quantization axis for each site, with the up/down arrows and circle representing the $\pm \hbar$ and $0\hbar$ spin projections onto the z-axis respectively. The opacity of each object represents the probability (absolute value squared), and the color represents the phase. Since we are using classical dynamics to simulate the data, the phase will be mostly random.

First, we thermalize the chain, and then take several samples in order get reasonably good "experiment" data.

# ... thermalize ...
-viz_chain(spin_one_chain)
# ... some time later ...
-viz_chain(spin_one_chain)
# ... some time later ...
-viz_chain(spin_one_chain)
# ... some time later ...
-viz_chain(spin_one_chain)

Now that we have collected several samples,

sc
SampledCorrelations (401.206 KiB)
+viz_chain(spin_one_chain)

In this plot, the z-axis has been used as the quantization axis for each site, with the up/down arrows and circle representing the $\pm \hbar$ and $0\hbar$ spin projections onto the z-axis respectively. The opacity of each object represents the probability (absolute value squared), and the color represents the phase. Since we are using classical dynamics to simulate the data, the phase will be mostly random.

First, we thermalize the chain, and then take several samples in order get reasonably good "experiment" data.

# ... thermalize ...
+viz_chain(spin_one_chain)
# ... some time later ...
+viz_chain(spin_one_chain)
# ... some time later ...
+viz_chain(spin_one_chain)
# ... some time later ...
+viz_chain(spin_one_chain)

Now that we have collected several samples,

sc
SampledCorrelations (401.206 KiB)
 [S(q,ω) | nω = 80, Δω = 0.2549 | 22 samples]
 Lattice: (16, 1, 1)×1
 6 correlations in SU(3) mode:
@@ -50,7 +50,7 @@
 SIMULATED_EXPERIMENT_DATA = (is ./ counts)[:,1,1,:]
 
 bcs = axes_bincenters(SIMULATED_EXPERIMENT_HISTOGRAM_PARAMS)
-heatmap!(ax,bcs[1],bcs[4],log10.(SIMULATED_EXPERIMENT_DATA))

Fitting to the experiment data

To fit this data, we first model the known aspects of the system in Sunny. The first steps are the same whether we are simulating a known system or modelling an unknown system:

# Same as before
+heatmap!(ax,bcs[1],bcs[4],log10.(SIMULATED_EXPERIMENT_DATA))

Fitting to the experiment data

To fit this data, we first model the known aspects of the system in Sunny. The first steps are the same whether we are simulating a known system or modelling an unknown system:

# Same as before
 chain_spacing = 10. # Angstrom
 latvecs = chain_spacing * I(3)
 one_dimensional_chain = Crystal(latvecs,[[0,0,0]],"P1")
@@ -122,7 +122,7 @@
 opt_result = optimize(get_loss,x0,method=GradientDescent(alphaguess=1e-3),store_trace=true,extended_trace = true,time_limit=10.)
 lines!(ax,Point2f.(Optim.x_trace(opt_result)))
 scatter!(ax,-1,10)
-fig

The fit can be verified by plotting the LSWT band structure over top of the experiment data:

bcs = axes_bincenters(SIMULATED_EXPERIMENT_HISTOGRAM_PARAMS)
+fig

The fit can be verified by plotting the LSWT band structure over top of the experiment data:

bcs = axes_bincenters(SIMULATED_EXPERIMENT_HISTOGRAM_PARAMS)
 heatmap!(ax,bcs[1],bcs[4],log10.(SIMULATED_EXPERIMENT_DATA), colormap = :deepsea)
 
 
@@ -140,4 +140,4 @@
 end
 Colorbar(f[1,2],colormap = :turbo, limits = (0.,1.))
 Colorbar(f[1,3],colormap = :deepsea, limits = (0.,1.))
-f

This page was generated using Literate.jl.

+f

This page was generated using Literate.jl.

diff --git a/dev/examples/out_of_equilibrium/index.html b/dev/examples/out_of_equilibrium/index.html index 96083f1b5..272a8ff0e 100644 --- a/dev/examples/out_of_equilibrium/index.html +++ b/dev/examples/out_of_equilibrium/index.html @@ -52,4 +52,4 @@ plot_triangular_plaquettes(sun_berry_curvature, frames; resolution=(1800,600), offset_spacing=10, texts = ["\tt = "*string(τ) for τ in τs], text_offset = (0.0, 6.0) -)

The times are given in $\hbar/|J_1|$. The white background corresponds to a quantum paramagnetic state, where the local spin exhibits a strong quadrupole moment and little or no dipole moment. Observe that the process has generated a number of well-formed skyrmions of both positive (red) and negative (blue) charge in addition to a number of other metastable spin configurations. A full-sized version of this figure is available in Dahlbom et al..

This page was generated using Literate.jl.

+)

The times are given in $\hbar/|J_1|$. The white background corresponds to a quantum paramagnetic state, where the local spin exhibits a strong quadrupole moment and little or no dipole moment. Observe that the process has generated a number of well-formed skyrmions of both positive (red) and negative (blue) charge in addition to a number of other metastable spin configurations. A full-sized version of this figure is available in Dahlbom et al..

This page was generated using Literate.jl.

diff --git a/dev/examples/powder_averaging/index.html b/dev/examples/powder_averaging/index.html index 43b80f11e..116c35fc3 100644 --- a/dev/examples/powder_averaging/index.html +++ b/dev/examples/powder_averaging/index.html @@ -23,7 +23,7 @@ minimize_energy!(sys) energy_per_site = energy(sys) / length(eachsite(sys)) -@assert energy_per_site ≈ -2J*S^2

Plotting the spins confirms the expected Néel order. Note that the overall, global rotation of dipoles is arbitrary.

plot_spins(sys; ghost_radius=2.0)

We can now estimate $𝒮(𝐪,ω)$ with SpinWaveTheory and intensity_formula. The mode :perp contracts with a dipole factor to return the unpolarized intensity. We will also apply broadening with the lorentzian kernel, and will dampen intensities using the FormFactor for Cobalt(2+).

swt = SpinWaveTheory(sys)
+@assert energy_per_site ≈ -2J*S^2

Plotting the spins confirms the expected Néel order. Note that the overall, global rotation of dipoles is arbitrary.

plot_spins(sys; ghost_radius=2.0)

We can now estimate $𝒮(𝐪,ω)$ with SpinWaveTheory and intensity_formula. The mode :perp contracts with a dipole factor to return the unpolarized intensity. We will also apply broadening with the lorentzian kernel, and will dampen intensities using the FormFactor for Cobalt(2+).

swt = SpinWaveTheory(sys)
 η = 0.4 # (meV)
 kernel = lorentzian(η)
 formfactors = [FormFactor("Co2")]
@@ -56,4 +56,4 @@
 empty!(fig)
 ax = Axis(fig[1,1]; xlabel="|Q| (Å⁻¹)", ylabel="ω (meV)")
 heatmap!(ax, radii, energies, output, colormap=:gnuplot2)
-fig

This result can be compared to experimental neutron scattering data from Fig. 5 of Ge et al.

This page was generated using Literate.jl.

+fig

This result can be compared to experimental neutron scattering data from Fig. 5 of Ge et al.

This page was generated using Literate.jl.

diff --git a/dev/index.html b/dev/index.html index 0e6378e56..18ed2391b 100644 --- a/dev/index.html +++ b/dev/index.html @@ -1,2 +1,2 @@ -Overview · Sunny documentation
Edit on GitHub

Sunny Overview

Sunny is a Julia package for modeling atomic-scale magnetism. It provides powerful tools to study equilibrium and non-equilibrium magnetic phenomena. In particular, it allows estimation of dynamical structure factor intensities, $\mathcal{S}(𝐪,ω)$, to support quantitative modeling of experimental scattering data.

Features include:

  • Generalized spin dynamics using SU(N) coherent states.
  • Ability specify a crystal by a .cif file, or using its spacegroup symmetry.
  • Interactive visualizations of the 3D crystals and magnetic ordering.
  • Symmetry analysis to classify allowed interaction terms, and to propagate them by symmetry.
  • Single-ion anisotropy at arbitrary order, which can be specified using Stevens operators or as a polynomial of spin operators.
  • Monte Carlo sampling of spin configurations in thermal equilibrium, and optimization tools.
  • Measurements of dynamical correlation functions. For small supercells at low temperature, one can use linear spin wave theory and its multi-boson generalization. Alternatively, one can use the full classical dynamics to study systems with large supercells (e.g., disordered systems), or anharmonic effects with thermal fluctuations.
  • Long-range dipole-dipole interactions accelerated with the fast Fourier transform (FFT).
  • Various correction factors to facilitate comparison with experimental data (form factor, dipole factor, temperature-dependent classical-to-quantum factors, intensity binning, etc.).
+Overview · Sunny documentation
Edit on GitHub

Sunny Overview

Sunny is a Julia package for modeling atomic-scale magnetism. It provides powerful tools to study equilibrium and non-equilibrium magnetic phenomena. In particular, it allows estimation of dynamical structure factor intensities, $\mathcal{S}(𝐪,ω)$, to support quantitative modeling of experimental scattering data.

Features include:

  • Generalized spin dynamics using SU(N) coherent states.
  • Ability specify a crystal by a .cif file, or using its spacegroup symmetry.
  • Interactive visualizations of the 3D crystals and magnetic ordering.
  • Symmetry analysis to classify allowed interaction terms, and to propagate them by symmetry.
  • Single-ion anisotropy at arbitrary order, which can be specified using Stevens operators or as a polynomial of spin operators.
  • Monte Carlo sampling of spin configurations in thermal equilibrium, and optimization tools.
  • Measurements of dynamical correlation functions. For small supercells at low temperature, one can use linear spin wave theory and its multi-boson generalization. Alternatively, one can use the full classical dynamics to study systems with large supercells (e.g., disordered systems), or anharmonic effects with thermal fluctuations.
  • Long-range dipole-dipole interactions accelerated with the fast Fourier transform (FFT).
  • Various correction factors to facilitate comparison with experimental data (form factor, dipole factor, temperature-dependent classical-to-quantum factors, intensity binning, etc.).
diff --git a/dev/library/index.html b/dev/library/index.html index 54a681826..f355bacc4 100644 --- a/dev/library/index.html +++ b/dev/library/index.html @@ -1,8 +1,8 @@ -Library API · Sunny documentation
Edit on GitHub

Library API

This page describes the public types and functions exported by Sunny. This documentation can be also be accessed using the Julia help system (enter ? at the Julia command prompt).

Sunny.Site — Type
(cell1, cell2, cell3, i) :: Site

Four indices identifying a single site in a System. The first three indices select the lattice cell and the last selects the sublattice (i.e., the atom within the unit cell).

This object can be used to index dipoles and coherents fields of a System. A Site is also required to specify inhomogeneous interactions via functions such as set_external_field_at! or set_exchange_at!.

Note that the definition of a cell may change when a system is reshaped. In this case, it is convenient to construct the Site using position_to_site, which always takes a position in fractional coordinates of the original lattice vectors.

source
Sunny.Units — Constant
Units.meV
-Units.theory

The unit system is implicitly determined by the definition of two physical constants: the vacuum permeability $μ₀$ and the Bohr magneton $μ_B$. Temperatures are effectively measured in units of energy ($k_B = 1$) and time is effectively measured in units of inverse energy ($ħ = 1$). The default unit system, Units.meV, employs (meV, Å, tesla). Select alternatively Units.theory for a units system defined so that $μ₀ = μ_B = 1$.

See also meV_per_K

source
Sunny.meV_per_K — Constant
meV_per_K = 0.086173332621451774

A physical constant. Useful for converting kelvin into the default energy units, meV.

source
Sunny.BinningParameters — Type
BinningParameters(binstart,binend,binwidth;covectors = I(4))
+Library API · Sunny documentation
Edit on GitHub
Library API
This page describes the public types and functions exported by Sunny. This documentation can be also be accessed using the Julia help system (enter ? at the Julia command prompt).
Sunny.Site — Type
(cell1, cell2, cell3, i) :: Site
Four indices identifying a single site in a System. The first three indices select the lattice cell and the last selects the sublattice (i.e., the atom within the unit cell).
This object can be used to index dipoles and coherents fields of a System. A Site is also required to specify inhomogeneous interactions via functions such as set_external_field_at! or set_exchange_at!.
Note that the definition of a cell may change when a system is reshaped. In this case, it is convenient to construct the Site using position_to_site, which always takes a position in fractional coordinates of the original lattice vectors.
source
Sunny.Units — Constant
Units.meV
+Units.theory
The unit system is implicitly determined by the definition of two physical constants: the vacuum permeability $μ₀$ and the Bohr magneton $μ_B$. Temperatures are effectively measured in units of energy ($k_B = 1$) and time is effectively measured in units of inverse energy ($ħ = 1$). The default unit system, Units.meV, employs (meV, Å, tesla). Select alternatively Units.theory for a units system defined so that $μ₀ = μ_B = 1$.
See also meV_per_K
source
Sunny.meV_per_K — Constant
meV_per_K = 0.086173332621451774
A physical constant. Useful for converting kelvin into the default energy units, meV.
source
Sunny.BinningParameters — Type
BinningParameters(binstart,binend,binwidth;covectors = I(4))
 BinningParameters(binstart,binend;numbins,covectors = I(4))
Describes a 4D parallelepided histogram in a format compatible with experimental Inelasitic Neutron Scattering data. See generate_mantid_script_from_binning_parameters to convert BinningParameters to a format understandable by the Mantid software, or load_nxs to load BinningParameters from a Mantid .nxs file.
The coordinates of the histogram axes are specified by multiplication  of (q,ω) with each row of the covectors matrix, with q given in [R.L.U.]. Since the default covectors matrix is the identity matrix, the default axes are (qx,qy,qz,ω) in absolute units.
The convention for the binning scheme is that:
  • The left edge of the first bin starts at binstart
  • The bin width is binwidth
  • The last bin contains binend
  • There are no "partial bins;" the last bin may contain values greater than binend. C.f. count_bins.
A value can be binned by computing its bin index:
coords = covectors * value
-bin_ix = 1 .+ floor.(Int64,(coords .- binstart) ./ binwidth)
source
Sunny.Bond — Type
Bond(i, j, n)
Represents a bond between atom indices i and j. n is a vector of three integers specifying unit cell displacement in terms of lattice vectors.
source
Sunny.Crystal — Type
An object describing a crystallographic unit cell and its space group symmetry. Constructors are as follows:
Crystal(filename; symprec=1e-5)
Reads the crystal from a .cif file located at the path filename.  The optional parameter symprec controls the precision tolerance for spacegroup symmetries.
Crystal(latvecs, positions; types=nothing, symprec=1e-5)
Constructs a crystal from the complete list of atom positions positions, with coordinates (between 0 and 1) in units of lattice vectors latvecs. Spacegroup symmetry information is automatically inferred. The optional parameter types is a list of strings, one for each atom, and can be used to break symmetry-equivalence between atoms.
Crystal(latvecs, positions, spacegroup_number; types=nothing, setting=nothing, symprec=1e-5)
Builds a crystal by applying symmetry operators for a given international spacegroup number. For certain spacegroups, there are multiple possible unit cell settings; in this case, a warning message will be printed, and a list of crystals will be returned, one for every possible setting. Alternatively, the optional setting string will disambiguate between unit cell conventions.
Currently, crystals built using only the spacegroup number will be missing some symmetry information. It is generally preferred to build a crystal from a .cif file or from the full specification of the unit cell.
Examples
# Read a Crystal from a .cif file
+bin_ix = 1 .+ floor.(Int64,(coords .- binstart) ./ binwidth)
source
Sunny.Bond — Type
Bond(i, j, n)
Represents a bond between atom indices i and j. n is a vector of three integers specifying unit cell displacement in terms of lattice vectors.
source
Sunny.Crystal — Type
An object describing a crystallographic unit cell and its space group symmetry. Constructors are as follows:
Crystal(filename; symprec=1e-5)
Reads the crystal from a .cif file located at the path filename.  The optional parameter symprec controls the precision tolerance for spacegroup symmetries.
Crystal(latvecs, positions; types=nothing, symprec=1e-5)
Constructs a crystal from the complete list of atom positions positions, with coordinates (between 0 and 1) in units of lattice vectors latvecs. Spacegroup symmetry information is automatically inferred. The optional parameter types is a list of strings, one for each atom, and can be used to break symmetry-equivalence between atoms.
Crystal(latvecs, positions, spacegroup_number; types=nothing, setting=nothing, symprec=1e-5)
Builds a crystal by applying symmetry operators for a given international spacegroup number. For certain spacegroups, there are multiple possible unit cell settings; in this case, a warning message will be printed, and a list of crystals will be returned, one for every possible setting. Alternatively, the optional setting string will disambiguate between unit cell conventions.
Currently, crystals built using only the spacegroup number will be missing some symmetry information. It is generally preferred to build a crystal from a .cif file or from the full specification of the unit cell.
Examples
# Read a Crystal from a .cif file
 Crystal("filename.cif")
 
 # Build an FCC crystal using the primitive unit cell. The spacegroup number
@@ -25,29 +25,29 @@
 # overall unit cell translation.
 latvecs = lattice_vectors(1, 1, 1, 90, 90, 90)
 positions = [[1, 1, 1] / 4]
-cryst = Crystal(latvecs, positions, 227; setting="1")
See also lattice_vectors.
source
Sunny.FormFactor — Method
FormFactor(ion::String; g_lande=2)
The magnetic form factor for a given magnetic ion and charge state. These can optionally be provided to intensity_formula, and will be used to scale the structure factor intensities as a function of wavevector magnitude.
The parameter ion must be one of the following allowed strings:
Sc0,Sc1,Sc2,Ti0,Ti1,Ti2,Ti3,V0,V1,V2,V3,V4,Cr0,Cr1,Cr2,Cr3,Cr4,Mn0,Mn1,Mn2,Mn3,
+cryst = Crystal(latvecs, positions, 227; setting="1")
See also lattice_vectors.
source
Sunny.FormFactor — Method
FormFactor(ion::String; g_lande=2)
The magnetic form factor for a given magnetic ion and charge state. These can optionally be provided to intensity_formula, and will be used to scale the structure factor intensities as a function of wavevector magnitude.
The parameter ion must be one of the following allowed strings:
Sc0,Sc1,Sc2,Ti0,Ti1,Ti2,Ti3,V0,V1,V2,V3,V4,Cr0,Cr1,Cr2,Cr3,Cr4,Mn0,Mn1,Mn2,Mn3,
 Mn4,Fe0,Fe1,Fe2,Fe3,Fe4,Co0,Co1,Co2,Co3,Co4,Ni0,Ni1,Ni2,Ni3,Ni4,Cu0,Cu1,Cu2,Cu3,
 Cu4,Y0,Zr0,Zr1,Nb0,Nb1,Mo0,Mo1,Tc0,Tc1,Ru0,Ru1,Rh0,Rh1,Pd0,Pd1,Ce2,Nd2,Nd3,Sm2,
 Sm3,Eu2,Eu3,Gd2,Gd3,Tb2,Tb3,Dy2,Dy3,Ho2,Ho3,Er2,Er3,Tm2,Tm3,Yb2,Yb3,Pr3,U3,U4,
-U5,Np3,Np4,Np5,Np6,Pu3,Pu4,Pu5,Pu6,Am2,Am3,Am4,Am5,Am6,Am7
A first approximation to the magnetic form factor is
$f(s) = \langle j_0(s) \rangle$,
where $\langle j_l(s) \rangle$ is a Bessel function integral of the magnetic dipole.
If Landé $g$-factor is distinct from 2, then a correction will be applied,
$F(s) = \frac{2-g}{g} \langle j_2(s) \rangle s^2 + f(s)$.
Sunny uses the semi-empirical fits for $j_0$ and $j_2$ listed from Refs. [1] and [2]. These functions are approximated as a sum of Gaussians in the scalar variable $s = |k|/4π$, where $|k|$ can be interpreted as the magnitude of momentum transfer:
$\langle j_l(s) \rangle = A e^{-as^2} + B e^{-bs^2} + Ce^{-cs^2} + D,$
where $A, B, C, D, a, b, c$ are $l$-dependent fitting parameters. For transition metals, the parameters are estimated using the Hartree-Fock method. For rare-earth metals and ions, the Dirac-Fock form is used.
References:
  1. https://www.ill.eu/sites/ccsl/ffacts/ffachtml.html
  2. J. Brown, The Neutron Data Booklet, 2nd ed., Sec. 2.5 Magnetic Form Factors (2003).
  3. Marshall W and Lovesey S W, Theory of thermal neutron scattering Chapter 6 Oxford University Press (1971)
  4. Clementi E and Roetti C,  Atomic Data and Nuclear Data Tables, 14 pp 177-478 (1974)
  5. Freeman A J and Descleaux J P, J. Magn. Mag. Mater., 12 pp 11-21 (1979) Descleaux J P and Freeman A J, J. Magn. Mag. Mater., 8 pp 119-129 (1978) 
source
Sunny.ImplicitMidpoint — Type
ImplicitMidpoint(Δt::Float64; atol=1e-12) where N
Energy-conserving spin dynamics. One call to the step! function will advance a System by Δt units of time.
Uses the spherical midpoint integration scheme for dipole systems and the Schrödinger midpoint integration scheme for SU(N) spin systems. Both integration schemes are symplectic, and therefore avoid energy drift over long periods of simulation time.
source
Sunny.Langevin — Type
Langevin(Δt::Float64; λ::Float64, kT::Float64)
Spin dynamics with coupling to a Langevin thermostat, which includes damping and noise terms. One call to the step! function will advance a System by Δt units of time.
Assuming ergodicity, the Langevin dynamics will sample from thermal equilibrium for the target temperature kT. The empirical parameter λ determines the strength of the coupling to the thermal bath. In other words, 1/λ is the decorrelation time-scale. If $λ = 0$, then the spin dynamics coincides with ImplicitMidpoint.
An alternative approach to sampling is LocalSampler, which may be preferred when the allowed spin values become effective discrete (e.g. Ising spins).
source
Sunny.LocalSampler — Type
LocalSampler(; kT, nsweeps=1.0, propose=propose_uniform)
Monte Carlo simulation involving Metropolis updates to individual spins. One call to the step! function will perform nsweeps of MCMC sampling for a provided System. The default value of 1.0 means that step! performs, on average, one trial update per spin.
Assuming ergodicity, the LocalSampler will sample from thermal equilibrium for the target temperature kT. 
The trial spin updates are sampled using the propose function. Built-in options include propose_uniform, propose_flip, and propose_delta. Multiple proposals can be mixed with the macro @mix_proposals.
The returned object stores fields ΔE and Δs, which represent the cumulative change to the net energy and dipole, respectively.
An alternative approach to sampling is Langevin, which may be preferred for simulating continuous spins, especially in the presence of long-range dipole-dipole interactions (cf. enable_dipole_dipole!).
source
Sunny.SpinInfo — Type
SpinInfo(atom::Int; S, g=2)
Characterizes the spin at a given atom index within the crystal unit cell. S is an integer multiple of 1/2 and gives the spin angular momentum in units of ħ. g is the g-factor or tensor, such that an angular momentum dipole $s$ produces a magnetic moment $g s$ in units of the Bohr magneton.
source
Sunny.SpinWaveTheory — Type
SpinWaveTheory(sys, energy_ϵ::Float64=1e-8, energy_tol=1e-6)
Constructs an object to perform linear spin wave theory. Use it with dispersion and dssf functions.
The optional parameter energy_ϵ adds a small positive shift to the diagonal of the dynamical matrix $D$ to avoid numerical issues with zero-energy quasi-particle modes. The optional parameter energy_tol relaxes the check on the imaginary part of the eigenvalues.
source
Sunny.System — Method
System(crystal::Crystal, latsize, infos, mode; units=Units.meV, seed::Int)
Construct a System of spins for a given Crystal symmetry. The latsize parameter determines the number of unit cells in each lattice vector direction. The infos parameter is a list of SpinInfo objects, which determine the magnitude $S$ and $g$-tensor of each spin.
The three possible options for mode are :SUN, :dipole, and :large_S. The most variationally accurate choice is :SUN, in which each spin-$S$ degree of freedom is described as an SU(N) coherent state, where $N = 2S + 1$. Note that an SU(N) coherent state fully describes any local spin state; this description includes expected dipole components $⟨Ŝᵅ⟩$, quadrupole components $⟨ŜᵅŜᵝ+ŜᵝŜᵅ⟩$, etc.
The mode :dipole projects the SU(N) dynamics onto the space of pure dipoles. In practice this means that Sunny will simulate Landau-Lifshitz dynamics, but all single-ion anisotropy and biquadratic exchange interactions will be automatically renormalized for maximum accuracy.
To disable such renormalization, e.g. to reproduce results using the historical large-$S$ classical limit, use the experimental mode :large_S. Modes :SUN or :dipole are strongly preferred for the development of new models.
The default units system of (meV, Å, tesla) can be overridden by with the units parameter; see Units. 
An optional seed may be provided to achieve reproducible random number generation.
All spins are initially polarized in the $z$-direction.
source
Sunny.add_sample! — Method
add_sample!(sc::SampledCorrelations, sys::System)
add_trajectory uses the spin configuration contained in the System to generate a correlation data and accumulate it into sc. For static structure factors, this involves analyzing the spin-spin correlations of the spin configuration provided. For a dynamic structure factor, a trajectory is calculated using the given spin configuration as an initial condition. The spin-spin correlations are then calculating in time and accumulated into sc. 
This function will change the state of sys when calculating dynamical structure factor data. To preserve the initial state of sys, it must be saved separately prior to calling add_sample!. Alternatively, the initial spin configuration may be copied into a new System and this new System can be passed to add_sample!.
source
Sunny.available_energies — Method
available_energies(sc::SampledCorrelations; negative_energies=false)
Return the ω values for the energy index of a SampledCorrelations. By default, only returns values for non-negative energies, which corresponds to the default output of intensities. Set negative_energies to true to retrieve all ω values.
source
Sunny.available_wave_vectors — Method
available_wave_vectors(sc::SampledCorrelations; bzsize=(1,1,1))
Returns all wave vectors for which sc contains exact values. bsize specifies the number of Brillouin zones to be included.
source
Sunny.axes_bincenters — Method
axes_bincenters(params::BinningParameters)
Returns tick marks which label the bins of the histogram described by BinningParameters by their bin centers.
The following alternative syntax can be used to compute bin centers for a single axis:
axes_bincenters(binstart,binend,binwidth)
source
Sunny.broaden_energy — Method
broaden_energy(sc::SampledCorrelations, vals, kernel::Function; negative_energies=false)
Performs a real-space convolution along the energy axis of an array of intensities. Assumes the format of the intensities array corresponds to what would be returned by intensities_interpolated. kernel must be a function that takes two numbers: kernel(ω, ω₀), where ω is a frequency, and ω₀ is the center frequency of the kernel. Sunny provides lorentzian for the most common use case:
newvals = broaden_energy(sc, vals, (ω, ω₀) -> lorentzian(ω-ω₀, 0.2))
source
Sunny.browser — Method
browser(html_str; dir)
Launch a system browser to display the provided HTML string or SunnyViewer. If a directory dir is provided, an HTML file will be written at that location.
source
Sunny.count_bins — Method
count_bins(binstart,binend,binwidth)
Returns the number of bins in the binning scheme implied by binstart, binend, and binwidth. To count the bins in a BinningParameters, use params.numbins.
This function defines how partial bins are handled, so it should be used preferentially over computing the number of bins manually.
source
Sunny.dispersion — Method
dispersion(swt::SpinWaveTheory, qs)
Computes the spin excitation energy dispersion relations given a SpinWaveTheory and an array of wave vectors qs. Each element $q$ of qs must be a 3-vector in units of reciprocal lattice units. I.e., $qᵢ$ is given in $2π/|aᵢ|$ with $|aᵢ|$ the lattice constant of the original chemical lattice.
The first indices of the returned array correspond to those of qs. A final index, corresponding to mode, is added to these. Each entry of the array is an energy.
source
Sunny.dmvec — Method
dmvec(D)
Antisymmetric matrix representation of the Dzyaloshinskii-Moriya pseudo-vector,
  [  0    D[3] -D[2]
+U5,Np3,Np4,Np5,Np6,Pu3,Pu4,Pu5,Pu6,Am2,Am3,Am4,Am5,Am6,Am7
A first approximation to the magnetic form factor is
$f(s) = \langle j_0(s) \rangle$,
where $\langle j_l(s) \rangle$ is a Bessel function integral of the magnetic dipole.
If Landé $g$-factor is distinct from 2, then a correction will be applied,
$F(s) = \frac{2-g}{g} \langle j_2(s) \rangle s^2 + f(s)$.
Sunny uses the semi-empirical fits for $j_0$ and $j_2$ listed from Refs. [1] and [2]. These functions are approximated as a sum of Gaussians in the scalar variable $s = |k|/4π$, where $|k|$ can be interpreted as the magnitude of momentum transfer:
$\langle j_l(s) \rangle = A e^{-as^2} + B e^{-bs^2} + Ce^{-cs^2} + D,$
where $A, B, C, D, a, b, c$ are $l$-dependent fitting parameters. For transition metals, the parameters are estimated using the Hartree-Fock method. For rare-earth metals and ions, the Dirac-Fock form is used.
References:
  1. https://www.ill.eu/sites/ccsl/ffacts/ffachtml.html
  2. J. Brown, The Neutron Data Booklet, 2nd ed., Sec. 2.5 Magnetic Form Factors (2003).
  3. Marshall W and Lovesey S W, Theory of thermal neutron scattering Chapter 6 Oxford University Press (1971)
  4. Clementi E and Roetti C,  Atomic Data and Nuclear Data Tables, 14 pp 177-478 (1974)
  5. Freeman A J and Descleaux J P, J. Magn. Mag. Mater., 12 pp 11-21 (1979) Descleaux J P and Freeman A J, J. Magn. Mag. Mater., 8 pp 119-129 (1978) 
source
Sunny.ImplicitMidpoint — Type
ImplicitMidpoint(Δt::Float64; atol=1e-12) where N
Energy-conserving spin dynamics. One call to the step! function will advance a System by Δt units of time.
Uses the spherical midpoint integration scheme for dipole systems and the Schrödinger midpoint integration scheme for SU(N) spin systems. Both integration schemes are symplectic, and therefore avoid energy drift over long periods of simulation time.
source
Sunny.Langevin — Type
Langevin(Δt::Float64; λ::Float64, kT::Float64)
Spin dynamics with coupling to a Langevin thermostat, which includes damping and noise terms. One call to the step! function will advance a System by Δt units of time.
Assuming ergodicity, the Langevin dynamics will sample from thermal equilibrium for the target temperature kT. The empirical parameter λ determines the strength of the coupling to the thermal bath. In other words, 1/λ is the decorrelation time-scale. If $λ = 0$, then the spin dynamics coincides with ImplicitMidpoint.
An alternative approach to sampling is LocalSampler, which may be preferred when the allowed spin values become effective discrete (e.g. Ising spins).
source
Sunny.LocalSampler — Type
LocalSampler(; kT, nsweeps=1.0, propose=propose_uniform)
Monte Carlo simulation involving Metropolis updates to individual spins. One call to the step! function will perform nsweeps of MCMC sampling for a provided System. The default value of 1.0 means that step! performs, on average, one trial update per spin.
Assuming ergodicity, the LocalSampler will sample from thermal equilibrium for the target temperature kT. 
The trial spin updates are sampled using the propose function. Built-in options include propose_uniform, propose_flip, and propose_delta. Multiple proposals can be mixed with the macro @mix_proposals.
The returned object stores fields ΔE and Δs, which represent the cumulative change to the net energy and dipole, respectively.
An alternative approach to sampling is Langevin, which may be preferred for simulating continuous spins, especially in the presence of long-range dipole-dipole interactions (cf. enable_dipole_dipole!).
source
Sunny.SpinInfo — Type
SpinInfo(atom::Int; S, g=2)
Characterizes the spin at a given atom index within the crystal unit cell. S is an integer multiple of 1/2 and gives the spin angular momentum in units of ħ. g is the g-factor or tensor, such that an angular momentum dipole $s$ produces a magnetic moment $g s$ in units of the Bohr magneton.
source
Sunny.SpinWaveTheory — Type
SpinWaveTheory(sys, energy_ϵ::Float64=1e-8, energy_tol=1e-6)
Constructs an object to perform linear spin wave theory. Use it with dispersion and dssf functions.
The optional parameter energy_ϵ adds a small positive shift to the diagonal of the dynamical matrix $D$ to avoid numerical issues with zero-energy quasi-particle modes. The optional parameter energy_tol relaxes the check on the imaginary part of the eigenvalues.
source
Sunny.System — Method
System(crystal::Crystal, latsize, infos, mode; units=Units.meV, seed::Int)
Construct a System of spins for a given Crystal symmetry. The latsize parameter determines the number of unit cells in each lattice vector direction. The infos parameter is a list of SpinInfo objects, which determine the magnitude $S$ and $g$-tensor of each spin.
The three possible options for mode are :SUN, :dipole, and :large_S. The most variationally accurate choice is :SUN, in which each spin-$S$ degree of freedom is described as an SU(N) coherent state, where $N = 2S + 1$. Note that an SU(N) coherent state fully describes any local spin state; this description includes expected dipole components $⟨Ŝᵅ⟩$, quadrupole components $⟨ŜᵅŜᵝ+ŜᵝŜᵅ⟩$, etc.
The mode :dipole projects the SU(N) dynamics onto the space of pure dipoles. In practice this means that Sunny will simulate Landau-Lifshitz dynamics, but all single-ion anisotropy and biquadratic exchange interactions will be automatically renormalized for maximum accuracy.
To disable such renormalization, e.g. to reproduce results using the historical large-$S$ classical limit, use the experimental mode :large_S. Modes :SUN or :dipole are strongly preferred for the development of new models.
The default units system of (meV, Å, tesla) can be overridden by with the units parameter; see Units. 
An optional seed may be provided to achieve reproducible random number generation.
All spins are initially polarized in the $z$-direction.
source
Sunny.add_sample! — Method
add_sample!(sc::SampledCorrelations, sys::System)
add_trajectory uses the spin configuration contained in the System to generate a correlation data and accumulate it into sc. For static structure factors, this involves analyzing the spin-spin correlations of the spin configuration provided. For a dynamic structure factor, a trajectory is calculated using the given spin configuration as an initial condition. The spin-spin correlations are then calculating in time and accumulated into sc. 
This function will change the state of sys when calculating dynamical structure factor data. To preserve the initial state of sys, it must be saved separately prior to calling add_sample!. Alternatively, the initial spin configuration may be copied into a new System and this new System can be passed to add_sample!.
source
Sunny.available_energies — Method
available_energies(sc::SampledCorrelations; negative_energies=false)
Return the ω values for the energy index of a SampledCorrelations. By default, only returns values for non-negative energies, which corresponds to the default output of intensities. Set negative_energies to true to retrieve all ω values.
source
Sunny.available_wave_vectors — Method
available_wave_vectors(sc::SampledCorrelations; bzsize=(1,1,1))
Returns all wave vectors for which sc contains exact values. bsize specifies the number of Brillouin zones to be included.
source
Sunny.axes_bincenters — Method
axes_bincenters(params::BinningParameters)
Returns tick marks which label the bins of the histogram described by BinningParameters by their bin centers.
The following alternative syntax can be used to compute bin centers for a single axis:
axes_bincenters(binstart,binend,binwidth)
source
Sunny.broaden_energy — Method
broaden_energy(sc::SampledCorrelations, vals, kernel::Function; negative_energies=false)
Performs a real-space convolution along the energy axis of an array of intensities. Assumes the format of the intensities array corresponds to what would be returned by intensities_interpolated. kernel must be a function that takes two numbers: kernel(ω, ω₀), where ω is a frequency, and ω₀ is the center frequency of the kernel. Sunny provides lorentzian for the most common use case:
newvals = broaden_energy(sc, vals, (ω, ω₀) -> lorentzian(ω-ω₀, 0.2))
source
Sunny.browser — Method
browser(html_str; dir)
Launch a system browser to display the provided HTML string or SunnyViewer. If a directory dir is provided, an HTML file will be written at that location.
source
Sunny.count_bins — Method
count_bins(binstart,binend,binwidth)
Returns the number of bins in the binning scheme implied by binstart, binend, and binwidth. To count the bins in a BinningParameters, use params.numbins.
This function defines how partial bins are handled, so it should be used preferentially over computing the number of bins manually.
source
Sunny.dispersion — Method
dispersion(swt::SpinWaveTheory, qs)
Computes the spin excitation energy dispersion relations given a SpinWaveTheory and an array of wave vectors qs. Each element $q$ of qs must be a 3-vector in units of reciprocal lattice units. I.e., $qᵢ$ is given in $2π/|aᵢ|$ with $|aᵢ|$ the lattice constant of the original chemical lattice.
The first indices of the returned array correspond to those of qs. A final index, corresponding to mode, is added to these. Each entry of the array is an energy.
source
Sunny.dmvec — Method
dmvec(D)
Antisymmetric matrix representation of the Dzyaloshinskii-Moriya pseudo-vector,
  [  0    D[3] -D[2]
    -D[3]   0    D[1]
-    D[2] -D[1]   0  ]
Useful in the context of set_exchange!.
source
Sunny.dssf — Method
dssf(swt::SpinWaveTheory, qs)
Given a SpinWaveTheory object, computes the dynamical spin structure factor,
\[    𝒮^{αβ}(𝐤, ω) = 1/(2πN)∫dt ∑_𝐫 \exp[i(ωt - 𝐤⋅𝐫)] ⟨S^α(𝐫, t)S^β(0, 0)⟩,\]
using the result from linear spin-wave theory,
\[    𝒮^{αβ}(𝐤, ω) = ∑_n |A_n^{αβ}(𝐤)|^2 δ[ω-ω_n(𝐤)].\]
qs is an array of wave vectors of arbitrary dimension. Each element $q$ of qs must be a 3-vector in reciprocal lattice units (RLU), i.e., in the basis of reciprocal lattice vectors.
The first indices of the returned array correspond to those of qs. A final index, corresponding to mode, is added to these. Each entry of this array is a tensor (3×3 matrix) corresponding to the indices $α$ and $β$.
source
Sunny.dynamical_correlations — Method
dynamical_correlations(sys::System; Δt, nω, ωmax, 
-    process_trajectory=:none, observables=nothing, correlations=nothing)
Creates a SampledCorrelations for calculating and storing $𝒮(𝐪,ω)$ data. This information will be obtained by running dynamical spin simulations on equilibrium snapshots and measuring pair-correlations. The $𝒮(𝐪,ω)$ data can be retrieved by calling intensities_interpolated. Alternatively, instant_intensities_interpolated will integrate out $ω$ to obtain $𝒮(𝐪)$, optionally applying classical-to-quantum correction factors.
The SampleCorrelations that is returned will contain no correlation data. Samples are generated and accumulated by calling add_sample!(sc, sys) where sc is a SampleCorrelations and sys is an appropriately equilibrated System. Note that the sys should be thermalized before each call of add_sample! such that the spin configuration in the system represents a new (fully decorrelated) sample.
Three keywords are required to specify the dynamics used for the trajectory calculation.
  • Δt: The time step used for calculating the trajectory from which dynamic   spin-spin correlations are calculated. The trajectories are calculated with   an ImplicitMidpoint integrator.
  • ωmax: The maximum energy, $ω$, that will be resolved.
  • nω: The number of energy bins to calculated between 0 and ωmax.
Additional keyword options are the following:
  • process_trajectory: Specifies a function that will be applied to the sample   trajectory before correlation analysis. Current options are :none and   :symmetrize. The latter will symmetrize the trajectory in time, which can   be useful for removing Fourier artifacts that arise when calculating the   correlations.
  • observables: Allows the user to specify custom observables. The   observables must be given as a list of complex N×N matrices or   LinearMaps. It's recommended to name each observable, for example:   observables = [:A => a_observable_matrix, :B => b_map, ...]. By default,   Sunny uses the 3 components of the dipole, :Sx, :Sy and :Sz.
  • correlations: Specify which correlation functions are calculated, i.e. which   matrix elements $αβ$ of $𝒮^{αβ}(q,ω)$ are calculated and stored.   Specified with a vector of tuples. By default Sunny records all auto- and   cross-correlations generated by all observables. To retain only the xx and   xy correlations, one would set correlations=[(:Sx,:Sx), (:Sx,:Sy)] or   correlations=[(1,1),(1,2)].
source
Sunny.enable_dipole_dipole! — Method
enable_dipole_dipole!(sys::System)
Enables long-range dipole-dipole interactions,
\[    -(μ_0/4π) ∑_{⟨ij⟩}  (3 (𝐌_j⋅𝐫̂_{ij})(𝐌_i⋅𝐫̂_{ij}) - 𝐌_i⋅𝐌_j) / |𝐫_{ij}|^3\]
where the sum is over all pairs of spins (singly counted), including periodic images, regularized using the Ewald summation convention. The magnetic moments are $𝐌_i = μ_B g 𝐒_i$ where $g$ is the g-factor or g-tensor, and $𝐒_i$ is the spin angular momentum dipole in units of ħ. The Bohr magneton $μ_B$ and vacuum permeability $μ_0$ are physical constants, with numerical values determined by the unit system.
source
Sunny.generate_mantid_script_from_binning_parameters — Method
generate_mantid_script_from_binning_parameters(params::BinningParameters)
Generate a Mantid script which bins data according to the  given BinningParameters.
Units
Take care to ensure the units are correct (R.L.U. or absolute). You may want to call Sunny.bin_rlu_as_absolute_units! or Sunny.bin_absolute_units_as_rlu! first.
source
Sunny.global_position — Method
global_position(sys::System, site::Site)
Position of a Site in global coordinates.
To precompute a full list of positions, one can use eachsite as below:
pos = [global_position(sys, site) for site in eachsite(sys)]
source
Sunny.instant_correlations — Method
instant_correlations(sys::System; process_trajectory=:none, observables=nothing, correlations=nothing)
Creates a SampledCorrelations object for calculating and storing instantaneous structure factor intensities $𝒮(𝐪)$. This data will be calculated from the spin-spin correlations of equilibrium snapshots, absent any dynamical information. $𝒮(𝐪)$ data can be retrieved by calling instant_intensities_interpolated.
Important note: When dealing with continuous (non-Ising) spins, consider creating using dynamical_correlations instead of  instant_correlations. The former will provide full $𝒮(𝐪,ω)$ data, from which $𝒮(𝐪)$ can be obtained by integrating out $ω$. During this integration step, Sunny can incorporate temperature- and $ω$-dependent classical-to-quantum correction factors to produce more accurate $𝒮(𝐪)$ estimates. See instant_intensities_interpolated for more information.
Prior to calling instant_correlations, ensure that sys represents a good equilibrium sample. Additional sample data may be accumulated by calling add_sample!(sc, sys) with newly equilibrated sys configurations.
The following optional keywords are available:
  • process_trajectory: Specifies a function that will be applied to the sample   trajectory before correlation analysis. Current options are :none and   :symmetrize. The latter will symmetrize the trajectory in time, which can   be useful for removing Fourier artifacts that arise when calculating the   correlations.
  • observables: Allows the user to specify custom observables. The   observables must be given as a list of complex N×N matrices or   LinearMaps. It's recommended to name each observable, for example:   observables = [:A => a_observable_matrix, :B => b_map, ...]. By default,   Sunny uses the 3 components of the dipole, :Sx, :Sy and :Sz.
  • correlations: Specify which correlation functions are calculated, i.e. which   matrix elements $αβ$ of $𝒮^{αβ}(q,ω)$ are calculated and stored.   Specified with a vector of tuples. By default Sunny records all auto- and   cross-correlations generated by all observables. To retain only the xx and   xy correlations, one would set correlations=[(:Sx,:Sx), (:Sx,:Sy)] or   correlations=[(1,1),(1,2)].
source
Sunny.instant_intensities_interpolated — Method
instant_intensities_interpolated(sc::SampledCorrelations, qs; kwargs...)
Return $𝒮(𝐪)$ intensities at wave vectors qs. The functionality is very similar to intensities_interpolated, except the returned array has dimensions identical to qs. If called on a SampledCorrelations with dynamical information, i.e., $𝒮(𝐪,ω)$, the $ω$ information is integrated out.
source
Sunny.integrate_axes! — Method
integrate_axes!(params::BinningParameters; axes)
Integrate over one or more axes of the histogram by setting the number of bins in that axis to 1. Examples:
integrate_axes!(params; axes = [2,3])
-integrate_axes!(params; axes = 2)
source
Sunny.intensities_bands — Method
dispersion, intensities = intensities_bands(swt::SpinWaveTheory, ks, formula::SpinWaveIntensityFormula)
Computes the scattering intensities at each energy band for each momentum transfer k in ks, according to Linear Spin Wave Theory and the given intensity formula. The formula must have a delta-function kernel, e.g.:
formula = intensity_formula(swt, :perp, formula; kernel = delta_function_kernel)
or else the bands will be broadened, and their intensity can not be computed.
The outputs will be arrays with indices identical to ks, with the last index giving the band index. dispersions reports the energy of each band, while intensities reports the scattering intensity.
source
Sunny.intensities_binned — Method
intensity, counts = intensities_binned(sc::SampledCorrelations, params::BinningParameters, formula; integrated_kernel)
Given correlation data contained in a SampledCorrelations and BinningParameters describing the shape of a histogram, compute the intensity and normalization for each histogram bin using a given intensity_formula.
The BinningParameters are expected to accept (q,ω) in R.L.U. for the (possibly reshaped) crystal associated with sc.
This is an alternative to intensities_interpolated which bins the scattering intensities into a histogram instead of interpolating between them at specified qs values. See unit_resolution_binning_parameters for a reasonable default choice of BinningParameters which roughly emulates intensities_interpolated with interpolation = :round.
If a function integrated_kernel(Δω) is passed, it will be used as the CDF of a kernel function for energy broadening. For example, integrated_kernel = Δω -> atan(Δω/η)/pi (c.f. integrated_lorentzian implements Lorentzian broadening with parameter η. Energy-dependent energy broadening can be achieved by providing an integrated_kernel(ω,Δω) whose first argument is the energy transfer ω.
Currently, energy broadening is only supported if the BinningParameters are such that the first three axes are purely spatial and the last (energy) axis is [0,0,0,1].
source
Sunny.intensities_broadened — Method
intensities_broadened(swt::SpinWaveTheory, ks, ωvals, formula)
Computes the scattering intensities at each (Q,ω) according to Linear Spin Wave Theory and the given intensity formula. The required formula must have a non-delta-function kernel, e.g.:
formula = intensity_formula(swt, :perp; kernel = lorentzian(0.05))
or else the intensity at ωvals which are not exactly on the dispersion curve can not be calculated.
The intensity is computed at each wave vector in ks and each energy in ωvals. The output will be an array with indices identical to ks, with the last index matching ωvals.
Note that ks is an array of wave vectors of arbitrary dimension. Each element $k$ of ks must be a 3-wavevector in absolute units.
source
Sunny.intensities_interpolated — Method
intensities_interpolated(sc::SampledCorrelations, qs, formula:ClassicalIntensityFormula; interpolation=nothing, negative_energies=false)
The basic function for retrieving $𝒮(𝐪,ω)$ information from a SampledCorrelations. Maps an array of wave vectors qs to an array of structure factor intensities, including an additional energy index. The values of $ω$ associated with the energy index can be retrieved by calling available_energies. The three coordinates of each wave vector are measured in reciprocal lattice units, i.e., multiples of the reciprocal lattice vectors.
  • interpolation: Since $𝒮(𝐪, ω)$ is calculated on a finite lattice, data   is only available at discrete wave vectors. By default, Sunny will round a   requested q to the nearest available wave vector. Linear interpolation can   be applied by setting interpolation=:linear.
  • negative_energies: If set to true, Sunny will return the periodic   extension of the energy axis. Most users will not want this.
source
Sunny.intensity_formula — Method
formula = intensity_formula(sc::SampledCorrelations)
Establish a formula for computing the intensity of the discrete scattering modes (q,ω) using the correlation data $𝒮^{αβ}(q,ω)$ stored in the SampledCorrelations. The formula returned from intensity_formula can be passed to intensities_interpolated or intensities_binned.
intensity_formula(sc,...; kT = Inf, formfactors = ...)
There are keyword arguments providing temperature and form factor corrections:
  • kT: If a temperature is provided, the intensities will be rescaled by a   temperature- and ω-dependent classical-to-quantum factor. kT should be   specified when making comparisons with spin wave calculations or   experimental data. If kT is not specified, infinite temperature (no   correction) is assumed.
  • formfactors: To apply form factor corrections, provide this keyword with a   list of FormFactors, one for each symmetry-distinct site in the crystal.   The order of FormFactors must correspond to the order of site symmetry   classes, e.g., as they appear when printed in display(crystal).
source
Sunny.intensity_formula — Method
A custom intensity formula can be specifed by providing a function intensity = f(q,ω,correlations) and specifying which correlations it requires:
intensity_formula(f,sc::SampledCorrelations, required_correlations; kwargs...)
The function is intended to be specified using do notation. For example, this custom formula sums the off-diagonal correlations:
required = [(:Sx,:Sy),(:Sy,:Sz),(:Sx,:Sz)]
+    D[2] -D[1]   0  ]
Useful in the context of set_exchange!.
source
Sunny.dssf — Method
dssf(swt::SpinWaveTheory, qs)
Given a SpinWaveTheory object, computes the dynamical spin structure factor,
\[    𝒮^{αβ}(𝐤, ω) = 1/(2πN)∫dt ∑_𝐫 \exp[i(ωt - 𝐤⋅𝐫)] ⟨S^α(𝐫, t)S^β(0, 0)⟩,\]
using the result from linear spin-wave theory,
\[    𝒮^{αβ}(𝐤, ω) = ∑_n |A_n^{αβ}(𝐤)|^2 δ[ω-ω_n(𝐤)].\]
qs is an array of wave vectors of arbitrary dimension. Each element $q$ of qs must be a 3-vector in reciprocal lattice units (RLU), i.e., in the basis of reciprocal lattice vectors.
The first indices of the returned array correspond to those of qs. A final index, corresponding to mode, is added to these. Each entry of this array is a tensor (3×3 matrix) corresponding to the indices $α$ and $β$.
source
Sunny.dynamical_correlations — Method
dynamical_correlations(sys::System; Δt, nω, ωmax, 
+    process_trajectory=:none, observables=nothing, correlations=nothing)
Creates a SampledCorrelations for calculating and storing $𝒮(𝐪,ω)$ data. This information will be obtained by running dynamical spin simulations on equilibrium snapshots and measuring pair-correlations. The $𝒮(𝐪,ω)$ data can be retrieved by calling intensities_interpolated. Alternatively, instant_intensities_interpolated will integrate out $ω$ to obtain $𝒮(𝐪)$, optionally applying classical-to-quantum correction factors.
The SampleCorrelations that is returned will contain no correlation data. Samples are generated and accumulated by calling add_sample!(sc, sys) where sc is a SampleCorrelations and sys is an appropriately equilibrated System. Note that the sys should be thermalized before each call of add_sample! such that the spin configuration in the system represents a new (fully decorrelated) sample.
Three keywords are required to specify the dynamics used for the trajectory calculation.
  • Δt: The time step used for calculating the trajectory from which dynamic   spin-spin correlations are calculated. The trajectories are calculated with   an ImplicitMidpoint integrator.
  • ωmax: The maximum energy, $ω$, that will be resolved.
  • nω: The number of energy bins to calculated between 0 and ωmax.
Additional keyword options are the following:
  • process_trajectory: Specifies a function that will be applied to the sample   trajectory before correlation analysis. Current options are :none and   :symmetrize. The latter will symmetrize the trajectory in time, which can   be useful for removing Fourier artifacts that arise when calculating the   correlations.
  • observables: Allows the user to specify custom observables. The   observables must be given as a list of complex N×N matrices or   LinearMaps. It's recommended to name each observable, for example:   observables = [:A => a_observable_matrix, :B => b_map, ...]. By default,   Sunny uses the 3 components of the dipole, :Sx, :Sy and :Sz.
  • correlations: Specify which correlation functions are calculated, i.e. which   matrix elements $αβ$ of $𝒮^{αβ}(q,ω)$ are calculated and stored.   Specified with a vector of tuples. By default Sunny records all auto- and   cross-correlations generated by all observables. To retain only the xx and   xy correlations, one would set correlations=[(:Sx,:Sx), (:Sx,:Sy)] or   correlations=[(1,1),(1,2)].
source
Sunny.enable_dipole_dipole! — Method
enable_dipole_dipole!(sys::System)
Enables long-range dipole-dipole interactions,
\[    -(μ_0/4π) ∑_{⟨ij⟩}  (3 (𝐌_j⋅𝐫̂_{ij})(𝐌_i⋅𝐫̂_{ij}) - 𝐌_i⋅𝐌_j) / |𝐫_{ij}|^3\]
where the sum is over all pairs of spins (singly counted), including periodic images, regularized using the Ewald summation convention. The magnetic moments are $𝐌_i = μ_B g 𝐒_i$ where $g$ is the g-factor or g-tensor, and $𝐒_i$ is the spin angular momentum dipole in units of ħ. The Bohr magneton $μ_B$ and vacuum permeability $μ_0$ are physical constants, with numerical values determined by the unit system.
source
Sunny.generate_mantid_script_from_binning_parameters — Method
generate_mantid_script_from_binning_parameters(params::BinningParameters)
Generate a Mantid script which bins data according to the  given BinningParameters.
Units
Take care to ensure the units are correct (R.L.U. or absolute). You may want to call Sunny.bin_rlu_as_absolute_units! or Sunny.bin_absolute_units_as_rlu! first.
source
Sunny.global_position — Method
global_position(sys::System, site::Site)
Position of a Site in global coordinates.
To precompute a full list of positions, one can use eachsite as below:
pos = [global_position(sys, site) for site in eachsite(sys)]
source
Sunny.instant_correlations — Method
instant_correlations(sys::System; process_trajectory=:none, observables=nothing, correlations=nothing)
Creates a SampledCorrelations object for calculating and storing instantaneous structure factor intensities $𝒮(𝐪)$. This data will be calculated from the spin-spin correlations of equilibrium snapshots, absent any dynamical information. $𝒮(𝐪)$ data can be retrieved by calling instant_intensities_interpolated.
Important note: When dealing with continuous (non-Ising) spins, consider creating using dynamical_correlations instead of  instant_correlations. The former will provide full $𝒮(𝐪,ω)$ data, from which $𝒮(𝐪)$ can be obtained by integrating out $ω$. During this integration step, Sunny can incorporate temperature- and $ω$-dependent classical-to-quantum correction factors to produce more accurate $𝒮(𝐪)$ estimates. See instant_intensities_interpolated for more information.
Prior to calling instant_correlations, ensure that sys represents a good equilibrium sample. Additional sample data may be accumulated by calling add_sample!(sc, sys) with newly equilibrated sys configurations.
The following optional keywords are available:
  • process_trajectory: Specifies a function that will be applied to the sample   trajectory before correlation analysis. Current options are :none and   :symmetrize. The latter will symmetrize the trajectory in time, which can   be useful for removing Fourier artifacts that arise when calculating the   correlations.
  • observables: Allows the user to specify custom observables. The   observables must be given as a list of complex N×N matrices or   LinearMaps. It's recommended to name each observable, for example:   observables = [:A => a_observable_matrix, :B => b_map, ...]. By default,   Sunny uses the 3 components of the dipole, :Sx, :Sy and :Sz.
  • correlations: Specify which correlation functions are calculated, i.e. which   matrix elements $αβ$ of $𝒮^{αβ}(q,ω)$ are calculated and stored.   Specified with a vector of tuples. By default Sunny records all auto- and   cross-correlations generated by all observables. To retain only the xx and   xy correlations, one would set correlations=[(:Sx,:Sx), (:Sx,:Sy)] or   correlations=[(1,1),(1,2)].
source
Sunny.instant_intensities_interpolated — Method
instant_intensities_interpolated(sc::SampledCorrelations, qs; kwargs...)
Return $𝒮(𝐪)$ intensities at wave vectors qs. The functionality is very similar to intensities_interpolated, except the returned array has dimensions identical to qs. If called on a SampledCorrelations with dynamical information, i.e., $𝒮(𝐪,ω)$, the $ω$ information is integrated out.
source
Sunny.integrate_axes! — Method
integrate_axes!(params::BinningParameters; axes)
Integrate over one or more axes of the histogram by setting the number of bins in that axis to 1. Examples:
integrate_axes!(params; axes = [2,3])
+integrate_axes!(params; axes = 2)
source
Sunny.intensities_bands — Method
dispersion, intensities = intensities_bands(swt::SpinWaveTheory, ks, formula::SpinWaveIntensityFormula)
Computes the scattering intensities at each energy band for each momentum transfer k in ks, according to Linear Spin Wave Theory and the given intensity formula. The formula must have a delta-function kernel, e.g.:
formula = intensity_formula(swt, :perp, formula; kernel = delta_function_kernel)
or else the bands will be broadened, and their intensity can not be computed.
The outputs will be arrays with indices identical to ks, with the last index giving the band index. dispersions reports the energy of each band, while intensities reports the scattering intensity.
source
Sunny.intensities_binned — Method
intensity, counts = intensities_binned(sc::SampledCorrelations, params::BinningParameters, formula; integrated_kernel)
Given correlation data contained in a SampledCorrelations and BinningParameters describing the shape of a histogram, compute the intensity and normalization for each histogram bin using a given intensity_formula.
The BinningParameters are expected to accept (q,ω) in R.L.U. for the (possibly reshaped) crystal associated with sc.
This is an alternative to intensities_interpolated which bins the scattering intensities into a histogram instead of interpolating between them at specified qs values. See unit_resolution_binning_parameters for a reasonable default choice of BinningParameters which roughly emulates intensities_interpolated with interpolation = :round.
If a function integrated_kernel(Δω) is passed, it will be used as the CDF of a kernel function for energy broadening. For example, integrated_kernel = Δω -> atan(Δω/η)/pi (c.f. integrated_lorentzian implements Lorentzian broadening with parameter η. Energy-dependent energy broadening can be achieved by providing an integrated_kernel(ω,Δω) whose first argument is the energy transfer ω.
Currently, energy broadening is only supported if the BinningParameters are such that the first three axes are purely spatial and the last (energy) axis is [0,0,0,1].
source
Sunny.intensities_broadened — Method
intensities_broadened(swt::SpinWaveTheory, ks, ωvals, formula)
Computes the scattering intensities at each (Q,ω) according to Linear Spin Wave Theory and the given intensity formula. The required formula must have a non-delta-function kernel, e.g.:
formula = intensity_formula(swt, :perp; kernel = lorentzian(0.05))
or else the intensity at ωvals which are not exactly on the dispersion curve can not be calculated.
The intensity is computed at each wave vector in ks and each energy in ωvals. The output will be an array with indices identical to ks, with the last index matching ωvals.
Note that ks is an array of wave vectors of arbitrary dimension. Each element $k$ of ks must be a 3-wavevector in absolute units.
source
Sunny.intensities_interpolated — Method
intensities_interpolated(sc::SampledCorrelations, qs, formula:ClassicalIntensityFormula; interpolation=nothing, negative_energies=false)
The basic function for retrieving $𝒮(𝐪,ω)$ information from a SampledCorrelations. Maps an array of wave vectors qs to an array of structure factor intensities, including an additional energy index. The values of $ω$ associated with the energy index can be retrieved by calling available_energies. The three coordinates of each wave vector are measured in reciprocal lattice units, i.e., multiples of the reciprocal lattice vectors.
  • interpolation: Since $𝒮(𝐪, ω)$ is calculated on a finite lattice, data   is only available at discrete wave vectors. By default, Sunny will round a   requested q to the nearest available wave vector. Linear interpolation can   be applied by setting interpolation=:linear.
  • negative_energies: If set to true, Sunny will return the periodic   extension of the energy axis. Most users will not want this.
source
Sunny.intensity_formula — Method
formula = intensity_formula(sc::SampledCorrelations)
Establish a formula for computing the intensity of the discrete scattering modes (q,ω) using the correlation data $𝒮^{αβ}(q,ω)$ stored in the SampledCorrelations. The formula returned from intensity_formula can be passed to intensities_interpolated or intensities_binned.
intensity_formula(sc,...; kT = Inf, formfactors = ...)
There are keyword arguments providing temperature and form factor corrections:
  • kT: If a temperature is provided, the intensities will be rescaled by a   temperature- and ω-dependent classical-to-quantum factor. kT should be   specified when making comparisons with spin wave calculations or   experimental data. If kT is not specified, infinite temperature (no   correction) is assumed.
  • formfactors: To apply form factor corrections, provide this keyword with a   list of FormFactors, one for each symmetry-distinct site in the crystal.   The order of FormFactors must correspond to the order of site symmetry   classes, e.g., as they appear when printed in display(crystal).
source
Sunny.intensity_formula — Method
A custom intensity formula can be specifed by providing a function intensity = f(q,ω,correlations) and specifying which correlations it requires:
intensity_formula(f,sc::SampledCorrelations, required_correlations; kwargs...)
The function is intended to be specified using do notation. For example, this custom formula sums the off-diagonal correlations:
required = [(:Sx,:Sy),(:Sy,:Sz),(:Sx,:Sz)]
 intensity_formula(sc,required,return_type = ComplexF64) do k, ω, off_diagonal_correlations
     sum(off_diagonal_correlations)
-end
If your custom formula returns a type other than Float64, use the return_type keyword argument to flag this.
source
Sunny.intensity_formula — Method
formula = intensity_formula(swt::SpinWaveTheory; kernel = ...)
Establish a formula for computing the scattering intensity by diagonalizing the hamiltonian $H(q)$ using Linear Spin Wave Theory.
If kernel = delta_function_kernel, then the resulting formula can be used with intensities_bands.
If kernel is an energy broadening kernel function, then the resulting formula can be used with intensities_broadened. Energy broadening kernel functions can either be a function of Δω only, e.g.:
kernel = Δω -> ...
or a function of both the energy transfer ω and of Δω, e.g.:
kernel = (ω,Δω) -> ...
The integral of a properly normalized kernel function over all Δω is one.
source
Sunny.intensity_formula — Method
intensity_formula([swt or sc], contraction_mode::Symbol)
Sunny has several built-in formulas that can be selected by setting contraction_mode to one of these values:
  • :trace (default), which yields $\operatorname{tr} 𝒮(q,ω) = ∑_α 𝒮^{αα}(q,ω)$
  • :perp, which contracts $𝒮^{αβ}(q,ω)$ with the dipole factor $δ_{αβ} - q_{α}q_{β}$, returning the unpolarized intensity.
  • :full, which will return all elements $𝒮^{αβ}(𝐪,ω)$ without contraction.
source
Sunny.lattice_params — Method
lattice_params(latvecs::Mat3)
Compute the lattice parameters $(a, b, c, α, β, γ)$ for the three lattice vectors provided as columns of latvecs. The inverse mapping is lattice_vectors.
source
Sunny.lattice_vectors — Method
lattice_vectors(a, b, c, α, β, γ)
Return the lattice vectors, as columns of the $3×3$ output matrix, that correspond to the conventional unit cell defined by the lattice constants $(a, b, c)$ and the angles $(α, β, γ)$ in degrees. The inverse mapping is lattice_params.
source
Sunny.magnetic_moment — Method
magnetic_moment(sys::System, site::Site)
Get the magnetic moment for a Site. This is the spin dipole multiplied by the Bohr magneton and the local g-tensor.
source
Sunny.merge! — Method
merge!(sc::SampledCorrelations, others...)
Accumulate the samples in others (one or more SampledCorrelations) into sc.
source
Sunny.minimize_energy! — Method
minimize_energy!(sys::System{N}; maxiters=100, subiters=20,
-                 method=Optim.ConjugateGradient(), kwargs...) where N
Optimizes the spin configuration in sys to minimize energy. A total of maxiters iterations will be attempted, with restarts after every subiters iterations. The remaining kwargs will be forwarded to the optimize method of the Optim.jl package.
source
Sunny.position_to_site — Method
position_to_site(sys::System, r)
Converts a position r to four indices of a Site. The coordinates of r are given in units of the lattice vectors for the original crystal. This function can be useful for working with systems that have been reshaped using reshape_supercell.
Example
# Find the `site` at the center of a unit cell which is displaced by four
+end
If your custom formula returns a type other than Float64, use the return_type keyword argument to flag this.
source
Sunny.intensity_formula — Method
formula = intensity_formula(swt::SpinWaveTheory; kernel = ...)
Establish a formula for computing the scattering intensity by diagonalizing the hamiltonian $H(q)$ using Linear Spin Wave Theory.
If kernel = delta_function_kernel, then the resulting formula can be used with intensities_bands.
If kernel is an energy broadening kernel function, then the resulting formula can be used with intensities_broadened. Energy broadening kernel functions can either be a function of Δω only, e.g.:
kernel = Δω -> ...
or a function of both the energy transfer ω and of Δω, e.g.:
kernel = (ω,Δω) -> ...
The integral of a properly normalized kernel function over all Δω is one.
source
Sunny.intensity_formula — Method
intensity_formula([swt or sc], contraction_mode::Symbol)
Sunny has several built-in formulas that can be selected by setting contraction_mode to one of these values:
  • :trace (default), which yields $\operatorname{tr} 𝒮(q,ω) = ∑_α 𝒮^{αα}(q,ω)$
  • :perp, which contracts $𝒮^{αβ}(q,ω)$ with the dipole factor $δ_{αβ} - q_{α}q_{β}$, returning the unpolarized intensity.
  • :full, which will return all elements $𝒮^{αβ}(𝐪,ω)$ without contraction.
source
Sunny.lattice_params — Method
lattice_params(latvecs::Mat3)
Compute the lattice parameters $(a, b, c, α, β, γ)$ for the three lattice vectors provided as columns of latvecs. The inverse mapping is lattice_vectors.
source
Sunny.lattice_vectors — Method
lattice_vectors(a, b, c, α, β, γ)
Return the lattice vectors, as columns of the $3×3$ output matrix, that correspond to the conventional unit cell defined by the lattice constants $(a, b, c)$ and the angles $(α, β, γ)$ in degrees. The inverse mapping is lattice_params.
source
Sunny.magnetic_moment — Method
magnetic_moment(sys::System, site::Site)
Get the magnetic moment for a Site. This is the spin dipole multiplied by the Bohr magneton and the local g-tensor.
source
Sunny.merge! — Method
merge!(sc::SampledCorrelations, others...)
Accumulate the samples in others (one or more SampledCorrelations) into sc.
source
Sunny.minimize_energy! — Method
minimize_energy!(sys::System{N}; maxiters=100, subiters=20,
+                 method=Optim.ConjugateGradient(), kwargs...) where N
Optimizes the spin configuration in sys to minimize energy. A total of maxiters iterations will be attempted, with restarts after every subiters iterations. The remaining kwargs will be forwarded to the optimize method of the Optim.jl package.
source
Sunny.position_to_site — Method
position_to_site(sys::System, r)
Converts a position r to four indices of a Site. The coordinates of r are given in units of the lattice vectors for the original crystal. This function can be useful for working with systems that have been reshaped using reshape_supercell.
Example
# Find the `site` at the center of a unit cell which is displaced by four
 # multiples of the first lattice vector
 site = position_to_site(sys, [4.5, 0.5, 0.5])
 
 # Print the dipole at this site
-println(sys.dipoles[site])
source
Sunny.powder_average_binned — Method
powder_average_binned(sc::SampledCorrelations, radial_binning_parameters; formula
-                     ω_binning_parameters, integrated_kernel = nothing, bzsize = nothing)
This function emulates the experimental situation of "powder averaging," where only the magnitude (and not the direction) of the momentum transfer is resolvable. The intensities are binned similarly to intensities_binned, but the histogram x-axis is |k| in absolute units, which is a nonlinear function of kx,ky,kz. The y-axis is energy.
Radial binning parameters are specified as tuples (start,end,bin_width), e.g. radial_binning_parameters = (0,6π,6π/55).
Energy broadening is supported in the same way as intensities_binned, and this function accepts the same kind of intensity_formula.
source
Sunny.print_bond — Method
print_bond(cryst::Crystal, bond::Bond; b_ref::Bond)
Prints symmetry information for bond bond. A symmetry-equivalent reference bond b_ref can optionally be provided to fix the meaning of the coefficients A, B, ...
source
Sunny.print_site — Method
print_site(cryst, i; R=I)
Print symmetry information for the site i, including allowed g-tensor and allowed anisotropy operator. An optional rotation matrix R can be provided to define the reference frame for expression of the anisotropy.
source
Sunny.print_stevens_expansion — Method
function print_stevens_expansion(op)
Prints a local Hermitian operator as a linear combination of Stevens operators. This function works on explicit matrix representations.
Examples
S = spin_matrices(N=5)
+println(sys.dipoles[site])
source
Sunny.powder_average_binned — Method
powder_average_binned(sc::SampledCorrelations, radial_binning_parameters; formula
+                     ω_binning_parameters, integrated_kernel = nothing, bzsize = nothing)
This function emulates the experimental situation of "powder averaging," where only the magnitude (and not the direction) of the momentum transfer is resolvable. The intensities are binned similarly to intensities_binned, but the histogram x-axis is |k| in absolute units, which is a nonlinear function of kx,ky,kz. The y-axis is energy.
Radial binning parameters are specified as tuples (start,end,bin_width), e.g. radial_binning_parameters = (0,6π,6π/55).
Energy broadening is supported in the same way as intensities_binned, and this function accepts the same kind of intensity_formula.
source
Sunny.print_bond — Method
print_bond(cryst::Crystal, bond::Bond; b_ref::Bond)
Prints symmetry information for bond bond. A symmetry-equivalent reference bond b_ref can optionally be provided to fix the meaning of the coefficients A, B, ...
source
Sunny.print_site — Method
print_site(cryst, i; R=I)
Print symmetry information for the site i, including allowed g-tensor and allowed anisotropy operator. An optional rotation matrix R can be provided to define the reference frame for expression of the anisotropy.
source
Sunny.print_stevens_expansion — Method
function print_stevens_expansion(op)
Prints a local Hermitian operator as a linear combination of Stevens operators. This function works on explicit matrix representations.
Examples
S = spin_matrices(N=5)
 print_stevens_expansion(S[1]^4 + S[2]^4 + S[3]^4)
-# Prints: (1/20)𝒪₄₀ + (1/4)𝒪₄₄ + 102/5
source
Sunny.print_suggested_frame — Method
print_suggested_frame(cryst, i; digits=4)
Print a suggested reference frame, as a rotation matrix R, that can be used as input to print_site(). This is useful to simplify the description of allowed anisotropies.
source
Sunny.print_symmetry_table — Method
print_symmetry_table(cryst::Crystal, max_dist)
Print symmetry information for all equivalence classes of sites and bonds, up to a maximum bond distance of max_dist. Equivalent to calling print_bond(cryst, b) for every bond b in reference_bonds(cryst, max_dist), where Bond(i, i, [0,0,0]) refers to a single site i.
source
Sunny.print_wrapped_intensities — Method
print_wrapped_intensities(sys::System; nmax=10)
For Bravais lattices: Prints up to nmax wavevectors according to their instantaneous (static) structure factor intensities, listed in descending order. For non-Bravais lattices: Performs the same analysis for each spin sublattice independently; the output weights are naïvely averaged over sublattices, without incorporating phase shift information. Only wavevectors within the first Brillouin zone are printed. Wavevector coordinates are given in reciprocal lattice units, such that each coordinate is between $-1/2$ and $1/2$.  The output from this function will typically be used as input to suggest_magnetic_supercell.
Because this function does not incorporate phase information in its averaging over sublattices, the printed weights are not directly comparable with experiment. For that purpose, use instant_correlations instead.
The weights printed by print_wrapped_intensities may be given a physical interpretation as follows: All possible $q$-vectors are periodically wrapped into the first Brillouin zone, and the average over their corresponding instantaneous structure factor intensities produce the output weights.
source
Sunny.propose_delta — Method
propose_delta(magnitude)
Generate a proposal function that adds a Gaussian perturbation to the existing spin state. In :dipole mode, the procedure is to first introduce a random three-vector perturbation $𝐬′ = 𝐬 + |𝐬| ξ$ and then return the properly normalized spin $|𝐬| (𝐬′/|𝐬′|)$. Each component of the random vector $ξ$ is Gaussian distributed with a standard deviation of magnitude; the latter is dimensionless and typically smaller than one. 
In :SUN mode, the procedure is analogous, but now involving Gaussian perturbations to each of the $N$ complex components of an SU(N) coherent state.
In the limit of very large magnitude, this function coincides with propose_uniform.
For use with LocalSampler.
source
Sunny.propose_flip — Method
propose_flip
Function to propose pure spin flip updates in the context of a LocalSampler. Dipoles are flipped as $𝐬 → -𝐬$. SU(N) coherent states are flipped using the time-reversal operator.
source
Sunny.propose_uniform — Function
propose_uniform
Function to propose a uniformly random spin update in the context of a LocalSampler. In :dipole mode, the result is a random three-vector with appropriate normalization. In :SUN mode, the result is a random SU(N) coherent state with appropriate normalization.
source
Sunny.reciprocal_lattice_vectors — Method
reciprocal_lattice_vectors(cryst::Crystal)
Returns the $3×3$ matrix $(𝐛₁,𝐛₂,𝐛₃)$ with columns $𝐛ᵢ$ as reciprocal lattice vectors. These are defined to satisfy $𝐛ᵢ⋅𝐚ⱼ = 2πδᵢⱼ$, where $(𝐚₁,𝐚₂,𝐚₃)$ are the lattice vectors used to construct cryst.
source
Sunny.reciprocal_space_path — Method
reciprocal_space_path(cryst::Crystal, qs, density)
Returns a pair (path, xticks). The path return value is a list of wavevectors that samples linearly between the provided wavevectors qs. The xticks return value can be used to label the special $𝐪$ values on the x-axis of a plot.
Special note about units: the wavevectors qs must be provided in reciprocal lattice units (RLU) for the given crystal, but the sampling density must be specified in units of inverse length. The path will therefore include more samples between q-points that are further apart in absolute Fourier distance (units of inverse length).
source
Sunny.reciprocal_space_path_bins — Method
reciprocal_space_path_bins(sc,qs,density,args...;kwargs...)
Takes a list of wave vectors, qs in R.L.U., and builds a series of histogram BinningParameters whose first axis traces a path through the provided points. The second and third axes are integrated over according to the args and kwargs, which are passed through to slice_2D_binning_parameters.
Also returned is a list of marker indices corresponding to the input points, and a list of ranges giving the indices of each histogram x-axis within a concatenated histogram. The density parameter is given in samples per reciprocal lattice unit (R.L.U.).
source
Sunny.reciprocal_space_shell — Method
reciprocal_space_shell(cryst::Crystal, radius, n)
Sample n points on the reciprocal space sphere with a given radius (units of inverse length).
Examples
# Sample wavevectors on the sphere at fixed density
-reciprocal_space_shell(cryst, r, 4π*r^2*density)
source
Sunny.reference_bonds — Method
reference_bonds(cryst::Crystal, max_dist)
Returns a full list of bonds, one for each symmetry equivalence class, up to distance max_dist. The reference bond b for each equivalence class is selected according to a scoring system that prioritizes simplification of the elements in basis_for_symmetry_allowed_couplings(cryst, b).
source
Sunny.remove_periodicity! — Method
remove_periodicity!(sys::System, dims)
Remove periodic interactions along the dimensions where dims is true. The system must support inhomogeneous interactions via to_inhomogeneous.
Example
# Remove periodic boundaries along the 1st and 3rd dimensions
-remove_periodicity!(sys::System, (true, false, true))
source
Sunny.repeat_periodically — Method
repeat_periodically(sys::System{N}, counts) where N
Creates a System identical to sys but repeated a given number of times in each dimension, specified by the tuple counts.
source
Sunny.reshape_supercell — Method
reshape_supercell(sys::System, A)
Maps an existing System to a new one that has the shape and periodicity of a requested supercell. The columns of the $3×3$ integer matrix A represent the supercell lattice vectors measured in units of the original crystal lattice vectors.
The crystal unit cell may also need to be reshaped to achieve the desired periodicity of the requested supercell. If this is the case, the returned System object will be missing symmetry information. Consequently, certain operations will be unavailable for this system, e.g., setting interactions by symmetry propagation. In practice, one can set all interactions using the original system, and then reshape as a final step.
source
Sunny.resize_supercell — Method
resize_supercell(sys::System{N}, latsize) where N
Creates a System identical to sys but enlarged to a given number of unit cells in each lattice vector direction.
An error will be thrown if sys is incommensurate with latsize. Use reshape_supercell instead to reduce the volume, or to perform an incommensurate reshaping.
source
Sunny.rotate_operator — Method
rotate_operator(A, R)
Rotates the local quantum operator A according to the $3×3$ rotation matrix R.
source
Sunny.rotation_in_rlu — Method
rotation_in_rlu(cryst::Crystal, axis, angle)
Returns a $3×3$ matrix that rotates wavevectors in reciprocal lattice units (RLU). The axis vector is a real-space direction in absolute units (but arbitrary magnitude), and the angle is in radians.
source
Sunny.set_coherent! — Method
set_coherent!(sys::System, Z, site::Site)
Set a coherent spin state at a Site using the $N$ complex amplitudes in Z.
For a standard SpinInfo, these amplitudes will be interpreted in the eigenbasis of $𝒮̂ᶻ$. That is, Z[1] represents the amplitude for the basis state fully polarized along the $ẑ$-direction, and subsequent components represent states with decreasing angular momentum along this axis ($m = S, S-1, …, -S$).
source
Sunny.set_exchange! — Method
set_exchange!(sys::System, J, bond::Bond; biquad=0.)
Sets a 3×3 spin-exchange matrix J along bond, yielding a pairwise interaction energy $𝐒_i⋅J 𝐒_j$. This interaction will be propagated to equivalent bonds in consistency with crystal symmetry. Any previous exchange interactions on these bonds will be overwritten. The parameter bond has the form Bond(i, j, offset), where i and j are atom indices within the unit cell, and offset is a displacement in unit cells.
The parameter J may be scalar or matrix-valued. As a convenience, dmvec(D) can be used to construct the antisymmetric part of the exchange, where D is the Dzyaloshinskii-Moriya pseudo-vector. The resulting interaction will be $𝐃⋅(𝐒_i×𝐒_j)$.
The optional parameter biquad defines the strength $b$ for scalar biquadratic interactions of the form $b (𝐒_i⋅𝐒_j)²$ For systems restricted to dipoles, $b$ will be automatically renormalized for maximum consistency with the more variationally accurate SU(N) mode. This renormalization introduces also a correction to the quadratic part of the exchange.
Examples
using Sunny, LinearAlgebra
+# Prints: (1/20)𝒪₄₀ + (1/4)𝒪₄₄ + 102/5
source
Sunny.print_suggested_frame — Method
print_suggested_frame(cryst, i; digits=4)
Print a suggested reference frame, as a rotation matrix R, that can be used as input to print_site(). This is useful to simplify the description of allowed anisotropies.
source
Sunny.print_symmetry_table — Method
print_symmetry_table(cryst::Crystal, max_dist)
Print symmetry information for all equivalence classes of sites and bonds, up to a maximum bond distance of max_dist. Equivalent to calling print_bond(cryst, b) for every bond b in reference_bonds(cryst, max_dist), where Bond(i, i, [0,0,0]) refers to a single site i.
source
Sunny.print_wrapped_intensities — Method
print_wrapped_intensities(sys::System; nmax=10)
For Bravais lattices: Prints up to nmax wavevectors according to their instantaneous (static) structure factor intensities, listed in descending order. For non-Bravais lattices: Performs the same analysis for each spin sublattice independently; the output weights are naïvely averaged over sublattices, without incorporating phase shift information. Only wavevectors within the first Brillouin zone are printed. Wavevector coordinates are given in reciprocal lattice units, such that each coordinate is between $-1/2$ and $1/2$.  The output from this function will typically be used as input to suggest_magnetic_supercell.
Because this function does not incorporate phase information in its averaging over sublattices, the printed weights are not directly comparable with experiment. For that purpose, use instant_correlations instead.
The weights printed by print_wrapped_intensities may be given a physical interpretation as follows: All possible $q$-vectors are periodically wrapped into the first Brillouin zone, and the average over their corresponding instantaneous structure factor intensities produce the output weights.
source
Sunny.propose_delta — Method
propose_delta(magnitude)
Generate a proposal function that adds a Gaussian perturbation to the existing spin state. In :dipole mode, the procedure is to first introduce a random three-vector perturbation $𝐬′ = 𝐬 + |𝐬| ξ$ and then return the properly normalized spin $|𝐬| (𝐬′/|𝐬′|)$. Each component of the random vector $ξ$ is Gaussian distributed with a standard deviation of magnitude; the latter is dimensionless and typically smaller than one. 
In :SUN mode, the procedure is analogous, but now involving Gaussian perturbations to each of the $N$ complex components of an SU(N) coherent state.
In the limit of very large magnitude, this function coincides with propose_uniform.
For use with LocalSampler.
source
Sunny.propose_flip — Method
propose_flip
Function to propose pure spin flip updates in the context of a LocalSampler. Dipoles are flipped as $𝐬 → -𝐬$. SU(N) coherent states are flipped using the time-reversal operator.
source
Sunny.propose_uniform — Function
propose_uniform
Function to propose a uniformly random spin update in the context of a LocalSampler. In :dipole mode, the result is a random three-vector with appropriate normalization. In :SUN mode, the result is a random SU(N) coherent state with appropriate normalization.
source
Sunny.reciprocal_lattice_vectors — Method
reciprocal_lattice_vectors(cryst::Crystal)
Returns the $3×3$ matrix $(𝐛₁,𝐛₂,𝐛₃)$ with columns $𝐛ᵢ$ as reciprocal lattice vectors. These are defined to satisfy $𝐛ᵢ⋅𝐚ⱼ = 2πδᵢⱼ$, where $(𝐚₁,𝐚₂,𝐚₃)$ are the lattice vectors used to construct cryst.
source
Sunny.reciprocal_space_path — Method
reciprocal_space_path(cryst::Crystal, qs, density)
Returns a pair (path, xticks). The path return value is a list of wavevectors that samples linearly between the provided wavevectors qs. The xticks return value can be used to label the special $𝐪$ values on the x-axis of a plot.
Special note about units: the wavevectors qs must be provided in reciprocal lattice units (RLU) for the given crystal, but the sampling density must be specified in units of inverse length. The path will therefore include more samples between q-points that are further apart in absolute Fourier distance (units of inverse length).
source
Sunny.reciprocal_space_path_bins — Method
reciprocal_space_path_bins(sc,qs,density,args...;kwargs...)
Takes a list of wave vectors, qs in R.L.U., and builds a series of histogram BinningParameters whose first axis traces a path through the provided points. The second and third axes are integrated over according to the args and kwargs, which are passed through to slice_2D_binning_parameters.
Also returned is a list of marker indices corresponding to the input points, and a list of ranges giving the indices of each histogram x-axis within a concatenated histogram. The density parameter is given in samples per reciprocal lattice unit (R.L.U.).
source
Sunny.reciprocal_space_shell — Method
reciprocal_space_shell(cryst::Crystal, radius, n)
Sample n points on the reciprocal space sphere with a given radius (units of inverse length).
Examples
# Sample wavevectors on the sphere at fixed density
+reciprocal_space_shell(cryst, r, 4π*r^2*density)
source
Sunny.reference_bonds — Method
reference_bonds(cryst::Crystal, max_dist)
Returns a full list of bonds, one for each symmetry equivalence class, up to distance max_dist. The reference bond b for each equivalence class is selected according to a scoring system that prioritizes simplification of the elements in basis_for_symmetry_allowed_couplings(cryst, b).
source
Sunny.remove_periodicity! — Method
remove_periodicity!(sys::System, dims)
Remove periodic interactions along the dimensions where dims is true. The system must support inhomogeneous interactions via to_inhomogeneous.
Example
# Remove periodic boundaries along the 1st and 3rd dimensions
+remove_periodicity!(sys::System, (true, false, true))
source
Sunny.repeat_periodically — Method
repeat_periodically(sys::System{N}, counts) where N
Creates a System identical to sys but repeated a given number of times in each dimension, specified by the tuple counts.
source
Sunny.reshape_supercell — Method
reshape_supercell(sys::System, A)
Maps an existing System to a new one that has the shape and periodicity of a requested supercell. The columns of the $3×3$ integer matrix A represent the supercell lattice vectors measured in units of the original crystal lattice vectors.
The crystal unit cell may also need to be reshaped to achieve the desired periodicity of the requested supercell. If this is the case, the returned System object will be missing symmetry information. Consequently, certain operations will be unavailable for this system, e.g., setting interactions by symmetry propagation. In practice, one can set all interactions using the original system, and then reshape as a final step.
source
Sunny.resize_supercell — Method
resize_supercell(sys::System{N}, latsize) where N
Creates a System identical to sys but enlarged to a given number of unit cells in each lattice vector direction.
An error will be thrown if sys is incommensurate with latsize. Use reshape_supercell instead to reduce the volume, or to perform an incommensurate reshaping.
source
Sunny.rotate_operator — Method
rotate_operator(A, R)
Rotates the local quantum operator A according to the $3×3$ rotation matrix R.
source
Sunny.rotation_in_rlu — Method
rotation_in_rlu(cryst::Crystal, axis, angle)
Returns a $3×3$ matrix that rotates wavevectors in reciprocal lattice units (RLU). The axis vector is a real-space direction in absolute units (but arbitrary magnitude), and the angle is in radians.
source
Sunny.set_coherent! — Method
set_coherent!(sys::System, Z, site::Site)
Set a coherent spin state at a Site using the $N$ complex amplitudes in Z.
For a standard SpinInfo, these amplitudes will be interpreted in the eigenbasis of $𝒮̂ᶻ$. That is, Z[1] represents the amplitude for the basis state fully polarized along the $ẑ$-direction, and subsequent components represent states with decreasing angular momentum along this axis ($m = S, S-1, …, -S$).
source
Sunny.set_exchange! — Method
set_exchange!(sys::System, J, bond::Bond; biquad=0.)
Sets a 3×3 spin-exchange matrix J along bond, yielding a pairwise interaction energy $𝐒_i⋅J 𝐒_j$. This interaction will be propagated to equivalent bonds in consistency with crystal symmetry. Any previous exchange interactions on these bonds will be overwritten. The parameter bond has the form Bond(i, j, offset), where i and j are atom indices within the unit cell, and offset is a displacement in unit cells.
The parameter J may be scalar or matrix-valued. As a convenience, dmvec(D) can be used to construct the antisymmetric part of the exchange, where D is the Dzyaloshinskii-Moriya pseudo-vector. The resulting interaction will be $𝐃⋅(𝐒_i×𝐒_j)$.
The optional parameter biquad defines the strength $b$ for scalar biquadratic interactions of the form $b (𝐒_i⋅𝐒_j)²$ For systems restricted to dipoles, $b$ will be automatically renormalized for maximum consistency with the more variationally accurate SU(N) mode. This renormalization introduces also a correction to the quadratic part of the exchange.
Examples
using Sunny, LinearAlgebra
 
 # An explicit exchange matrix
 J1 = [2 3 0;
@@ -57,7 +57,7 @@
 
 # An equivalent Heisenberg + DM exchange 
 J2 = 2*I + dmvec([0,0,3])
-set_exchange!(sys, J2, bond)
source
Sunny.set_exchange_at! — Method
set_exchange_at!(sys::System, J, site1::Site, site2::Site; biquad=0., offset=nothing)
Sets the exchange interaction along the single bond connecting two Sites, ignoring crystal symmetry. The system must support inhomogeneous interactions via to_inhomogeneous.
If the system is relatively small, the direction of the bond can be ambiguous due to possible periodic wrapping. Resolve this ambiguity by passing an explicit offset vector, in multiples of unit cells.
See also set_exchange!.
source
Sunny.set_external_field_at! — Method
set_external_field_at!(sys::System, B::Vec3, site::Site)
Sets a Zeeman coupling between a field B and a single spin. Site includes a unit cell and a sublattice index.
source
Sunny.set_onsite_coupling! — Method
set_onsite_coupling!(sys::System, op::Matrix{ComplexF64}, i::Int)
Set the single-ion anisotropy for the ith atom of every unit cell, as well as all symmetry-equivalent atoms. The local operator op may be constructed using spin_operators or stevens_operators.
For systems restricted to dipoles, the anisotropy operators interactions will automatically be renormalized to achieve maximum consistency with the more variationally accurate SU(N) mode.
Examples
# An easy axis anisotropy in the z-direction
+set_exchange!(sys, J2, bond)
source
Sunny.set_exchange_at! — Method
set_exchange_at!(sys::System, J, site1::Site, site2::Site; biquad=0., offset=nothing)
Sets the exchange interaction along the single bond connecting two Sites, ignoring crystal symmetry. The system must support inhomogeneous interactions via to_inhomogeneous.
If the system is relatively small, the direction of the bond can be ambiguous due to possible periodic wrapping. Resolve this ambiguity by passing an explicit offset vector, in multiples of unit cells.
See also set_exchange!.
source
Sunny.set_external_field_at! — Method
set_external_field_at!(sys::System, B::Vec3, site::Site)
Sets a Zeeman coupling between a field B and a single spin. Site includes a unit cell and a sublattice index.
source
Sunny.set_onsite_coupling! — Method
set_onsite_coupling!(sys::System, op::Matrix{ComplexF64}, i::Int)
Set the single-ion anisotropy for the ith atom of every unit cell, as well as all symmetry-equivalent atoms. The local operator op may be constructed using spin_operators or stevens_operators.
For systems restricted to dipoles, the anisotropy operators interactions will automatically be renormalized to achieve maximum consistency with the more variationally accurate SU(N) mode.
Examples
# An easy axis anisotropy in the z-direction
 S = spin_operators(sys, i)
 set_onsite_coupling!(sys, -D*S[3]^3, i)
 
@@ -67,15 +67,15 @@
 set_onsite_coupling!(sys, O[4,0] + 5*O[4,4], i)
 
 # An equivalent expression of this quartic anisotropy, up to a constant shift
-set_onsite_coupling!(sys, 20*(S[1]^4 + S[2]^4 + S[3]^4), i)
See also spin_operators.
source
Sunny.set_vacancy_at! — Method
set_vacancy_at!(sys::System, site::Site)
Make a single site nonmagnetic. Site includes a unit cell and a sublattice index.
source
Sunny.slice_2D_binning_parameters — Method
slice_2D_binning_parameter(sc::SampledCorrelations, cut_from_q, cut_to_q, cut_bins::Int64, cut_width::Float64; plane_normal = [0,0,1],cut_height = cutwidth)
Creates BinningParameters which make a cut along one dimension of Q-space.
The x-axis of the resulting histogram consists of cut_bins-many bins ranging from cut_from_q to cut_to_q.  The width of the bins in the transverse direciton is controlled by cut_width and cut_height.
The binning in the transverse directions is defined in the following way, which sets their normalization and orthogonality properties:
cut_covector = normalize(cut_to_q - cut_from_q)
+set_onsite_coupling!(sys, 20*(S[1]^4 + S[2]^4 + S[3]^4), i)
See also spin_operators.
source
Sunny.set_vacancy_at! — Method
set_vacancy_at!(sys::System, site::Site)
Make a single site nonmagnetic. Site includes a unit cell and a sublattice index.
source
Sunny.slice_2D_binning_parameters — Method
slice_2D_binning_parameter(sc::SampledCorrelations, cut_from_q, cut_to_q, cut_bins::Int64, cut_width::Float64; plane_normal = [0,0,1],cut_height = cutwidth)
Creates BinningParameters which make a cut along one dimension of Q-space.
The x-axis of the resulting histogram consists of cut_bins-many bins ranging from cut_from_q to cut_to_q.  The width of the bins in the transverse direciton is controlled by cut_width and cut_height.
The binning in the transverse directions is defined in the following way, which sets their normalization and orthogonality properties:
cut_covector = normalize(cut_to_q - cut_from_q)
 transverse_covector = normalize(plane_normal × cut_covector)
-cotransverse_covector = normalize(transverse_covector × cut_covector)
In other words, the axes are orthonormal with respect to the Euclidean metric.
If the cut is too narrow, there will be very few scattering vectors per bin, or the number per bin will vary substantially along the cut. If the output appears under-resolved, try increasing cut_width.
The four axes of the resulting histogram are:
  1. Along the cut
  2. Fist transverse Q direction
  3. Second transverse Q direction
  4. Energy
This function can be used without reference to a SampledCorrelations using this alternate syntax to manually specify the bin centers for the energy axis:
slice_2D_binning_parameter(ω_bincenters, cut_from, cut_to,...)
where ω_bincenters specifies the energy axis, and both cut_from and cut_to are arbitrary covectors, in any units.
source
Sunny.spin_matrices — Method
spin_matrices(; N)
Constructs the three spin operators, i.e. the generators of SU(2), in the N-dimensional irrep. See also spin_operators, which determines the appropriate value of N for a given site index.
source
Sunny.step! — Function
step!(sys::System, dynamics)
Advance the spin configuration one dynamical time-step. The dynamics object may be a continuous spin dynamics, such as Langevin or ImplicitMidpoint, or it may be a discrete Monte Carlo sampling scheme such as LocalSampler.
source
Sunny.stevens_operators — Method
stevens_operators(sys, i::Int)
-stevens_operators(sys, site::Int)
Returns a generator of Stevens operators appropriate to an atom or Site index. The return value O can be indexed as O[k,q], where $0 ≤ k ≤ 6$ labels an irrep and $q = -k, …, k$. This will produce an $N×N$ matrix of appropriate dimension $N$.
source
Sunny.subcrystal — Method
subcrystal(cryst, types) :: Crystal
Filters sublattices of a Crystal by atom types, keeping the space group unchanged.
subcrystal(cryst, classes) :: Crystal
Filters sublattices of Crystal by equivalence classes, keeping the space group unchanged.
source
Sunny.suggest_magnetic_supercell — Method
suggest_magnetic_supercell(qs, latsize)
Suggests a magnetic supercell, in units of the crystal lattice vectors, that is consistent with periodicity of the wavevectors in qs. An upper bound for the supercell is given by latsize, which is measured in units of lattice vectors, and must be commensurate with the wavevectors.
source
Sunny.symmetry_equivalent_bonds — Method
symmetry_equivalent_bonds(sys::System, bond::Bond)
Given a Bond for the original (unreshaped) crystal, return all symmetry equivalent bonds in the System. Each returned bond is represented as a pair of Sites, which may be used as input to set_exchange_at!. Reverse bonds are not included (no double counting).
Example
for (site1, site2, offset) in symmetry_equivalent_bonds(sys, bond)
+cotransverse_covector = normalize(transverse_covector × cut_covector)
In other words, the axes are orthonormal with respect to the Euclidean metric.
If the cut is too narrow, there will be very few scattering vectors per bin, or the number per bin will vary substantially along the cut. If the output appears under-resolved, try increasing cut_width.
The four axes of the resulting histogram are:
  1. Along the cut
  2. Fist transverse Q direction
  3. Second transverse Q direction
  4. Energy
This function can be used without reference to a SampledCorrelations using this alternate syntax to manually specify the bin centers for the energy axis:
slice_2D_binning_parameter(ω_bincenters, cut_from, cut_to,...)
where ω_bincenters specifies the energy axis, and both cut_from and cut_to are arbitrary covectors, in any units.
source
Sunny.spin_matrices — Method
spin_matrices(; N)
Constructs the three spin operators, i.e. the generators of SU(2), in the N-dimensional irrep. See also spin_operators, which determines the appropriate value of N for a given site index.
source
Sunny.step! — Function
step!(sys::System, dynamics)
Advance the spin configuration one dynamical time-step. The dynamics object may be a continuous spin dynamics, such as Langevin or ImplicitMidpoint, or it may be a discrete Monte Carlo sampling scheme such as LocalSampler.
source
Sunny.stevens_operators — Method
stevens_operators(sys, i::Int)
+stevens_operators(sys, site::Int)
Returns a generator of Stevens operators appropriate to an atom or Site index. The return value O can be indexed as O[k,q], where $0 ≤ k ≤ 6$ labels an irrep and $q = -k, …, k$. This will produce an $N×N$ matrix of appropriate dimension $N$.
source
Sunny.subcrystal — Method
subcrystal(cryst, types) :: Crystal
Filters sublattices of a Crystal by atom types, keeping the space group unchanged.
subcrystal(cryst, classes) :: Crystal
Filters sublattices of Crystal by equivalence classes, keeping the space group unchanged.
source
Sunny.suggest_magnetic_supercell — Method
suggest_magnetic_supercell(qs, latsize)
Suggests a magnetic supercell, in units of the crystal lattice vectors, that is consistent with periodicity of the wavevectors in qs. An upper bound for the supercell is given by latsize, which is measured in units of lattice vectors, and must be commensurate with the wavevectors.
source
Sunny.symmetry_equivalent_bonds — Method
symmetry_equivalent_bonds(sys::System, bond::Bond)
Given a Bond for the original (unreshaped) crystal, return all symmetry equivalent bonds in the System. Each returned bond is represented as a pair of Sites, which may be used as input to set_exchange_at!. Reverse bonds are not included (no double counting).
Example
for (site1, site2, offset) in symmetry_equivalent_bonds(sys, bond)
     @assert site1 < site2
     set_exchange_at!(sys, J, site1, site2; offset)
-end
source
Sunny.unit_resolution_binning_parameters — Method
unit_resolution_binning_parameters(sc::SampledCorrelations)
Create BinningParameters which place one histogram bin centered at each possible (q,ω) scattering vector of the crystal. This is the finest possible binning without creating bins with zero scattering vectors in them.
This function can be used without reference to a SampledCorrelations using an alternate syntax to manually specify the bin centers for the energy axis and the lattice size:
unit_resolution_binning_parameters(ω_bincenters,latsize,[reciprocal lattice vectors])
The last argument may be a 3x3 matrix specifying the reciprocal lattice vectors, or a Crystal.
Lastly, binning parameters for a single axis may be specifed by their bin centers:
(binstart,binend,binwidth) = unit_resolution_binning_parameters(bincenters::Vector{Float64})
source
Sunny.view_crystal — Method
view_crystal(crystal::Crystal, max_dist::Real)
Create and show crystal viewer in a VSCode or Jupyter notebook environment. The result can also be displayed using browser().
source
Sunny.@mix_proposals — Macro
@mix_proposals weight1 propose1 weight2 propose2 ...
Macro to generate a proposal function that randomly selects among the provided functions according to the provided probability weights. For use with LocalSampler.
Example
# A proposal function that proposes a spin flip 40% of the time, and a
+end
source
Sunny.unit_resolution_binning_parameters — Method
unit_resolution_binning_parameters(sc::SampledCorrelations)
Create BinningParameters which place one histogram bin centered at each possible (q,ω) scattering vector of the crystal. This is the finest possible binning without creating bins with zero scattering vectors in them.
This function can be used without reference to a SampledCorrelations using an alternate syntax to manually specify the bin centers for the energy axis and the lattice size:
unit_resolution_binning_parameters(ω_bincenters,latsize,[reciprocal lattice vectors])
The last argument may be a 3x3 matrix specifying the reciprocal lattice vectors, or a Crystal.
Lastly, binning parameters for a single axis may be specifed by their bin centers:
(binstart,binend,binwidth) = unit_resolution_binning_parameters(bincenters::Vector{Float64})
source
Sunny.view_crystal — Method
view_crystal(crystal::Crystal, max_dist::Real)
Create and show crystal viewer in a VSCode or Jupyter notebook environment. The result can also be displayed using browser().
source
Sunny.@mix_proposals — Macro
@mix_proposals weight1 propose1 weight2 propose2 ...
Macro to generate a proposal function that randomly selects among the provided functions according to the provided probability weights. For use with LocalSampler.
Example
# A proposal function that proposes a spin flip 40% of the time, and a
 # Gaussian perturbation 60% of the time.
-@mix_proposals 0.4 propose_flip 0.6 propose_delta(0.2)
source
Optional Makie extensions
The following will be enabled through a package extension if either GLMakie or WGLMakie is loaded.
Sunny.plot_spins — Function
plot_spins(sys::System; arrowscale=1.0, linecolor=:lightgrey,
+@mix_proposals 0.4 propose_flip 0.6 propose_delta(0.2)
source
Optional Makie extensions
The following will be enabled through a package extension if either GLMakie or WGLMakie is loaded.
Sunny.plot_spins — Function
plot_spins(sys::System; arrowscale=1.0, linecolor=:lightgrey,
            arrowcolor=:red, show_axis=false, show_cell=true,
-           orthographic=false, ghost_radius=0)
Plot the spin configuration defined by sys. Optional parameters include:
  • arrowscale: Scale all arrows by dimensionless factor.
  • show_axis: Show global Cartesian coordinates axis.
  • show_cell: Show original crystallographic unit cell.
  • orthographic: Use camera with orthographic projection.
  • ghost_radius: Show translucent periodic images up to a radius, given as a multiple of the characteristic distance between sites.
source
Optional WriteVTK extensions
The following will be enabled through a package extension if WriteVTK is loaded.
Sunny.export_vtk — Function
export_vtk(filename,params::BinningParameters,data)
Export a VTK-compatible file to filename (do not include file extension when specifying the file name) which contains the data as VTK Cell Data on a grid parameterized by params.
At least one axis of the BinningParameters must be integrated over, since VTK does not support 4D data. See integrate_axes!.
source

+           orthographic=false, ghost_radius=0)

Plot the spin configuration defined by sys. Optional parameters include:

  • arrowscale: Scale all arrows by dimensionless factor.
  • show_axis: Show global Cartesian coordinates axis.
  • show_cell: Show original crystallographic unit cell.
  • orthographic: Use camera with orthographic projection.
  • ghost_radius: Show translucent periodic images up to a radius, given as a multiple of the characteristic distance between sites.
source

Optional WriteVTK extensions

The following will be enabled through a package extension if WriteVTK is loaded.

Sunny.export_vtk — Function
export_vtk(filename,params::BinningParameters,data)

Export a VTK-compatible file to filename (do not include file extension when specifying the file name) which contains the data as VTK Cell Data on a grid parameterized by params.

At least one axis of the BinningParameters must be integrated over, since VTK does not support 4D data. See integrate_axes!.

source
diff --git a/dev/search/index.html b/dev/search/index.html index ad361b997..50807af90 100644 --- a/dev/search/index.html +++ b/dev/search/index.html @@ -1,2 +1,2 @@ -Search · Sunny documentation

Loading search...

    +Search · Sunny documentation

    Loading search...

      diff --git a/dev/structure-factor/index.html b/dev/structure-factor/index.html index a78c6af86..581263aa4 100644 --- a/dev/structure-factor/index.html +++ b/dev/structure-factor/index.html @@ -6,4 +6,4 @@ for _ in 1:nsamples decorrelate_system(sys) # Perform some type of Monte Carlo simulation add_sample!(sc, sys) # Use spins to calculate trajectory and accumulate new sample of 𝒮(𝐪,ω) -end

      The calculation may be configured in a number of ways; see the dynamical_correlations documentation for a list of all keywords.

      Estimating an instantaneous ("static") structure factor: $𝒮(𝐪)$

      Sunny provides two methods for calculating instantaneous, or static, structure factors: $𝒮^{αβ}(𝐪)$. The first involves calculating spatial spin-spin correlations at single time slices. The second involves calculating a dynamic structure factor first and integrating out the $ω$ information. The advantage of the latter approach is that it enables application of an $ω$-dependent classical-to-quantum rescaling of structure factor intensities, a method that should be preferred whenever comparing results to experimental data or spin wave calculations. A disadvantage of this approach is that it is computationally more expensive. There are also many cases when it is not straightforward to calculate a meaningful dynamics, as when working with Ising spins. In this section we will discuss how to calculate instantaneous structure factors from static spin configurations. Information about calculating instantaneous data from a dynamical correlations can be found in the following section.

      The basic usage for the instantaneous case is very similar to the dynamic case, except one calls instant_correlations instead of dynamical_correlations to configure a SampledCorrelations. Note that there are no required keywords as there is no need to specify any dynamics. instant_correlations will return a SampledCorrelations containing no data. Samples may be added by calling add_sample!(sc, sys), where sc is the SampledCorrelations. When performing a finite-temperature calculation, it is important to ensure that the spin configuration in the sys represents a good equilibrium sample, as in the dynamical case. Note, however, that we recommend calculating instantaneous correlations at finite temperature calculations by using full dynamics (i.e., using dynamical_correlations) and then integrating out the energy axis. An approach to doing this is described in the next section.

      Extracting information from sampled correlation data

      The basic function for extracting information from a SampledCorrelations at a particular wave vector, $𝐪$, is intensities_interpolated. It takes a SampledCorrelations, a list of wave vectors, and an intensity_formula. The intensity_formula specifies how to contract and correct correlation data to arrive at a physical intensity. A simple example is formula = intensity_formula(sc, :perp), which will instruct Sunny apply polarization corrections: $\sum_{αβ}(I-q_α q_β) 𝒮^{αβ}(𝐪,ω)$. An intensity at the wave vector $𝐪 = (𝐛_2 + 𝐛_3)/2$ may then be retrieved with intensities_interpolated(sf, [[0.0, 0.5, 0.5]], formula) . intensities_interpolated returns a list of nω elements at each wavevector. The corresponding $ω$ values can be retrieved by calling available_energies on sf.

      Since Sunny only calculates the structure factor on a finite lattice when performing classical simulations, it is important to realize that exact information is only available at a discrete set of wave vectors. Specifically, for each axis index $i$, we will get information at $q_i = \frac{n}{L_i}$, where $n$ runs from $(\frac{-L_i}{2}+1)$ to $\frac{L_i}{2}$ and $L_i$ is the linear dimension of the lattice used for the calculation. If you request a wave vector that does not fall into this set, Sunny will automatically round to the nearest $𝐪$ that is available. If intensities_interpolated is given the keyword argument interpolation=:linear, Sunny will use trilinear interpolation to determine a result at the requested wave vector.

      To retrieve the intensities at all wave vectors for which there is exact data, first call the function available_wave_vectors to generate a list of qs. This takes an optional keyword argument bzsize, which must be given a tuple of three integers specifying the number of Brillouin zones to calculate, e.g., bzsize=(2,2,2). The resulting list of wave vectors may then be passed to intensities_interpolated.

      Alternatively, intensities_binned can be used to place the exact data into histogram bins for comparison with experiment.

      The convenience function reciprocal_space_path returns a list of wavevectors sampled along a path that connects specified $𝐪$ points. This list can be used as an input to intensities. Another convenience method, reciprocal_space_shell will generate points on a sphere of a given radius. This is useful for powder averaging.

      A number of arguments for intensity_formula are available which modify the calculation of structure factor intensity. It is generally recommended to provide a value of kT corresponding to the temperature of sampled configurations. Given kT, Sunny will include an energy- and temperature-dependent classical-to-quantum rescaling of intensities in the formula.

      To retrieve intensity data from a instantaneous structure factor, use instant_intensities_interpolated, which accepts similar arguments to intensities_interpolated. This function may also be used to calculate instantaneous information from a dynamical correlation data, i.e. from a SampledCorrelations created with dynamical_correlations. Note that it is important to supply a value to kT to reap the benefits of this approach over simply calculating a static structure factor at the outset.

      +end

      The calculation may be configured in a number of ways; see the dynamical_correlations documentation for a list of all keywords.

      Estimating an instantaneous ("static") structure factor: $𝒮(𝐪)$

      Sunny provides two methods for calculating instantaneous, or static, structure factors: $𝒮^{αβ}(𝐪)$. The first involves calculating spatial spin-spin correlations at single time slices. The second involves calculating a dynamic structure factor first and integrating out the $ω$ information. The advantage of the latter approach is that it enables application of an $ω$-dependent classical-to-quantum rescaling of structure factor intensities, a method that should be preferred whenever comparing results to experimental data or spin wave calculations. A disadvantage of this approach is that it is computationally more expensive. There are also many cases when it is not straightforward to calculate a meaningful dynamics, as when working with Ising spins. In this section we will discuss how to calculate instantaneous structure factors from static spin configurations. Information about calculating instantaneous data from a dynamical correlations can be found in the following section.

      The basic usage for the instantaneous case is very similar to the dynamic case, except one calls instant_correlations instead of dynamical_correlations to configure a SampledCorrelations. Note that there are no required keywords as there is no need to specify any dynamics. instant_correlations will return a SampledCorrelations containing no data. Samples may be added by calling add_sample!(sc, sys), where sc is the SampledCorrelations. When performing a finite-temperature calculation, it is important to ensure that the spin configuration in the sys represents a good equilibrium sample, as in the dynamical case. Note, however, that we recommend calculating instantaneous correlations at finite temperature calculations by using full dynamics (i.e., using dynamical_correlations) and then integrating out the energy axis. An approach to doing this is described in the next section.

      Extracting information from sampled correlation data

      The basic function for extracting information from a SampledCorrelations at a particular wave vector, $𝐪$, is intensities_interpolated. It takes a SampledCorrelations, a list of wave vectors, and an intensity_formula. The intensity_formula specifies how to contract and correct correlation data to arrive at a physical intensity. A simple example is formula = intensity_formula(sc, :perp), which will instruct Sunny apply polarization corrections: $\sum_{αβ}(I-q_α q_β) 𝒮^{αβ}(𝐪,ω)$. An intensity at the wave vector $𝐪 = (𝐛_2 + 𝐛_3)/2$ may then be retrieved with intensities_interpolated(sf, [[0.0, 0.5, 0.5]], formula) . intensities_interpolated returns a list of nω elements at each wavevector. The corresponding $ω$ values can be retrieved by calling available_energies on sf.

      Since Sunny only calculates the structure factor on a finite lattice when performing classical simulations, it is important to realize that exact information is only available at a discrete set of wave vectors. Specifically, for each axis index $i$, we will get information at $q_i = \frac{n}{L_i}$, where $n$ runs from $(\frac{-L_i}{2}+1)$ to $\frac{L_i}{2}$ and $L_i$ is the linear dimension of the lattice used for the calculation. If you request a wave vector that does not fall into this set, Sunny will automatically round to the nearest $𝐪$ that is available. If intensities_interpolated is given the keyword argument interpolation=:linear, Sunny will use trilinear interpolation to determine a result at the requested wave vector.

      To retrieve the intensities at all wave vectors for which there is exact data, first call the function available_wave_vectors to generate a list of qs. This takes an optional keyword argument bzsize, which must be given a tuple of three integers specifying the number of Brillouin zones to calculate, e.g., bzsize=(2,2,2). The resulting list of wave vectors may then be passed to intensities_interpolated.

      Alternatively, intensities_binned can be used to place the exact data into histogram bins for comparison with experiment.

      The convenience function reciprocal_space_path returns a list of wavevectors sampled along a path that connects specified $𝐪$ points. This list can be used as an input to intensities. Another convenience method, reciprocal_space_shell will generate points on a sphere of a given radius. This is useful for powder averaging.

      A number of arguments for intensity_formula are available which modify the calculation of structure factor intensity. It is generally recommended to provide a value of kT corresponding to the temperature of sampled configurations. Given kT, Sunny will include an energy- and temperature-dependent classical-to-quantum rescaling of intensities in the formula.

      To retrieve intensity data from a instantaneous structure factor, use instant_intensities_interpolated, which accepts similar arguments to intensities_interpolated. This function may also be used to calculate instantaneous information from a dynamical correlation data, i.e. from a SampledCorrelations created with dynamical_correlations. Note that it is important to supply a value to kT to reap the benefits of this approach over simply calculating a static structure factor at the outset.

      diff --git a/dev/versions/index.html b/dev/versions/index.html index 9148304b1..b1cac3975 100644 --- a/dev/versions/index.html +++ b/dev/versions/index.html @@ -1,2 +1,2 @@ -Version History · Sunny documentation
      Edit on GitHub

      Version 0.5.0

      New features.

      Support for Linear Spin Wave Theory in :dipole and :SUN modes. (Thanks Hao Zhang!)

      New function minimize_energy! to efficiently find an optimal configuration of spin dipoles or SU(N) coherent states.

      Major refactors and enhancements to intensity calculations. This new interface allows unification between LSWT and classical spin dynamics calculations. This interface allows: Custom observables as local quantum operators, better support for linebroadening, and automatic binning to facilitate comparison with experimental data. See intensity_formula for documentation. Use load_nxs to load experimental neutron scattering data.

      Breaking changes.

      Require Julia 1.9.

      Replace set_anisotropy! with a new function set_onsite_coupling! (and similarly set_onsite_coupling_at!). The latter expects an explicit matrix representation for the local Hamiltonian. This can be constructed, e.g., as a linear combination of stevens_operators, or as a polynomial of spin_operators. To understand the mapping between these two, the new function print_stevens_expansion acts on an arbitrary local operator.

      Remove set_biquadratic!. Instead, use an optional keyword argument biquad to set_exchange!.

      Rename DynamicStructureFactor to dynamical_correlations. Similarly, replace InstantStructureFactor with instant_correlations. The return type has been renamed SampledCorrelations to emphasize that the object may be holding thermodynamic samples, which are collected using add_sample!.

      Remove intensities function. Instead, use one of intensities_interpolated or intensities_binned. These will require an intensity_formula, which defines a calculator (e.g., LSWT).

      Rename connected_path to reciprocal_space_path, which now returns an xticks object that can be used in plotting. Replace spherical_shell with reciprocal_space_shell that functions similarly.

      Rename polarize_spin! to set_dipole! for consistency with set_coherent!. The behavior of the former function is unchanged: the spin at a given site will still be polarized along the provided direction.

      Rename all_sites to eachsite consistent with Julia convention for iterators.

      Rename reshape_geometry to reshape_supercell, which is the fundamental reshaping function. Rename resize_periodically to resize_supercell.

      The constructor SpinInfo now requires a $g$-factor or tensor as a named argument.

      The constructor FormFactor no longer accepts an atom index. Instead, the form factors are associated with site-symmetry classes in order of appearance.

      Version 0.4.3

      Experimental support for linear SpinWaveTheory, implemented in SU(N) mode. This module may evolve rapidly.

      Implement renormalization of single-ion anisotropy and biquadratic interactions when in :dipole mode. This makes the model more faithful to the quantum mechanical Hamiltonian, but is also a breaking change.

      Various improvements and bugfixes for to_inhomogeneous. Setting inhomogeneous interactions via set_exchange_at! should now infer the correct bond offset direction, or will report an ambiguity error. Ambiguities can be resolved by passing an explicit offset.

      The function remove_periodicity! disables periodicity along specified dimensions.

      Rename StaticStructureFactor to InstantStructureFactor.

      Version 0.4.2

      Introduce LocalSampler, a framework for MCMC sampling with local spin updates.

      Rename print_dominant_wavevectors to print_wrapped_intensities to reduce confusion with the physical instantaneous intensities.

      The function spherical_shell now takes a radius in physical units of inverse Å.

      New exported functions global_position, magnetic_moment, all_sites.

      Remove all uses of Base.deepcopy which resolves crashes.

      Version 0.4.1

      The function to_inhomogeneous creates a system that supports inhomogeneous interactions, which can be set using set_exchange_at!, etc.

      set_biquadratic! replaces set_exchange_with_biquadratic!.

      Version 0.4.0

      This update includes many breaking changes, and is missing some features of 0.3.0.

      Creating a spin System

      Rename SpinSystem to System. Its constructor now has the form,

      System(crystal, latsize, infos, mode)

      The parameter infos is now a list of SpinInfo objects. Each defines spin angular momentum $S = \frac{1}{2}, 1, \frac{3}{2}, …$, and an optional $g$-factor or tensor.

      The parameter mode is one of :SUN or :dipole.

      Setting interactions

      Interactions are now added mutably to an existing System using the following functions: set_external_field!, set_exchange!, set_onsite_coupling!, enable_dipole_dipole!.

      As a convenience, one can use dmvec(D) to convert a DM vector to a $3×3$ antisymmetric exchange matrix.

      Fully general single-ion anisotropy is now possible. The function set_onsite_coupling! expects the single ion anisotropy to be expressed as a polynomial in symbolic spin operators 𝒮, or as a linear combination of symbolic Stevens operators 𝒪. For example, an easy axis anisotropy in the direction n may be written D*(𝒮⋅n)^2.

      Stevens operators 𝒪[k,q] admit polynomial expression in spin operators 𝒮[α]. Conversely, a polynomial of spin operators can be expressed as a linear combination of Stevens operators. To see this expansion use print_anisotropy_as_stevens.

      Inhomogeneous field

      An external field can be applied to a single site with set_external_field_at!.

      Structure factor rewrite

      The calculation of structure factors has been completely rewritten. For the new interface, see the Structure Factor Calculations page.

      Various

      • The "Sampler" interface is in flux. Langevin replaces both LangevinHeunP and LangevinSampler. Local spin-flip Monte Carlo sampling methods are temporarily broken.

      • repeat_periodically replaces extend_periodically.

      Additional related functions include resize_periodically and reshape_geometry, the latter being fundamental.

      The new function includes the list of symmetry-allowed single ion anisotropies in addition to exchange interactions.

      • When reading CIF files, the field _atom_site_label is now used in place of the field _atom_site_type_symbol.

      This is required for correctness. The field _atom_site_label is guaranteed to be present, and is guaranteed to be a distinct label for each symmetry-inequivalent site. Code that explicitly referred to site labels (e.g. in calls to subcrystal) will need to be updated to use the new label.

      +Version History · Sunny documentation
      Edit on GitHub

      Version 0.5.0

      New features.

      Support for Linear Spin Wave Theory in :dipole and :SUN modes. (Thanks Hao Zhang!)

      New function minimize_energy! to efficiently find an optimal configuration of spin dipoles or SU(N) coherent states.

      Major refactors and enhancements to intensity calculations. This new interface allows unification between LSWT and classical spin dynamics calculations. This interface allows: Custom observables as local quantum operators, better support for linebroadening, and automatic binning to facilitate comparison with experimental data. See intensity_formula for documentation. Use load_nxs to load experimental neutron scattering data.

      Breaking changes.

      Require Julia 1.9.

      Replace set_anisotropy! with a new function set_onsite_coupling! (and similarly set_onsite_coupling_at!). The latter expects an explicit matrix representation for the local Hamiltonian. This can be constructed, e.g., as a linear combination of stevens_operators, or as a polynomial of spin_operators. To understand the mapping between these two, the new function print_stevens_expansion acts on an arbitrary local operator.

      Remove set_biquadratic!. Instead, use an optional keyword argument biquad to set_exchange!.

      Rename DynamicStructureFactor to dynamical_correlations. Similarly, replace InstantStructureFactor with instant_correlations. The return type has been renamed SampledCorrelations to emphasize that the object may be holding thermodynamic samples, which are collected using add_sample!.

      Remove intensities function. Instead, use one of intensities_interpolated or intensities_binned. These will require an intensity_formula, which defines a calculator (e.g., LSWT).

      Rename connected_path to reciprocal_space_path, which now returns an xticks object that can be used in plotting. Replace spherical_shell with reciprocal_space_shell that functions similarly.

      Rename polarize_spin! to set_dipole! for consistency with set_coherent!. The behavior of the former function is unchanged: the spin at a given site will still be polarized along the provided direction.

      Rename all_sites to eachsite consistent with Julia convention for iterators.

      Rename reshape_geometry to reshape_supercell, which is the fundamental reshaping function. Rename resize_periodically to resize_supercell.

      The constructor SpinInfo now requires a $g$-factor or tensor as a named argument.

      The constructor FormFactor no longer accepts an atom index. Instead, the form factors are associated with site-symmetry classes in order of appearance.

      Version 0.4.3

      Experimental support for linear SpinWaveTheory, implemented in SU(N) mode. This module may evolve rapidly.

      Implement renormalization of single-ion anisotropy and biquadratic interactions when in :dipole mode. This makes the model more faithful to the quantum mechanical Hamiltonian, but is also a breaking change.

      Various improvements and bugfixes for to_inhomogeneous. Setting inhomogeneous interactions via set_exchange_at! should now infer the correct bond offset direction, or will report an ambiguity error. Ambiguities can be resolved by passing an explicit offset.

      The function remove_periodicity! disables periodicity along specified dimensions.

      Rename StaticStructureFactor to InstantStructureFactor.

      Version 0.4.2

      Introduce LocalSampler, a framework for MCMC sampling with local spin updates.

      Rename print_dominant_wavevectors to print_wrapped_intensities to reduce confusion with the physical instantaneous intensities.

      The function spherical_shell now takes a radius in physical units of inverse Å.

      New exported functions global_position, magnetic_moment, all_sites.

      Remove all uses of Base.deepcopy which resolves crashes.

      Version 0.4.1

      The function to_inhomogeneous creates a system that supports inhomogeneous interactions, which can be set using set_exchange_at!, etc.

      set_biquadratic! replaces set_exchange_with_biquadratic!.

      Version 0.4.0

      This update includes many breaking changes, and is missing some features of 0.3.0.

      Creating a spin System

      Rename SpinSystem to System. Its constructor now has the form,

      System(crystal, latsize, infos, mode)

      The parameter infos is now a list of SpinInfo objects. Each defines spin angular momentum $S = \frac{1}{2}, 1, \frac{3}{2}, …$, and an optional $g$-factor or tensor.

      The parameter mode is one of :SUN or :dipole.

      Setting interactions

      Interactions are now added mutably to an existing System using the following functions: set_external_field!, set_exchange!, set_onsite_coupling!, enable_dipole_dipole!.

      As a convenience, one can use dmvec(D) to convert a DM vector to a $3×3$ antisymmetric exchange matrix.

      Fully general single-ion anisotropy is now possible. The function set_onsite_coupling! expects the single ion anisotropy to be expressed as a polynomial in symbolic spin operators 𝒮, or as a linear combination of symbolic Stevens operators 𝒪. For example, an easy axis anisotropy in the direction n may be written D*(𝒮⋅n)^2.

      Stevens operators 𝒪[k,q] admit polynomial expression in spin operators 𝒮[α]. Conversely, a polynomial of spin operators can be expressed as a linear combination of Stevens operators. To see this expansion use print_anisotropy_as_stevens.

      Inhomogeneous field

      An external field can be applied to a single site with set_external_field_at!.

      Structure factor rewrite

      The calculation of structure factors has been completely rewritten. For the new interface, see the Structure Factor Calculations page.

      Various

      • The "Sampler" interface is in flux. Langevin replaces both LangevinHeunP and LangevinSampler. Local spin-flip Monte Carlo sampling methods are temporarily broken.

      • repeat_periodically replaces extend_periodically.

      Additional related functions include resize_periodically and reshape_geometry, the latter being fundamental.

      The new function includes the list of symmetry-allowed single ion anisotropies in addition to exchange interactions.

      • When reading CIF files, the field _atom_site_label is now used in place of the field _atom_site_type_symbol.

      This is required for correctness. The field _atom_site_label is guaranteed to be present, and is guaranteed to be a distinct label for each symmetry-inequivalent site. Code that explicitly referred to site labels (e.g. in calls to subcrystal) will need to be updated to use the new label.

      diff --git a/dev/writevtk/index.html b/dev/writevtk/index.html index b027c313a..2fd887a0a 100644 --- a/dev/writevtk/index.html +++ b/dev/writevtk/index.html @@ -61,4 +61,4 @@ signal = sum(signal; dims = 4) # Export to ParaView -export_vtk("experiment_data_as_vtk", params, signal) +export_vtk("experiment_data_as_vtk", params, signal)