SpinW

https://github.com/spinw/spinw
Admin
SpinW is a Matlab library that can optimize magnetic structures using mean field theory and...
Tokens:161,788
Snippets:1,149
Trust Score:5.8
License:GPL-3.0
Update:9 months ago
Show doc for...
Tokens:
Raw
### SpinW Help and Utility Functions (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

This section demonstrates how to get help on SpinW functions, locate the SpinW installation directory, open function files in the editor, view object properties, edit data files, and manage preferences. It covers functions like 'help', 'sw_rootdir', 'edit', 'swpref.getpref'.

```MATLAB
help swfiles

% To find the location of the spinw library use
sw_rootdir

% To open any of the functions in the Matlab editor, use
edit spinw.plot

% To look at any of the spinw object properties, double click on the
% "Workspace" view on the name of the object. Also the data files
% (symmetry.dat, atom.dat, color.dat, magion.dat) can be easily edited,
% for example

edit symmetry.dat

% Some settings are ekpt during the active Matlab session, these can be
% set/get using the swpref.setpref and swpref.getpref commands. To change
% the default values, it can be defined in the startup.m file. To get all
% current value use

swpref.getpref
```

--------------------------------

### Install pySpinW Package

Source: https://github.com/spinw/spinw/blob/master/python/README.md

Installs the pySpinW package from a local wheel file. This command is intended for a bash or command-line environment. Ensure you have the correct wheel file name.

```bash
pip install pyspinw*.whl
```

--------------------------------

### Getting Help on SpinW Functions (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.html

This snippet demonstrates how to access help for SpinW functions. It covers general help, functions starting with 'sw_', methods of the 'spinw' class, and plotting commands. It also shows how to find the SpinW library root directory and edit SpinW function files.

```matlab
help swfiles

% To find the location of the spinw library use
sw_rootdir

% To open any of the functions in the Matlab editor, use
edit spinw.plot

% To look at any of the spinw object properties, double click on the
% "Workspace" view on the name of the object. Also the data files
% (symmetry.dat, atom.dat, color.dat, magion.dat) can be easily edited, for
% example

edit symmetry.dat

% Some settings are ekpt during the active Matlab session, these can be
% set/get using the swpref.setpref and swpref.getpref commands. To change
% the default values, it can be defined in the startup.m file. To get all
% current value use

swpref.getpref
```

--------------------------------

### Get Help for SpinW Functions in Matlab

Source: https://github.com/spinw/spinw/blob/master/docs/source/02_introduction.md

Demonstrates how to access documentation for specific SpinW functions. 'swdoc' displays the documentation in a separate window, while 'swhelp' shows the help text directly in the Matlab Command Window.

```matlab
swdoc funName
```

```matlab
swhelp funName
```

--------------------------------

### Get SpinW Version

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Returns the currently installed version of the SpinW software. This is useful for checking compatibility or reporting issues.

```matlab
sw_version
```

--------------------------------

### Mirror Plane Including Bond Example

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial32/tutorial32.html

This example illustrates a scenario where the mirror plane includes the bond. It involves generating a lattice, adding atoms, and then drawing a mirror plane using the swplot.plot function. Finally, it uses quickham and plotting functions, along with matrix retrieval.

```matlab
model = spinw;
model.genlattice('lat_const',[4 6 4],'sym','-x,y,z','label','m_x')
model.addatom('r',[1/2 3/8 1/2],'S',1)
model.addatom('r',[1/2 5/8 1/2],'S',1)
plot(model)

% Lets draw mirror plane.
Rlu = permute([1/2 0 0;1/2 1 0;1/2 1 1;1/2 0 1],[2 3 1]);
swplot.plot('type','polyhedron','position',cat(3,Rlu),'color','pink',
    'alpha',0.5,'replace',true)

model.quickham(1)
plot(model)
model.getmatrix('mat','J1');

R = sw_rotmatd([0.5 1 0],45);
swplot.transform(R)
swplot.translate
```

--------------------------------

### Get SpinW Installation Path

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Retrieves the root directory path of the SpinW installation. This is useful for locating library files or configuration.

```matlab
sw_rootdir
```

--------------------------------

### Generate Antiferromagnetic Chain - Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial29/tutorial29.html

This code snippet initializes a Spinw object, generates a 3D lattice, adds two atoms with spins, defines an anisotropy matrix and an exchange interaction, and then optimizes the magnetic structure. It's a foundational step for simulating magnetic properties.

```matlab
afc = sw;
afc.genlattice('lat_const',[4 4 6])
afc.addatom('r', [ 0 0 0],'S',1)
afc.addatom('r', [1/2 0 0],'S',1)
afc.addmatrix('label','A','value',diag([0 0 -0.1]))
afc.addmatrix('label','J','value',1)
afc.gencoupling
afc.addcoupling('J',1)
afc.addaniso('A')
afc.optmagsteep;
plot(afc)
```

--------------------------------

### Initialize Powder Fitting Class and Plot Data (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Initializes the `sw_fitpowder` class for fitting spinwave models to powder diffraction data. It requires a spinw model, the experimental data (in xye format), a fitting function to update model parameters, and initial guesses for these parameters. Optional arguments include specifying background subtraction strategies and enabling caching for performance. The initial guess is plotted to inspect the starting point of the fit.

```matlab
fit_func =  @(obj, p) matparser(obj, 'param', p, 'mat', {'J_1'}, 'init', true);
J1 = 0.85;

fitpow = sw_fitpowder(tri, data,  fit_func, [J1]);
fitpow.set_caching(true);
```

--------------------------------

### Configure and Plot Power Spectrum Data in Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Configures parameters for power spectrum calculation and instrument setup, crops the data, estimates background and scale factor, and plots the results. This involves setting arguments like dE, fastmode, nRand, and instrument parameters like dQ and Ei. The data is then cropped by energy and q-ranges before background and scale factor estimation and final plotting.

```matlab
fitpow.powspec_args.dE = eres;
fitpow.powspec_args.fastmode = true;
fitpow.powspec_args.neutron_output = true;
fitpow.powspec_args.nRand = 2e2;
fitpow.powspec_args.hermit = true;
fitpow.sw_instrument_args = struct('dQ', dQ, 'ThetaMin', 3.5, 'Ei', Ei);
fitpow.crop_energy_range(1.5*eres(0), inf);
fitpow.crop_q_range(0.25, 3);
fitpow.powspec_args.dE = eres;
fitpow.powspec_args.fastmode = true;
fitpow.powspec_args.neutron_output = true;
fitpow.estimate_constant_background();
fitpow.estimate_scale_factor();
fitpow.plot_result(fitpow.params, 'EdgeAlpha', 0.9, 'LineWidth', 1 ,'EdgeColor', 'k');
```

--------------------------------

### Add and Plot DM Components

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial32/tutorial32.html

This example demonstrates how to add two Dzyaloshinskii-Moriya (DM) vectors to a SpinW model and visualize them. The vectors are added as matrices with specified colors and coupled to a bond. The plot function visualizes the model with adjusted bond scaling.

```matlab
model.addmatrix('label','DM1','value',[0 1 0],'color','blue')
model.addmatrix('label','DM2','value',[0 0 1],'color','purple')
model.addcoupling('mat','DM1','bond',1)
model.addcoupling('mat','DM2','bond',1)
plot(model,'bondScale',1)
```

--------------------------------

### Initialize and Plot Magnetic Lattice - MATLAB

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial3/tutorial3.txt

Initializes a spinw object for a frustrated J1-J2 antiferromagnetic chain with specified lattice constants and magnetic atom properties. It then displays the magnetic lattice information and plots it.

```matlab
%% Frustrated J1-J2 AFM chain
% Crystal structure, shortest bond along a-axis, Cu+ magnetic atoms with
% S=1 spin.

J1J2chain = spinw; 
J1J2chain.genlattice('lat_const',[3 8 10],'angled',[90 90 90],'spgr',0);
J1J2chain.addatom('r',[0 0 0],'S',1,'label','Cu1','color','blue');
disp('Magnetic lattice:')
J1J2chain.table('atom')
plot(J1J2chain,'range',[3 1 1],'zoom',0.5)
```

--------------------------------

### Initialize MATLAB Interface in Python

Source: https://github.com/spinw/spinw/blob/master/python/README.md

Initializes the MATLAB interface within Python for pySpinW. This requires a compatible MATLAB or MCR installation. If MATLAB is not in a standard location, you must provide the specific path and version.

```python
from pyspinw import Matlab

m = Matlab(matlab_version='R2023a', matlab_path='/usr/local/MATLAB/R2023a/')
```

```python
from pyspinw import Matlab

m = Matlab()
```

--------------------------------

### Calculate and Plot Spin Wave Dispersion with SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial8/tutorial8.txt

Calculates and plots the spin wave dispersion for a given magnetic structure. This example focuses on plotting the real and imaginary parts of the dispersion for specific modes. It utilizes `spinwave`, `sw_egrid`, and `sw_plotspec` functions. Dependencies: spinw library, MATLAB.

```matlab
kag33Spec = AF33kagome.spinwave({[-1/2 0 0] [0 0 0] [1/2 1/2 0] 250},'hermit',false);
kag33Spec = sw_egrid(kag33Spec,'component','Sxx+Syy+Szz');
figure
subplot(2,1,1)
sw_plotspec(kag33Spec,'mode',1,'axLim',[0 2.5],'colorbar',false', ...
    'colormap',[0 0 0],'imag',true,'sortMode',true,'dashed',true)
subplot(2,1,2)
sw_plotspec(kag33Spec,'mode',3,'dE',0.05,'axLim',[0 2.5],'dashed',true)
colorbar off
legend off
swplot.subfigure(1,3,1)
```

--------------------------------

### DM Interaction with P4 Space Group

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial32/tutorial32.html

This example demonstrates Dzyaloshinskii-Moriya (DM) interaction using the P4 space group. It involves generating a lattice with P4 symmetry, adding an atom, generating couplings, adding a DM matrix, and coupling it to a bond. The output is visualized with specific viewing settings.

```matlab
cryst=spinw;
cryst.genlattice('sym','P 4','lat_const',[8 8 6])
cryst.addatom('r',[1/4 1/4 0],'S',1);
cryst.gencoupling;
cryst.addmatrix('label','D','value',[0 -1 0])
cryst.addcoupling('mat','D','bond',2)

swplot.clear
plot(cryst,'range',[1 1 1/2])
swplot.view('c')
```

--------------------------------

### Optimize Magnetic Structure Parameters - MATLAB

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial3/tutorial3.txt

This code optimizes the magnetic structure parameters for the J1J2chain model. It defines the search range for parameters and uses the `optmagstr` function to find the ground state energy and corresponding magnetic structure. The results are then displayed. Dependencies include the spinw package and the `gm_planar` function.

```matlab
x1 = [0      0   0   0      0    0];
x2 = [0    1/2   0   0      0    0];
optRes = J1J2chain.optmagstr('func',@gm_planar,'xmin',x1,'xmax',x2,'nRun',10);
disp('Ground state energy after optimization')
J1J2chain.energy
disp('Optimized magnetic structure:')
J1J2chain.table('mag')

plot(J1J2chain,'range',[3 0.9 0.9],'bondMode','line','bondLineWidth0',3)
```

--------------------------------

### Single Ion Anisotropy with No Space Group

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial32/tutorial32.html

This example illustrates single-ion anisotropy when no space group symmetry is applied. This results in a different Hamiltonian compared to when symmetry is present. It involves generating a lattice without symmetry, adding multiple atoms, generating couplings, defining an anisotropy matrix, and adding the anisotropy.

```matlab
cryst=spinw;
cryst.genlattice('lat_const',[8 8 6])
cryst.addatom('r',[1/4 1/4 0],'S',1)
cryst.addatom('r',[3/4 1/4 0],'S',1)
cryst.addatom('r',[1/4 3/4 0],'S',1)
cryst.addatom('r',[3/4 3/4 0],'S',1)
cryst.gencoupling
cryst.addmatrix('label','A','value',1-eye(3))
cryst.addaniso('A')

plot(cryst,'atomLegend',false)
```

--------------------------------

### SpinW: FCC Lattice Generation and Interaction Setup

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial28/tutorial28.txt

Initializes a spinw object for an FCC lattice, adds atomic sites with spin values, and defines magnetic exchange interactions (J1, J2) and biquadratic coupling (B). It then sets up a helical magnetic structure with a specified wavevector. The resulting lattice structure and magnetic configuration are plotted.

```matlab
fcc = spinw;
fcc.genlattice('lat_const',[8 8 8])
fcc.addatom('r',[0   0   0],'S',S)
fcc.addatom('r',[1/2 1/2 0],'S',S)
fcc.addatom('r',[1/2 0 1/2],'S',S)
fcc.addatom('r',[0 1/2 1/2],'S',S)

fcc.gencoupling
fcc.addmatrix('label','J1','value',J1)
fcc.addmatrix('label','J2','value',J2,'color','g')

fcc.addmatrix('label','B','value',-0.5*Q/S^3*2)

fcc.addcoupling('mat','J1','bond',1)
fcc.addcoupling('mat','J2','bond',2)
fcc.addcoupling('mat','B','bond',1,'type','biquadratic')


fcc.genmagstr('mode','helical','S',[1 -1 -1 -1;1 -1 -1 -1;zeros(1,4)],'k',[1/2 1/2 1/2],'next',[2 2 2],'n',[0 0 1]);

plot(fcc)

```

--------------------------------

### Initialize and Configure Powder Fitting (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Initializes the sw_fitpowder class with a spinw model, simulated data, a fitting function, and initial guess parameters. It also configures simulation arguments for powspec and sw_instrument, and crops the energy range.

```matlab
fit_func =  @(obj, p) matparser(obj, 'param', p, 'mat', {'J_1'}, 'init', true);
J1 = 0.85;

fitpow = sw_fitpowder(tri, data,  fit_func, [J1]);
fitpow.set_caching(true); % will store last calculated spectra

% set parameters passed to powspec
fitpow.powspec_args.dE = eres; % emergy resolution
fitpow.powspec_args.fastmode = true;
fitpow.powspec_args.neutron_output = true;
fitpow.powspec_args.nRand = 2e2; % low for speed (typically want > 1e3)
fitpow.powspec_args.hermit = true;
% set parameters passsed to sw_instrument
fitpow.sw_instrument_args = struct('dQ', dQ, 'ThetaMin', 3.5, 'Ei', Ei);

% crop data
fitpow.crop_energy_range(1.5*eres(0), inf); % typically want to avoid elastic line
```

--------------------------------

### Update SpinW Installation

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Updates the SpinW installation from the internet. This function allows users to easily get the latest version and bug fixes.

```matlab
sw_update
```

--------------------------------

### Fit Experimental Data with Spinw using Simplex Optimizer

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Sets the cost function to 'Rsq' and the optimizer to ndbase.simplex. It then configures background fitting by fixing initial slope parameters, setting bounds for the constant background, fitting the background, and fixing the fitted constant background. Model parameters are bounded, and the fit is performed. Finally, the results are plotted as a 2D colorfill and 1D cuts.

```matlab
fitpow.cost_function = "Rsq";
fitpow.optimizer = @ndbase.simplex;
fitpow.fix_bg_parameters(1:2);
fitpow.set_bg_parameter_bounds(3, 0.0, [])
fitpow.fit_background();
fitpow.fix_bg_parameters(3);
fitpow.set_model_parameter_bounds(1, 0, [])
[pfit, cost_val, stat] = fitpow.fit();
fitpow.plot_result(pfit, 10,  'EdgeAlpha', 0.9, 'LineWidth', 1 ,'EdgeColor', 'k')
qcens = [0.8:0.4:1.6];
dq = 0.05;
fitpow.plot_1d_cuts_of_2d_data(qcens-dq, qcens+dq, pfit)
```

--------------------------------

### Generate Spiral Magnetic Structure with J1-J2 Model (SpinW)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial31/tutorial31.html

This example shows how to generate a spiral magnetic structure for a zig-zag chain using the J1-J2 model. It involves setting up the lattice, adding atoms, defining interactions with `quickham`, optimizing the magnetic structure using `optmagk` and `optmagsteep`, and plotting the result. The ground state energy is also calculated.

```matlab
ch = spinw;
ch.genlattice('lat_const',[3 5 4])
ch.addatom('r',[0 .3 0],'S',1)
ch.addatom('r',[1/2 0.7 0],'S',1)
ch.quickham([1 1/2])

ch.optmagk
ch.optmagsteep
ch.energy

plot(ch,'range',[5 1 1/2])
```

--------------------------------

### Accessing SpinW Function Help

Source: https://github.com/spinw/spinw/blob/master/tutorials/help/Swclass/gen_Swclass.html

Illustrates how to access help documentation for SpinW class methods using the 'help' and 'doc' commands in MATLAB. It emphasizes using the fully qualified function name (e.g., sw.genlattice) to differentiate from standard MATLAB functions.

```matlab
help sw.genlattice
doc sw.genlattice
help sw.plot
```

--------------------------------

### Background Parameter Manipulation (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Demonstrates manipulating background parameters within the sw_fitpowder class. This includes fixing slopes, setting bounds for constant background, estimating, fitting, and fixing the constant background value.

```matlab
fitpow.fix_bg_parameters(1); % fix slopes to initial value (0) for all cuts
% e.g. fitpow.fix_bg_parameters(1, 2) would fix the bg slope of the second cut
fitpow.set_bg_parameter_bounds(2, 0.0, []) % Set lb of constant bg = 0
% fit background
fitpow.estimate_constant_background();
fitpow.fit_background();
fitpow.fix_bg_parameters(2); % fix fitted constant bg
```

--------------------------------

### Horace Plotting: Spin Wave Spectra with Energy Resolution

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial12/tutorial12.txt

Plots convoluted spin wave spectra using the Horace package. It calculates the spectrum in the (H,K,0) plane, applies a constant energy cut, and simulates finite energy resolution by convolving with a Gaussian function. Assumes Horace is installed and setup.

```matlab
dE = 0.15;
horaceObj = d3d(tri.abc,[1 0 0 0],[0,0.005,1],[0 1 0 0],[0,0.005,1],[0 0 0 1],[0,0.1,10]);
horaceObj = disp2sqw_eval(horaceObj,@tri.horace,{'component','Sperp'},dE,'-all');
cut1 = cut(horaceObj,[],[],[3.0 3.5]);
plot(cut1)
colorslider('delete')
colormap(flipud(cm_inferno))
colorbar
```

--------------------------------

### Get Fibonacci Numbers in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Returns the last two Fibonacci numbers that are less than or equal to a given input. This is a mathematical utility function.

```matlab
sw_fibo
```

--------------------------------

### Generate Kagome Lattice and Add Magnetic Atoms (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial8/tutorial8.txt

This snippet demonstrates how to create a Kagome lattice with specific lattice constants and angles, and then add magnetic atoms with a given spin value. It utilizes the genlattice and addatom functions from the spinw package. The plot function visualizes the generated lattice.

```MATLAB
AF33kagome = spinw;
AF33kagome.genlattice('lat_const',[6 6 40],'angled',[90 90 120],'spgr','P -3')
AF33kagome.addatom('r',[1/2 0 0],'S', 1,'label','MCu1','color','r')
plot(AF33kagome,'range',[2 2 1/2],'cellMode','inside')
```

--------------------------------

### Get Free RAM in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Returns the amount of available free RAM in bytes. This function can be used for monitoring system resources during complex calculations.

```matlab
sw_freemem
```

--------------------------------

### Generate Antiferromagnetic Chain in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial22/tutorial22.txt

Initializes a spin system, defines the lattice structure, adds magnetic atoms with spin values, and sets up exchange interactions and anisotropy. It then visualizes the initial magnetic configuration.

```matlab
afc = spinw;
afc.genlattice('lat_const',[3 4 4])
afc.addatom('r',[  0 0 0],'S',1)
afc.addmatrix('label','A','value',diag([0 0 0.1]))
afc.addmatrix('label','J1','value',1)
afc.addmatrix('label','J2-','value',1/3,'color','orange')
afc.gencoupling
afc.addcoupling('J1',1)
afc.addcoupling('J2-',5)
afc.addaniso('A')
%afc.optmagsteep;
plot(afc,'range',[2 1 1])
```

--------------------------------

### Basic Symmetry Analysis with SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial32/tutorial32.html

Initializes a SpinW model, generates a lattice with a mirror plane symmetry, adds an atom, and plots the structure. It then defines and adds a Dzyaloshinskii-Moriya (DM) interaction and visualizes it.

```matlab
model = spinw;
model.genlattice('lat_const',[6 4 4],'sym','-x,y,z','label','m_x')
model.addatom('r',[3/8 1/2 1/2],'S',1)
plot(model)

% draw mirror plane
Rlu = permute([1/2 0 0;1/2 1 0;1/2 1 1;1/2 0 1],[2 3 1]);
swplot.plot('type','polyhedron','position',cat(3,Rlu),'color','pink','alpha',0.5)

model.gencoupling
model.addmatrix('label','DM1','value',1);
model.addcoupling('mat','DM1','bond',1)
plot(model)
model.getmatrix('mat','DM1');

% Look at the figure from a special angle using the swplot.transform
% function and recenter the figure using swplot.translate.
R = sw_rotmatd([1 1 0],45);
swplot.transform(R)
swplot.translate
```

--------------------------------

### Get Unique Column Vectors in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Returns the unique column vectors within a specified tolerance. This is a numerical utility function for data cleaning or analysis.

```matlab
sw_uniquetol
```

--------------------------------

### Get Neutron Scattering Length in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Returns the bound coherent neutron scattering length in femtometers (fm) for a given element. This parameter is fundamental for neutron scattering calculations.

```matlab
sw_nb
```

--------------------------------

### Configure and Estimate Fitpow Parameters

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Configures the fitting range, sets arguments for power spectrum calculation, and estimates the constant background and scale factor. Dependencies include the Spinw library and a pre-defined `eres` variable.

```matlab
fitpow.crop_q_range(0.25, 3);
fitpow.powspec_args.dE = eres;
fitpow.powspec_args.fastmode = true;
fitpow.powspec_args.neutron_output = true;

% estimate background and scale factor
fitpow.estimate_constant_background();
fitpow.estimate_scale_factor();
```

--------------------------------

### Generating a Magnetic Structure

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial9/tutorial9.html

This section shows how to generate a magnetic structure using the 'genmagstr' method. It allows defining the k-vector, number of unit cells, spin orientation mode, and initial spin configurations. The ground state energy is then calculated.

```matlab
S0 = [1 -2 1; 2 -1 -1; 0 0 0];
DMkag.genmagstr('mode','direct','k',[0 0 0],'n',[0 0 1],'unitS','lu', 'S',S0);
DMkag.energy
```

--------------------------------

### Get Magnetic Form Factor Values in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Retrieves the magnetic form factor values and associated coefficients. This information is necessary for calculations involving magnetic scattering, such as neutron diffraction.

```matlab
sw_mff
```

--------------------------------

### Calculate Spin Wave Spectrum in Python

Source: https://github.com/spinw/spinw/blob/master/python/README.md

Demonstrates how to create a spin wave model and calculate its spectrum using pySpinW in Python. This involves initializing the MATLAB interface, defining a spin wave model (e.g., triangular antiferromagnet), and specifying a q-grid for the calculation.

```python
import numpy as np
from pyspinw import Matlab

m = Matlab()

# Create a spinw model, in this case a triangular antiferromagnet
s = m.sw_model('triAF', 1)

# Specify the start and end points of the q grid and the number of points
q_start = [0, 0, 0]
q_end = [1, 1, 0]
pts = 501

# Calculate the spin wave spectrum
spec = m.spinwave(s, [q_start, q_end, pts])
```

--------------------------------

### Get X-ray Form Factor Values in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Returns the atomic charge form factor values used in X-ray scattering calculations. This data is crucial for simulating X-ray diffraction experiments.

```matlab
sw_cff
```

--------------------------------

### Get Atom Data from SpinW Database

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Retrieves information about chemical elements stored in the 'atom.dat' file within SpinW. This function provides access to elemental properties relevant to scattering calculations.

```matlab
sw_atomdata
```

--------------------------------

### Define AFM First Neighbor Interactions (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial8/tutorial8.txt

Generates the list of bonds and specifies the first and second neighbor bonds. It then adds AFM first neighbor interactions by defining a matrix 'J1' and coupling it to the first neighbor bonds.

```matlab
AF33kagome.gencoupling('maxDistance',7)
disp('First neighbor bonds:')
AF33kagome.table('bond',1)

AF33kagome.addmatrix('label','J1','value',1.00,'color','g')
AF33kagome.addcoupling('mat','J1','bond',1)
plot(AF33kagome,'range',[2 2 1/2],'cellMode','inside')
```

--------------------------------

### Initialize Powder Fitting Class (sw_fitpowder)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.html

Initializes the sw_fitpowder class for powder data fitting. It requires a spinw model, data, a fitting function, and initial parameter guesses. Optional arguments include background strategy and parameters for internal spinw algorithms.

```matlab
fit_func =  @(obj, p) matparser(obj, 'param', p, 'mat', {'J_1'}, 'init', true);
J1 = 0.85;

fitpow = sw_fitpowder(tri, data,  fit_func, [J1]);
fitpow.set_caching(true); % will store last calculated spectra

% set parameters passed to powspec
fitpow.powspec_args.dE = eres; % emergy resolution
fitpow.powspec_args.fastmode = true;
fitpow.powspec_args.neutron_output = true;
fitpow.powspec_args.nRand = 2e2; % low for speed (typically want > 1e3)
fitpow.powspec_args.hermit = true;
% set parameters passsed to sw_instrument
fitpow.sw_instrument_args = struct('dQ', dQ, 'ThetaMin', 3.5, 'Ei', Ei);

% crop data
fitpow.crop_energy_range(1.5*eres(0), inf); % typically want to avoid elastic line
fitpow.crop_q_range(0.25, 3);
fitpow.powspec_args.dE = eres;
fitpow.powspec_args.fastmode = true;
fitpow.powspec_args.neutron_output = true;

% estimate background and scale factor
fitpow.estimate_constant_background();
fitpow.estimate_scale_factor();

% plot data to inspect - any arguments after parameters are passed to
% contour plot (which shows the result the calculated intensity)
fitpow.plot_result(fitpow.params, 'EdgeAlpha', 0.9, 'LineWidth', 1 ,'EdgeColor', 'k');
```

--------------------------------

### Calculate and Plot Spin Waves - Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial29/tutorial29.html

This code calculates the spin wave spectrum for a given wavevector and energy range, then prepares and plots the spectrum. It's essential for understanding the dynamic magnetic excitations in a material.

```matlab
spec = afc.spinwave({[0 0 0] [2 0 0] 500},'hermit',true);
spec = sw_egrid(spec,'Evect',linspace(0,3,300));
figure
sw_plotspec(spec);
axis([0 2 0 3])
```

--------------------------------

### Get Matrix Elements and Transform with Rotation

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial32/tutorial32.txt

Retrieves specific matrix elements (e.g., 'J1') from a model and applies a rotation matrix to the plotting environment. This is useful for visualizing how symmetry operations affect the magnetic interactions.

```matlab
model.getmatrix('mat','J1');
R = sw_rotmatd([0.5 1 0],45);
swplot.transform(R);
swplot.translate
```

--------------------------------

### Generate Bonds and Display First Neighbor Bonds in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial8/tutorial8.html

Generates the list of magnetic bonds up to a maximum distance and displays the first neighbor bonds. This helps in understanding the magnetic interactions within the lattice.

```matlab
AF33kagome.gencoupling('maxDistance', 7)
disp('First neighbor bonds:')
AF33kagome.table('bond', 1)
```

--------------------------------

### Create Colormap with RGB Values in Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial15/tutorial15.txt

This function creates a colormap using specified RGB values for start, middle, and end colors, and a defined number of color steps. It is useful for visualizing data with a gradient.

```matlab
colormap(makecolormap([0 1 0],[1 1 1],[0 0 1],81));
```

--------------------------------

### Initialize SpinW Environment

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial30/tutorial30.txt

Initializes the SpinW environment by removing user-specific entries from the symmetry.dat file. This ensures a clean state for symmetry calculations.

```matlab
sw_initialize
```

--------------------------------

### Modify Lattice Symmetry Directly (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/help/Swclass/Swclass.txt

Directly modifies the lattice symmetry property of an SW object. The value must be an integer, corresponding to the space group index. For example, int32(5) sets the space group to 'C 2'.

```matlab
model1.lattice.sym = int32(5);
```

--------------------------------

### Generate Magnetic Structure

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial7/tutorial7.html

Generates a magnetic structure for the kagome lattice with a specific k-point (0,0,0) and spin configuration. It uses the 'direct' mode and specifies spin vector components in the lattice vector coordinate system. The magnetic structure and ground state energy are then displayed.

```matlab
S0 = [1 -2 1; 2 -1 -1; 0 0 0];
AFkagome.genmagstr('mode','direct','k',[0 0 0],'n',[0 0 1],'unitS','lu','S',S0);
disp('Magnetic structure:')
AFkagome.table('mag')
AFkagome.energy
```

--------------------------------

### Run and Plot Spin Wave Dispersion in Matlab

Source: https://github.com/spinw/spinw/blob/master/docs/source/02_introduction.md

Executes a spin wave calculation for a triangular lattice antiferromagnet and plots the resulting dispersion. This example demonstrates the integration of model definition, spin wave calculation, and plotting functions within a single line.

```matlab
>>sw_plotspec(spinwave(sw_model('triAF',1),{[0 0 0] [1 1 0]}))
>>snapnow
```

--------------------------------

### Fit Powderspectrum Data with Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Performs a fit on powder diffraction data using specified cost functions and optimizers. It allows fixing background parameters, setting bounds for model parameters, and then executes the fitting process. Returns the fitted parameters, cost value, and statistics.

```matlab
% set cost function and minimser
fitpow.cost_function = "Rsq";  % "Rsq" or "chisq"
fitpow.optimizer = @ndbase.simplex; % or e.g. ndbase.simplex

% Fix background parameters (planar background of form 
default background is planar with parameters:
% [slope_energy, slope_modQ,  intercept]
fitpow.fix_bg_parameters(1:2); % fix slopes to initial value (0) 
fitpow.set_bg_parameter_bounds(3, 0.0, []) % Set lb of constant bg = 0
% fit background
fitpow.fit_background();
fitpow.fix_bg_parameters(3); % fix fitted constant bg

% set bounds on first (and only in this case) model parameter
fitpow.set_model_parameter_bounds(1, 0, []) % Force J_1 to be AFM

[pfit, cost_val, stat] = fitpow.fit();
```

--------------------------------

### MATLAB: Initialize and Fit 1D Cuts with Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.html

Initializes the sw_fitpowder class, replaces 2D data with 1D cuts, configures independent linear background, fits the background and model, and plots the results. The nQ parameter is reduced for faster processing, and background parameters can be fixed or bounds set.

```MATLAB
fitpow.nQ = 5;
% change background strategy to independent (planar is default)
fitpow.replace_2D_data_with_1D_cuts(qcens-dq, qcens+dq, "independent");

% independent linear background for all cuts with parameters:
% [slope_energy,  intercept]
fitpow.fix_bg_parameters(1); % fix slopes to initial value (0) for all cuts
% e.g. fitpow.fix_bg_parameters(1, 2) would fix the bg slope of the second cut
fitpow.set_bg_parameter_bounds(2, 0.0, []); % Set lb of constant bg = 0
% fit background
fitpow.estimate_constant_background();
fitpow.fit_background();
fitpow.fix_bg_parameters(2); % fix fitted constant bg

[pfit, cost_val, stat]  = fitpow.fit();

fitpow.plot_result(pfit)
```

--------------------------------

### Determine Magnetic Structure using SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial38/tutorial38.html

This snippet determines the optimal orientation of ordered pseudospin vectors within a crystallographic cell starting from a paramagnetic state. It utilizes the `optmagsteep` function to find the magnetic structure and then accesses the ground state energy.

```matlab
ca2ruo4.genmagstr('mode','random','S',[1 0 0],'k',[0 0 0])
magRes = ca2ruo4.optmagsteep('nRun',1e4);
ca2ruo4.energy
```

--------------------------------

### Fit 1D Cuts of Powder Diffraction Data

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Fits 1D cuts extracted from 2D powder diffraction data. This method can be faster than fitting the full 2D data. It allows configuring the number of Q-points for averaging, replacing 2D data with 1D cuts, and handling background independently for each cut.

```matlab
% set nQ before replacing data (reduced from default, 10, for speed)
fitpow.nQ = 5;
% change background strategyto independent (planar is default)
fitpow.replace_2D_data_with_1D_cuts(qcens-dq, qcens+dq, "independent");

% independent linear background for all cuts with parameters:
% [slope_energy,  intercept]
fitpow.fix_bg_parameters(1); % fix slopes to initial value (0) for all cuts
% e.g. fitpow.fix_bg_parameters(1, 2) would fix the bg slope of the second cut 
fitpow.set_bg_parameter_bounds(2, 0.0, []) % Set lb of constant bg = 0
% fit background
fitpow.estimate_constant_background();
fitpow.fit_background();
fitpow.fix_bg_parameters(2); % fix fitted constant bg

[pfit, cost_val, stat]  = fitpow.fit();

fitpow.plot_result(pfit)
```

--------------------------------

### Get Symmetry Allowed Matrix Elements

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial20/tutorial20.txt

Utilizes the spinw.getmatrix() function to determine the symmetry-allowed exchange matrix elements, g-tensor, and anisotropy matrix. The function identifies the allowed matrix elements based on the first bond defined in the coupling table.

```matlab
ybti.getmatrix('mat','J1');
```

--------------------------------

### DM Interaction without Space Group

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial32/tutorial32.txt

Sets up a crystal lattice without applying any space group symmetry (P0), adds multiple atoms, and defines a DM interaction. This example highlights how removing symmetry significantly alters the allowed interactions and the resulting Hamiltonian.

```matlab
cryst=spinw;
cryst.genlattice('lat_const',[8 8 6]);
cryst.addatom('r',[1/4 1/4 0],'S',1);
cryst.addatom('r',[3/4 1/4 0],'S',1);
cryst.addatom('r',[1/4 3/4 0],'S',1);
cryst.addatom('r',[3/4 3/4 0],'S',1);
cryst.gencoupling;
cryst.addmatrix('label','D','value',[0 -1 0]);
cryst.addcoupling('mat','D','bond',1,'subIdx',[3 5 7:8]);

plot(cryst,'range',[1 1 1/2],'atomLegend',false)
```

--------------------------------

### Generate and Display Bonds (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial8/tutorial8.txt

This code generates the list of bonds within a specified maximum distance and then displays the first neighbor bonds. It uses the gencoupling function to find bonds and the table function to list them. The output includes bond information such as distance, length, and connected atoms.

```MATLAB
AF33kagome.gencoupling('maxDistance',7)
disp('First neighbor bonds:')
AF33kagome.table('bond',1)
```

--------------------------------

### Plot Spin Wave Model (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial10/tutorial10.html

Visualizes the defined crystal and magnetic structure of the spin wave model. The 'plot' function displays the lattice, and 'swplot.zoom' adjusts the view. This is useful for verifying the model setup before proceeding with calculations.

```matlab
plot(sq)
swplot.zoom(2)
```

--------------------------------

### Optimize Magnetic Structure (MATLAB)

Source: https://context7.com/spinw/spinw/llms.txt

This section demonstrates how to optimize the magnetic structure in SpinW to find the ground state energy. It shows how to use different optimization algorithms like particle swarm optimization ('optmagstr'), steepest descent ('optmagsteep'), and simulated annealing ('anneal'). The code includes defining optimization bounds and parameters, and verifying the optimized structure and its energy.

```matlab
tri = sw_model('triAF', 1);

x_min = [0    0    0    0  0  0];
x_max = [0  1/2  1/2    0  0  0];
tri.optmagstr('func', @gm_planar, 'xmin', x_min, 'xmax', x_max, 'nRun', 10);

tri.optmagsteep('nRun', 100);

tri.anneal('random', true, 'nMC', 1e4, 'nStat', 1e2, 'initT', 100);

tri.table('mag');
E_optimized = tri.energy;
```

--------------------------------

### Replace 2D Data with 1D Cuts and Fit using Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial39/tutorial39.txt

Reduces the nQ value for faster processing and then replaces the 2D data with 1D cuts, specifying an 'independent' background strategy. This method is useful for fitting 1D cuts of data, which can be computationally quicker than fitting the full 2D dataset, especially when combined with the 'independent' background fitting approach.

```matlab
fitpow.nQ = 5;
fitpow.replace_2D_data_with_1D_cuts(qcens-dq, qcens+dq, "independent");
```

--------------------------------

### Plot Magnetic Model with Bonds and Atoms in SpinW

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial33/tutorial33.txt

This example demonstrates how to plot a magnetic model in SpinW, focusing on displaying both atoms and bonds. It utilizes the 'atomMode' to visualize magnetic properties and 'bondMode' to render bonds as cylinders, allowing for custom visual representations of the magnetic structure.

```matlab
model.plot('atomMode','mag','bondMode','cylinder',...)
```

--------------------------------

### Generate Antiferromagnetic Spin Chain Lattice (MATLAB)

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial2/tutorial2.html

Initializes a spinw object, generates a hexagonal lattice with specified constants and space group, and adds a magnetic atom with S=1 spin. Displays the magnetic lattice table and plots the initial structure.

```matlab
AFMchain = spinw;
AFMchain.genlattice('lat_const',[3 8 8],'angled',[90 90 90],'spgr',0);
AFMchain.addatom('r',[0 0 0],'S',1,'label','MCu1','color','blue');
disp('Magnetic lattice:')
AFMchain.table('matom')
```

--------------------------------

### Define Exchange Couplings - MATLAB

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial3/tutorial3.txt

Defines the first (J1) and second (J2) neighbor antiferromagnetic couplings for the magnetic chain. It generates bonds up to a maximum distance and assigns 'J1' and 'J2-' matrices with specific values and colors, then plots the bonds.

```matlab
%% Couplings
% First and second neighbor antiferromagnetic couplings. If the name of the
% matrix ends with '-' the bond is plotted with dashed line.

J1J2chain.gencoupling('maxDistance',7); 
disp('Bonds:')
J1J2chain.table('bond',[])

J1J2chain.addmatrix('label','J1', 'value',-1,'color','r');
J1J2chain.addmatrix('label','J2-','value', 2,'color','g'); 

J1J2chain.addcoupling('mat','J1','bond',1);
J1J2chain.addcoupling('mat','J2-','bond',2);
plot(J1J2chain,'range',[3 0.9 0.9],'bondMode','line','bondLinewidth0',3)
```

--------------------------------

### Calculate and Plot Spin Wave Spectrum in Spinw

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial35/tutorial35.txt

This section shows how to calculate the spin wave spectrum for specified Q-vectors and energy grids using spinw.spinwave and sw_egrid. The calculated spectrum is then plotted using sw_plotspec and overlaid with experimental data read from a file using sw_readtable. This allows for direct comparison between theoretical predictions and experimental observations.

```matlab
Q1 = [0 1.0 2.0];
Q2 = [0 1.0 3.0];
Q3 = [0 1.5 3.5];

spec = luvo.spinwave({Q1 Q2 Q3 501});

spec = sw_egrid(spec);

figure
sw_plotspec(spec,'dE',1.5)
legend('off')

% Plot over the experimental data after loading the data.
T = sw_readtable('LuVO3_fitted_modes.txt');

% List of Q values from data.
Q = [[T(:).QH];[T(:).QK];[T(:).QL]]';
% List of energy values from data.
w1 = [T(:).EN1];
w2 = [T(:).EN2];
% We remove  zero energy points.
w2(w2==0) = nan;

% (0,1,L) line
Qabs = sqrt(sum((bsxfun(@minus,Q(1:10,:),[0 1 2])*luvo.rl).^2,2));

% (0,1+K,3+K) line
Qabs2 = sqrt(sum((bsxfun(@minus,Q(11:end,:),[0 1 3])*luvo.rl).^2,2));
Qabs = [Qabs; Qabs2 + sqrt(sum(([0 0 1]*luvo.rl).^2))];

hold on
plot3(Qabs,w1,1e2+w1*0,'ko','MarkerFaceColor','g')
```

--------------------------------

### Generate AFM J1-J2 Chain Lattice and Atoms

Source: https://github.com/spinw/spinw/blob/master/tutorials/publish/tutorial3/tutorial3.txt

Initializes a spinw object, generates a simple cubic lattice with specified dimensions and space group 0, and adds a magnetic atom ('Cu1') with spin S=1 at the origin. It then displays the atomic table and plots the lattice.

```matlab
J1J2chain = spinw;
J1J2chain.genlattice('lat_const',[3 8 10],'angled',[90 90 90],'spgr',0);
J1J2chain.addatom('r',[0 0 0],'S',1,'label','Cu1','color','blue');
disp('Magnetic lattice:')
J1J2chain.table('atom')
plot(J1J2chain,'range',[3 1 1],'zoom',0.5)
```
Tokens:
Raw