Hartree approximation and counterterms

The Hartree approximation

Extended interactions require an extension of quantum cluster methods: inter-cluster interactions have to be cut off and replaced by a mean field, in the Hartree approximation. An extended interaction on the cluster is then reduced to

\[\sum_{(ij)}V^c_{ij}n_i n_j + \sum_{(ij)}V^m_{ij}\left(n_i \langle n_j\rangle + n_j \langle n_i\rangle - \langle n_i\rangle\langle n_j\rangle \right)\]

where \(V_m\) stands for the terms of \(V_{ij}\) which need to be treated in the Hartree approximation, and \(V^c\) those that do not need to be. \((ij)\) stands for a pair of sites (\(i\ne j\)).

Since \(V_m\) is real symmetric, the mean-field Hamiltonian may be recast into

\[H_m = \sum_{ij}V^m_{ij}\left(n_i \langle n_j\rangle - \frac12\langle n_i\rangle\langle n_j\rangle \right)\]

where now the sum is over independent values of \(i\) and \(j\). \(V^m\) can be diagonalized by an orthogonal transformation \(L\): \(V^m = L\Lambda \tilde L\). One then defines eigenoperators \(O_a = L_{aj}n_j\) such that

\[H_m = \sum_a \lambda_a\left\{O_a \langle O_a\rangle - \frac12 \langle O_a\rangle^2\right\}\]

Now, let us consider the mean values \(\langle O_a\rangle\) as adjustable variational (or mean-field) parameters. Then, in terms of the coefficients \(h_a=\lambda_a\langle O_a\rangle\) of the operator \(O_a\), the mean-field Hamiltonian takes the following form:

\[H_m = \sum_a \left\{ h_a O_a - \frac{h_a^2}{2\lambda_a} \right\}\]

The variation of parameter \(h_a\) the yields

\[\langle O_a\rangle = \frac{h_a}{\lambda_a} \rightarrow h_a=\lambda_a\langle O_a\rangle\]

The Hartree procedure consists in starting with trial values of \(_a\) and iteratively performing the above assignation until convergence.

List of functions

class pyqcm.hartree.hartree(Vm, V, eig, accur=0.0001, lattice=False)

This class contains the elements needed to perform the Hartree approximation for the inter-cluster components of an extended interaction. The basic self-consistency relation is

\[v_m = ve\langle V_m\rangle \]

where v is the coefficient of the operator V and \(v_m\) that of the operator \(V_m\), and e is an eigenvalue specific to the cluster shape and the interaction. \(\langle V_m\rangle\) is the average of the operator \(V_m\), taken as a lattice of as a cluster average.

attributes:

  • Vm (str) : mean-field operator

  • V (str) : extended interaction

  • eig (float) : eigenvalue e of the mean-field operator in the self-consistency relation

  • lattice (boolean) : True if lattice averages are used

  • diff : difference between successive values of \(v_m\)

  • ave : averasge of the operator \(V_m\)

  • accur : desired accuracy

__init__(Vm, V, eig, accur=0.0001, lattice=False)
Parameters

  • Vm (str) – name of the mean-field operator

  • V (str) – name of the interaction operator

  • eig (float) – eigenvalue

  • accur (float) – required accuracy of the self-consistent procedure

  • lattice (boolean) – if True, the lattice average is used, otherwise the cluster average

converged()

Tests whether the mean-field procedure has converged

Return boolean

True if the mean-field procedure has converged

omega()

returns the constant contribution, added to the Potthoff functional

omega_var()

returns the constant contribution, added to the Potthoff functional

update(pr=False)

Updates the value of the mean-field operator based on its average

Parameters

pr (boolean) – if True, progress is printed on the screen

Counterterms

class pyqcm.hartree.counterterm(name, clus, S, accur=0.0001)

That class contains information about operators that are added to the cluster Hamiltonian in order to make their average vanish. The coefficient v of the operator V is adjusted so that \(\langle V\rangle=0\). The coefficient is updated using the relation

\[\langle O_1\rangle-\langle O_2\rangle = S (v_1-v_2)\]

where \(v_{1,2}\) are two values of the coefficient of the operator used in succession, \(\langle v_{1,2}\rangle\) are the corresponding averages and S is the (varying) slope.

attributes:

  • name (str) : name of the countererm operator

  • fullname (str) : name, including the cluster label

  • clus (int) : label of the cluster

  • S (float) : slope

  • accur (float) : accuracy to which the average must vanish.

  • v (float) : value of the coefficient of the operator

  • v0 (float) : previous value of the coefficient of the operator (previous iteration)

__init__(name, clus, S, accur=0.0001)

Constructor

Parameters

  • name (str) – name of the counterterm (previously defined in the model)

  • clus (int) – cluster label to which it is applied

  • S (float) – initial value of the slope

  • accur (float) – accuracy

converged()

Performs a convergence test

Return boolean

True if converged

update(first=False)

updates the value of the operator given its averaged

Parameters

first (boolean) – True if this is the first time it is called for a given iterative sequence

Looping utilities

pyqcm.loop.Hartree(F, couplings, maxiter=10, eps_algo=0, file='hartree.tsv', SEF=False)

Performs the Hartree approximation

Parameters

  • F – task to perform wihtin the loop

  • couplings ([class hartree]) – list of Hartree couplings (or single coupling)

  • maxiter (int) – maximum number of Hartree iterations

  • eps_algo (int) – number of elements in the epsilon algorithm convergence accelerator = 2*eps_algo + 1 (0 = no acceleration)

pyqcm.loop.controlled_loop(func=None, varia=None, loop_param=None, loop_range=None, control_func=None, adjust=False, predict=True)

Performs a controlled loop for VCA or CDMFT with a predictor

Parameters

  • func – a function called at each step of the loop

  • varia ([str]) – names of the variational parameters

  • loop_param (str) – name of the parameter looped over

  • loop_range ((float, float, float)) – range of the loop (start, end, step)

  • control_func – (optional) name of the function that controls the loop (returns boolean)

  • adjust (boolean) – if True, adjusts the steps depending on control or status of convergence

  • predict (boolean) – if True, uses a linear or quadratic predictor

pyqcm.loop.fade(F, p1, p2, n)

fades the model between two sets of parameters, in n steps

Parameters

  • F – task to perform wihtin the loop

  • p1 (dict) – first set of parameters

  • p2 (dict) – second set of parameters

  • n – number of steps

pyqcm.loop.fixed_density_loop(mu, target_n, kappa=1.0, maxdmu=0.2, func=None, loop_param=None, loop_values=None, var_param=None, dens_tol=0.001, dir='', measure=None, cluster_density=False)

Performs a loop while trying to keep a fixed density

Parameters

  • mu (float) – initial value of mu

  • target_n (float) – desired value of the density

  • kappa – initial guess of the compressibility

  • maxdmu – maximum change in mu at each step (absolute value)

  • func – function called at each step of the loop. No required argument. returns None.

  • loop_param (str) – name of the parameter looped over

  • loop_values (float) – an array of values of loop_param

  • var_param (str) – array of variational parameters (names) to be predicted

  • dens_tol – tolerance on the value of the density

  • dir – directory of calling script

  • measure – name of function to be called when the desired density is reached

  • cluster_density – if True, uses the cluster density instead of the lattice density

pyqcm.loop.linear_loop(N, func=None, varia=None, params=None, predict=True)

Performs a loop for VCA or CDMFT with a predictor

Parameters

  • N – number of intervals within the loop

  • func – function called at each step of the loop

  • varia ([str]) – names of the variational parameters

  • P ({str:(float,float)}) – dict of parameters to vary with initial and final values

  • predict (boolean) – if True, uses a linear or quadratic predictor

pyqcm.loop.loop_from_file(func, file)

Performs a task over a set of instances defined in a file

Parameters

  • func – function (task) to perform

  • file (str) – name of the data file specifying the solutions, in the same tab-separated format usually used to write solutions

Other utilities

Profile of expectation values

pyqcm.profile.plot_profile(n_scale=1, bond_scale=1, current_scale=1, spin_scale=1, spin_angle=0, bond_spin_scale=1, singlet_scale=1, triplet_scale=1, file=None, layer=0)

Produces a figure of various local quantities on the repeated unit, from averages computed in the ground state wavefunction

Parameters

  • n_scale (float) – scale factor applied to the density

  • bond_scale (float) – scale factor applied to the bond charge density

  • current_scale (float) – scale factor applied to the currents on the bonds

  • spin_scale (float) – scale factor applied to the spins on the sites

  • spin_angle (float) – angle at which to draw the spins, from their nominal direction

  • bond_spin_scale (float) – scale factor applied to the spins on the bonds

  • singlet_scale (float) – scale factor applied to the singlet pairing amplitudes

  • triplet_scale (float) – scale factor applied to the triplet pairing amplitudes

  • file (str) – name of the output file, if not None

  • layer (float) – layer number (z coordinate)

Defining models for slabs

class pyqcm.slab.slab(name, nlayer, cluster, sites, superlattice, lattice, thickness=None)

Helper class to define multi-layer systems, typically layers of planes. The fundamental unit is a 2D model that is repeated in the z direction

__init__(name, nlayer, cluster, sites, superlattice, lattice, thickness=None)

Constructor

Parameters

  • name (str) – name of the 2D model

  • nlayer (int) – total number of layers in the slab

  • cluster (str) – name of the cluster model assembled (limited to one cluster)

  • sites ([[int,int,int]]) – list of sites in each layer

  • superlattice ([[int,int,int]]) – superlattice vectors in 2D

  • lattice ([[int,int,int]]) – lattice vectors in 2D

  • thickness (int) – number of inequivalent layers (<= nlayer/2). If None, all layers are different

hopping_operator(name, link, amplitude, **kwargs)

Defines a hopping operator Same arguments as the pyqcm.hopping_operator() function

interaction_operator(name, **kwargs)

Defines an interaction operator Same arguments as the pyqcm.interaction_operator() function