Magnetic field and DM interaction for S=1/2 spin model

[tshimokaw]

I just started to learn and use the netket.
I could run the test code of J1-J2 chain on my laptop. But I couldn't find the way to add the magnetic field term along z-direction. I guess I just have to add small modification into the above test code... but I couldn't find the proper documentations and examples.

And can I also add an antisymmetric interaction like the DM interaction?

Thanks a lot for your help in advance.

[tshimokaw]

Hi I think I found a way to add the magnetic field term. But I have another question to the developers.
I set the "total_sz=1" in the following code to check if the magnetic field term (along z direction) works properly and I added the function to compute total magnetization value (along z-direction) which must give 1. But I got "-1".

I couldn't understand why I got the negative sign in the total magnetization...

# ensure we run on the CPU
import os
os.environ["JAX_PLATFORM_NAME"] = "cpu"

# Import netket library
import netket as nk

# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

#Couplings J1 and J2
J = [1, 0.2]
L = 14
hz = 1.0 #magnetic field

# Define custom graph
edge_colors = []
for i in range(L):
    edge_colors.append([i, (i+1)%L, 1])
    edge_colors.append([i, (i+2)%L, 2])

# Define the netket graph object
g = nk.graph.Graph(edges=edge_colors)

#Si^z*Si^z interactions
siz = [[1/2, 0], [0, -1/2]]
mszsz = (np.kron(siz, siz))

#Exchange interactions
exchange = (1/4)*(np.asarray([[0, 0, 0, 0], [0, 0, 2, 0], [0, 2, 0, 0], [0, 0, 0, 0]]))

bond_operator = [
    (J[0] * mszsz).tolist(),
    (J[1] * mszsz).tolist(),
    (-J[0] * exchange).tolist(),
    (J[1] * exchange).tolist(),
]

bond_color = [1, 2, 1, 2]

# Spin based Hilbert Space
hi = nk.hilbert.Spin(s=0.5, total_sz=1, N=g.n_nodes)
print(g.n_nodes)

# Custom Hamiltonian operator
op = nk.operator.GraphOperator(hi, graph=g, bond_ops=bond_operator, bond_ops_colors=bond_color)

# Additional magnetic field term 
from netket.operator.spin import sigmaz
op +=sum([-hz*sigmaz(hi,i)/2 for i in range(L)])


import netket.nn as nknn
import flax.linen as nn

import jax.numpy as jnp

class FFNN(nn.Module):
    @nn.compact
    def __call__(self, x):
        x = nn.Dense(features=2*x.shape[-1],
                     use_bias=True,
                     param_dtype=np.complex128,
                     kernel_init=nn.initializers.normal(stddev=0.01),
                     bias_init=nn.initializers.normal(stddev=0.01)
                    )(x)
        x = nknn.log_cosh(x)
        x = jnp.sum(x, axis=-1)
        return x

model = FFNN()

# We shall use an exchange Sampler which preserves the global magnetization (as this is a conserved quantity in the model)
sa = nk.sampler.MetropolisExchange(hilbert=hi, graph=g, d_max = 2)

# Construct the variational state
vs = nk.vqs.MCState(sa, model, n_samples=1008)

# We choose a basic, albeit important, Optimizer: the Stochastic Gradient Descent
opt = nk.optimizer.Sgd(learning_rate=0.01)

# Stochastic Reconfiguration
sr = nk.optimizer.SR(diag_shift=0.01)

# We can then specify a Variational Monte Carlo object, using the Hamiltonian, sampler and optimizers chosen.
# Note that we also specify the method to learn the parameters of the wave-function: here we choose the efficient
# Stochastic reconfiguration (Sr), here in an iterative setup
gs = nk.VMC(hamiltonian=op, optimizer=opt, variational_state=vs, preconditioner=sr)

# We need to specify the local operators as a matrix acting on a local Hilbert space
sf = []
sites = []
structure_factor = nk.operator.LocalOperator(hi, dtype=complex)
for i in range(0, L):
    for j in range(0, L):
        structure_factor += (nk.operator.spin.sigmaz(hi, i)*nk.operator.spin.sigmaz(hi, j))*((-1)**(i-j))/L


tmz = []
sites = []
total_magz = nk.operator.LocalOperator(hi,dtype=complex)
for i in range(0, L):
    total_magz +=(nk.operator.spin.sigmaz(hi,i))*(1/2)


gs.run(out='test', n_iter=600, obs={'Structure Factor': structure_factor, 'Total Mag':total_magz})