# Quantum phase transitions in the Bose-Hubbard model

As an example of the dwa QMC code we will study a quantum phase transition in the Bose-Hubbard mode.

## Superfluid density in the Bose Hubbard model

### Preparing and running the simulation from the command line

The parameter file parm1a sets up Monte Carlo simulations of the quantum Bose Hubbard model on a square lattice with 4x4 sites for a couple of hopping parameters (t=0.01, 0.02, ..., 0.1) using the dwa code.

 LATTICE="square lattice";
L=4;

MODEL="boson Hubbard";
Nmax = 2;
U    = 1.0;
mu   = 0.5;

T    = 0.1;

SWEEPS=5000000;
THERMALIZATION=100000;
SKIP=500;

MEASURE[Winding Number]=1

{ t=0.01; }
{ t=0.02; }
{ t=0.03; }
{ t=0.04; }
{ t=0.05; }
{ t=0.06; }
{ t=0.07; }
{ t=0.08; }
{ t=0.09; }
{ t=0.1;  }


Using the standard sequence of commands you can run the simulation using the quantum dwa code

parameter2xml parm1a
dwa --Tmin 5 --write-xml parm1a.in.xml


### Preparing and running the simulation using Python

To set up and run the simulation in Python we use the script tutorial1a.py. The first parts of this script imports the required modules and then prepares the input files as a list of Python dictionaries:

import pyalps

parms = []
for t in [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1]:
parms.append(
{
'LATTICE'                 : "square lattice",
'MODEL'                   : "boson Hubbard",
'T'                       : 0.1,
'L'                       : 4 ,
't'                       : t ,
'mu'                      : 0.5,
'U'                       : 1.0 ,
'Nmax'                    : 2 ,
'THERMALIZATION'          : 100000,
'SWEEPS'                  : 20000000,
'SKIP'                    : 500,
'MEASURE[Winding Number]' : 1
}
)


We next convert this into a job file in XML format and run the worm simulation:

input_file = pyalps.writeInputFiles('parm1a', parms)
res = pyalps.runApplication('dwa', input_file, Tmin=5, writexml=True)


We now have the same output files as in the command line version.

### Evaluating the simulation and preparing plots using Python

To load the results and prepare plots we load the results from the output files and collect the magntization density as a function of magnetic field from all output files starting with parm1a. The script is again in tutorial1a.py

import matplotlib.pyplot as plt
import pyalps.plot as aplt

rhos = pyalps.collectXY(data,x='t',y='Stiffness')

plt.figure()
aplt.plot(rhos)
plt.xlabel('Hopping $t/U$')
plt.ylabel('Superfluid density $\\rho _s$')
plt.show()


### Setting up and running the simulation in Vistrails (in preparation)

To run the simulation in Vistrails open the file dwa-01-bosons.vt and look at the workflow labeled "L=4". Click on "Execute" to prepare the input file, run the simulation and create the output figure.

## The transition from the Mott insulator to the superfluid

We next want to pin down the location of the phase transition more accurately. For this we simulate a two-dimensional square lattice for various system sizes and look for a crossing of the quantity $\rho_s*L$.

### Preparing and running the simulation from the command line

In the parameter file parm1b we focus on the region around the critical point for three system sizes L=4,6, and 8:

LATTICE="square lattice";

MODEL="boson Hubbard";
Nmax  =2;
U    = 1.0;
mu   = 0.5;

T    = 0.05;

SWEEPS=2000000;
THERMALIZATION=150000;
SKIP=500;

{ L=4; t=0.045; }
{ L=4; t=0.05; }
{ L=4; t=0.0525; }
{ L=4; t=0.055; }
{ L=4; t=0.0575; }
{ L=4; t=0.06; }
{ L=4; t=0.065; }

{ L=6; t=0.045; }
{ L=6; t=0.05; }
{ L=6; t=0.0525; }
{ L=6; t=0.055; }
{ L=6; t=0.0575; }
{ L=6; t=0.06; }
{ L=6; t=0.065; }

{ L=8; t=0.045; }
{ L=8; t=0.05; }
{ L=8; t=0.0525; }
{ L=8; t=0.055; }
{ L=8; t=0.0575; }
{ L=8; t=0.06; }
{ L=8; t=0.065; }


Using the standard sequence of commands you can run the simulation using the quantum dwa code

parameter2xml parm1b
dwa --Tmin 5 --write-xml parm1b.in.xml


### Preparing and running the simulation using Python

To set up and run the simulation in Python we use the script tutorial1a.py. The first parts of this script imports the required modules and then prepares the input files as a list of Python dictionaries:

import pyalps

parms = []
for t in [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09, 0.1]:
parms.append(
{
'LATTICE'                 : "square lattice",
'MODEL'                   : "boson Hubbard",
'T'                       : 0.1,
'L'                       : 4 ,
't'                       : t ,
'mu'                      : 0.5,
'U'                       : 1.0 ,
'Nmax'                    : 2 ,
'THERMALIZATION'          : 100000,
'SWEEPS'                  : 20000000,
'SKIP'                    : 500,
'MEASURE[Winding Number]' : 1
}
)


We next convert this into a job file in XML format and run the worm simulation:

input_file = pyalps.writeInputFiles('parm1a', parms)
res = pyalps.runApplication('dwa', input_file, Tmin=5, writexml=True)


We now have the same output files as in the command line version.

### Preparing, running and evaluating the simulation using Python

The Python script tutorial1b.py similarly prepares the input file and then runs the simulation. we skip this part and instead focus on the evaluation part. We first load the superfluid density (stiffness) into three different data sets, one for each system size L:

data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix='parm1b'),'Stiffness')
rhos = pyalps.collectXY(data,x='t',y='Stiffness',foreach=['L'])


Next we multiply each data set by the size L:

for s in rhos:
s.y = s.y * float(s.props['L'])


And finally we make a plot in the usual way:

plt.figure()
pyalps.pyplot.plot(rhos)
plt.xlabel('Hopping $t/U$')
plt.ylabel('$\\rho _sL$')
plt.legend()
plt.title('Scaling plot for Bose-Hubbard model')
plt.show()


Note the legend and labels that are nicely set up.

### Setting up and running the simulation in Vistrails (in preparation)

To run the simulation in Vistrails open the file dwa-01-bosons.vt and look at the workflow labeled "scaling plot".

© 2013 by Matthias Troyer, Ping Nang Ma