Procedures

Calculates the Berry curvature traced over the occupied states, -2Im[f(k)] [Eq.33 CTVR06, Eq.6 LVTS12] for a list of Fermi energies, and stores it in axial-vector form

Calculates the three quantities needed for the orbital magnetization:

Contribution from point k to the complex interband optical conductivity, separated into Hermitian (H) and anti-Hermitian (AH) parts. Also returns the joint density of states

!

Computes the following quantities: (i) Anomalous Hall conductivity (from Berry curvature) (ii) Complex optical conductivity (Kubo-Greenwood) & JDOS (iii) Orbital magnetization (iv) Nonlinear shift current (v) Spin Hall conductivity

This is the main routine of the BoltzWann module. It calculates the transport coefficients using the Boltzmann transport equation.

This routine calculates the Transport Distribution Function $$\sigma_{ij}(\epsilon)$$ (TDF) in units of 1/hbar^2 * eV*fs/angstrom, and possibly the DOS.

Reduce complex data to all nodes

Reduce real data to all nodes

Given an array of size numpoints, we want to split on num_nodes nodes. This function returns two arrays: count and displs.

A barrier to synchronise all nodes

Send character array from root node to all nodes

Send character array from root node to all nodes

Send integar array from root node to all nodes

Send logical array from root node to all nodes

Send real array from root node to all nodes

Called to finalise the comms

Gather complex data to root node (for arrays of rank 1)

Gather complex data to root node (for arrays of rank 2)

Gather complex data to root node (for arrays of rank 3)

Gather complex data to root node (for arrays of rank 3 and 4, respectively)

Gather complex data to root node (for arrays of rank 4)

Gather real data to root node

Gather real data to root node (for arrays of rank 1)

Gather real data to root node (for arrays of rank 2)

Gather real data to root node (for arrays of rank 2 and 3, respectively)

Gather real data to root node (for arrays of rank 3)

Receive character array from specified node

Receive complex array from specified node

Receive integer array from specified node

Receive logical array from specified node

Receive real array from specified node

Reduce complex data to root node

Reduce integer data to root node

Reduce real data to root node

Scatter complex data from root node (array of rank 4)

Scatter integer data from root node (array of rank 1)

Scatter integer data from root node (array of rank 2)

Scatter integer data from root node (array of rank 3)

Scatter real data from root node (array of rank 1)

Scatter real data from root node (array of rank 2)

Scatter real data from root node (array of rank 3)

Send character array to specified node

Send complex array to specified node

Send integer array to specified node

Send logical array to specified node

Send real array to specified node

Set up communications

Set up variables related to communicators This should be called also in library mode

Set the seedname from the command line

Set the seedname from the command line

Read formatted checkpoint file

Read formatted checkpoint file

Read unformatted spn file

Read formatted spn file

Write formatted checkpoint file

Write formatted checkpoint file

Write unformatted spn file

Write formatted spn file

Extracts an num_wann-dimensional subspace at each k by minimizing Omega_I

Extracts an num_wann-dimensional subspace at each k by minimizing Omega_I (Gamma point version)

Main disentanglement routine

COMPUTES THE LEADING EIGENVECTORS OF Q_froz . P_s . Q_froz, WHERE P_s PROJECTOR OPERATOR ONTO THE SUBSPACE S OF THE PROJECTED GAUSSIANS, P_f THE PROJECTOR ONTO THE FROZEN STATES, AND Q_froz = 1 - P_froz, ALL EXP IN THE BASIS OF THE BLOCH EIGENSTATES INSIDE THE OUTER ENERGY WINDOW (See Eq. (27) in Sec. III.G of SMV)

Construct projections for the start of the disentanglement routine

This subroutine selects the states that are inside the outer window (ie, the energy window out of which we fish out the optimally-connected subspace) and those that are inside the inner window (that make up the frozen manifold, and are straightfowardly included as they are). This, in practice, amounts to slimming down the original num_wann x num_wann overlap matrices, removing rows and columns that belong to u_nks that have been excluded forever, and marking (indexing) the rows and columns that correspond to frozen states.

This subroutine calculates the contribution to the DOS of a single k point

This subroutine calculates the level spacing, i.e. how much the level changes near a given point of the interpolation mesh

Computes the electronic density of states. Can resolve into up-spin and down-spin parts, project onto selected Wannier orbitals, and use adaptive broadening, as in PRB 75, 195121 (2007) [YWVS07].

Fourier transforms Wannier-gauge representation of a given operator O from q-space to R-space:

gauss_freq(x) = (1+erf(x/sqrt(2)))/2 = erfc(-x/sqrt(2))/2 - See comments in erf

This routine prints the band energies (and possibly the band derivatives)

AA_a(R) = <0|r_a|R> is the Fourier transform of the Berrry connection AA_a(k) = i (a=x,y,z)

BB_a(R)=<0n|H(r-R)|Rm> is the Fourier transform of BB_a(k) = i (a=x,y,z)

CC_ab(R) = <0|r_a.H.(r-R)_b|R> is the Fourier transform of CC_ab(k) = (a,b=x,y,z)

FF_ab(R) = <0|r_a.(r-R)_b|R> is the Fourier transform of FF_ab(k) = (a=alpha,b=beta)

computes <0n|H|Rm>, in eV (pwscf uses Ry, but pw2wannier90 converts to eV)

This function reads and sets the interpolation mesh variables needed by a given module

Compute several matrices for spin Hall conductivity SR_R = <0n|sigma_{x,y,z}.(r-R)alpha|Rm> SHR_R = <0n|sigma.H.(r-R)alpha|Rm> SH_R = <0n|sigma.H|Rm>

This function parses a string containing the type of smearing and returns the correct index for the smearing_index variable

Wannier representation of the Pauli matrices: <0n|sigma_a|Rm> (a=x,y,z)

Find the lower bound (band index) of the outer energy window at the specified k-point

Computes the following quantities: (i) D tensor (ii) K tensor (iii) C tensor (iv) current-induced optical activity (v) natural optical activity

Deallocate module data

Calculate the Hamiltonian in the WF basis

Allocate arrays and setup data

Calculates a grid of points that fall inside of (and eventually on the surface of) the Wigner-Seitz supercell centered on the origin of the B lattice with primitive translations nmonkh(1)a_1+nmonkh(2)a_2+nmonkh(3)*a_3

Write the Hamiltonian in the WF basis

Write out the matrix elements of r

Write in a single file all the information that is needed to set up a Wannier-based tight-binding model: * lattice vectors * <0n|H|Rn> * <0n|r|Rn>

A reproducible maxloc function so b-vectors come in the same order each time

This routines returns the three integers that define the interpolation k-mesh, satisfying the condition that the spacing between two neighboring points along each of the three k_x, k_y and k_z directions is at smaller than a given spacing.

Writes a header for the output file(s).

Parse the commandline

Returns two strings containing the date and the time in human-readable format. Uses a standard f90 call.

Abort the code giving an error message

Returns an unused unit number so we can later open a file on that unit.

Get the seedname from the commandline

Output timing information to stdout

Stopwatch to time parts of the code

Returns elapsed CPU time in seconds since its first call. Uses standard f90 call

Main routine

Main routine

Release memory from the kmesh module

Main routine to calculate the b-vectors

Returns the b-vectors for a given shell and kpoint.

Find the correct set of shells to satisfy B1 The stratagy is: 1) Take the bvectors from the next shell 2) Reject them if they are parallel to exisiting b vectors 3) Test to see if we satisfy B1, if not add another shell and repeat

Find the B1 weights for a set of shells specified by the user

Find the B1 weights for a set of b-vectors given in a file. This routine is only activated via a devel_flag and is not intended for regular use.

Same as kmesh_spacing_singleinteger, but for a kmesh with three different mesh samplings along the three directions

Set up the value of the interpolation mesh spacing, needed for adaptive smearing [see Eqs. (34-35) YWVS07]. Choose it as the largest of the three Delta_k's for each of the primitive translations b1, b2, and b3

We look for kpoint neighbours in a large supercell of reciprocal unit cells. Done sequentially this is very slow. Here we order the cells by the distance from the origin. Doing the search in this order gives a dramatic speed up

Writes nnkp file (list of overlaps needed)

This function calculates -dn(E)/dE, where n(E) is the Fermi distribution function.

Allocate memory to read Mmn and Amn from files This must be called before calling overlap_read

Dellocate memory

Construct initial guess from the projection via a Lowdin transformation See section 3 of the CPC 2008 Note that in this subroutine num_wann = num_bands since, if we are here, then disentanglement = FALSE

Construct initial guess from the projection via a Lowdin transformation See section 3 of the CPC 2008 Note that in this subroutine num_wann = num_bands since, if we are here, then disentanglement = FALSE Gamma specific version

Read the Mmn and Amn from files Note: one needs to call overlap_allocate first!

Only used when interfaced to the CP code Not sure why this is done here and not in CP

Distribute the chk files

release memory from allocated parameters

distribute the parameters across processors !

Fills the atom data block

Finds the length of the data block

assigns value read to constraint parameters based on column

assigns projection centres as default centre constraints and global Lagrange multiplier as individual Lagrange multipliers then reads the centre_constraints block for individual centre constraint parameters

This function returns a string describing the convention associated to a sc_phase_conv integer value.

Finds the value of the required keyword.

Finds the values of the required data block

Fills the kpath data block

Finds the values of the required keyword vector

Fills the projection data block

Read a range vector eg. 1,2,3,4-10 or 1 3 400:100 if(lcount) we return the number of states in length

This function returns a string describing the type of smearing associated to a given smr_index integer value.

Returns the length of a keyword vector

Load the *.win file into a character array in_file, ignoring comments and blank lines and converting everything to lowercase characters

Fills the atom data block during a library call

Estimate how much memory we will allocate

write postw90 parameters to stdout

Read parameters and calculate derived values

Read checkpoint file IMPORTANT! If you change the chkpt format, adapt accordingly also the w90chk2chk.x utility!

Convert a few things to uppercase to look nice in the output

write wannier90 parameters to stdout

Write checkpoint file IMPORTANT! If you change the chkpt format, adapt accordingly also the w90chk2chk.x utility! Also, note that this routine writes the u_matrix and the m_matrix - in parallel mode these are however stored in distributed form in, e.g., u_matrix_loc only, so if you are changing the u_matrix, remember to gather it from u_matrix_loc first!

Write a suitable header for the calculation - version authors etc

June 2018: RM and SP Write to file the matrix elements of bvector and their weights This is used by EPW to compute the velocity. You need "write_bvec = .true." in your wannier input

Prepares a Xcrysden bxsf file to view the fermi surface

Plots the interpolated band structure

Main plotting routine

Plot u_matrix and u_matrix_opt to textfiles in readable format

Plot the WF in Xcrysden format based on code written by Michel Posternak

Writes the usage of the program to stdout

Writes the usage of the program to stdout

For alpha=0: O_ij(R) --> O_ij(k) = sum_R e^{+ik.R}*O_ij(R)

For OO: $$O_{ij}(k) = \sum_R e^{+ik.R}.O_{ij}(R)$$ For $$OO_{dx,dy,dz}$$ : $$\sum_R [i.R_{dx,dy,dz}.e^{+ik.R}.O_{ij}(R)]$$ where R_{x,y,z} are the Cartesian components of R

For OO: $$O_{ij}(k) = \sum_R e^{+ik.R}.O_{ij}(R)$$ For $$OO_{dx,dy,dz}$$ : $$\sum_R [i.R_{dx,dy,dz}.e^{+ik.R}.O_{ij}(R)]$$ where R_{x,y,z} are the Cartesian components of R For $$OO_{dx1,dy1,dz1;dx2,dy2,dz2}$$ : $$-\sum_R [R_{dx1,dy1,dz1}.R_{dx2,dy2,dz2}.e^{+ik.R}.O_{ij}(R)]$$ where R_{xi,yi,zi} are the Cartesian components of R

For OO: $$O_{ij}(k) = \sum_R e^{+ik.(R+tau_ij)}.O_{ij}(R)$$ For $$OO_{dx,dy,dz}$$ : $$\sum_R [i.(R+tau_ij)_{dx,dy,dz}.e^{+ik.(R+tau_ij)}.O_{ij}(R)]$$ where R_{x,y,z} are the Cartesian components of R For $$OO_{dx1,dy1,dz1;dx2,dy2,dz2}$$ : $$-\sum_R [(R+tau_ij)_{dx1,dy1,dz1}.(R+tau_ij)_{dx2,dy2,dz2}.e^{+ik.(R+tau_ij)}.O_{ij}(R)]$$ where {xi,yi,zi} denote the Cartesian components and

For OO_true (true vector): $${\vec O}_{ij}(k) = \sum_R e^{+ik.R} {\vec O}_{ij}(R)$$

For $$OO_{ij;dx,dy,dz}$$ : $$O_{ij;dx,dy,dz}(k) = \sum_R e^{+ik.R} O_{ij;dx,dy,dz}(R)$$ For $$OO_{ij;dx1,dy1,dz1;dx2,dy2,dz2}$$ : $$O_{ij;dx1,dy1,dz1;dx2,dy2,dz2}(k) = \sum_R e^{+ik.R} i.R_{dx2,dy2,dz2} .O_{ij;dx1,dy1,dz1}(R)$$

For $$OO_{ij;dx,dy,dz}$$ : $$O_{ij;dx,dy,dz}(k) = \sum_R e^{+ik.(R+tau_ij)} O_{ij;dx,dy,dz}(R)$$ For $$OO_{ij;dx1,dy1,dz1;dx2,dy2,dz2}$$ : $$O_{ij;dx1,dy1,dz1;dx2,dy2,dz2}(k) = \sum_R e^{+ik.(R+tau_ij)} i.(R+tau_ij)_{dx2,dy2,dz2} .O_{ij;dx1,dy1,dz1}(R)$$

Compute the electronic occupancy

Distribute the um and chk files

read kpoints from kpoint.dat and distribute

distribute the parameters across processors NOTE: we only send the ones postw90 uses, not all in w90

Setup data ready for interpolation

Error function - computed from the rational approximations of W. J. Cody, Math. Comp. 22 (1969), pages 631-637.

erfc(x) = 1-erf(x) - See comments in erf

Put R_in in the Wigner-Seitz cell centered around R0, and find all equivalent vectors to this (i.e., with same distance). Return their coordinates and the degeneracy, as well as the integer shifts needed to get the vector (these are always multiples of the mp_grid, i.e. they are supercell displacements in the large supercell)

Computes the spin magnetic moment by Wannier interpolation

Computes the spin magnetic moment by Wannier interpolation at the specified k-point

Computes (m=1,...,num_wann) where S.n = n_x.S_x + n_y.S_y + n_z.Z_z

This subroutine calculates the contribution to the TDF of a single k point

Dellocate module data

Main transport subroutine

Convert from Cartesian to fractional coordinates

Computes diagonal elements of [mat1,mat2]=mat1.mat2-mat2.mat1

Compares two vectors

Diagonalize the dim x dim hermitian matrix 'mat' and return the eigenvalues 'eig' and the unitary rotation 'rot'

Convert from fractional to Cartesian coordinates

Imaginary part of the trace

Return in b the adjoint of the 2x2 matrix a, together with the determinant of a. The inverse is defined as the adjoind divided by the determinant, so that inverse(a) = b/det

Return in b the adjoint of the 3x3 matrix a, and its determinant. The inverse is defined as the adjoind divided by the determinant, so that inverse(a) = b/det

Takes a string and converts to lowercase characters

Computes the diagonal elements of the matrix mat1.mat2

Calculate the real and reciprical space metrics

Real part of the trace

Calculates the reciprical lattice vectors and the cell volume

Rotates the dim x dim matrix 'mat' according to (rot)^dagger.mat.rot, where 'rot' is a unitary matrix

Rotates the dim x dim matrix 'mat' according to (rot)^dagger.mat.rot, where 'rot' is a unitary matrix. Computes only the diagonal elements of rotated matrix.

Takes a string in the form 0.0,1.0,0.5 and returns an array of the real num

Strips string of all blank spaces

Translate a vector to the home unit cell

the derivative of utility_wgauss: an approximation to the delta function

the derivative of utility_wgauss: an approximation to the delta function

this function computes the approximate theta function for the given order n, at the point x.

Return matrix product of complex n x n matrices a and b:

Calculate the Unitary Rotations to give Maximally Localised Wannier Functions

Calculate the Wannier Function spread !

Uses guiding centres to pick phases which give a consistent choice of branch cut for the spread definition

copy%om_c = orig%om_c

This routine should be called after wannier_setup from a code calling the library mode to actually run the Wannier code.

This routine should be called first from a code calling the library mode to setup all the variables. NOTE! The library mode currently works ONLY in serial (when called from a parallel code, make sure to run it only on 1 MPI process)

Compute D^H_a=UU^dag.del_a UU (a=x,y,z) using Eq.(24) of WYSV06

Compute D^H_a=UU^dag.del_a UU (a=alpha,beta), using Eq.(24) of WYSV06

Compute D^H_a=UU^dag.del_a UU (a=x,y,z) using Eq.(24) of WYSV06

Band derivatives dE/dk_a

Given a k point, this function returns eigenvalues E and derivatives of the eigenvalues dE/dk_a, using wham_get_deleig_a

Given a k point, this function returns eigenvalues E and derivatives of the eigenvalues dE/dk_a, using wham_get_deleig_a

Wrapper routine used to reduce number of Fourier calls

Wrapper routine used to reduce number of Fourier calls

Occupation matrix f, and g=1-f for a list of Fermi energies

Calculates a grid of lattice vectors r that fall inside (and eventually on the surface of) the Wigner-Seitz supercell centered on the origin of the Bravais superlattice with primitive translations mp_grid(1)a_1, mp_grid(2)a_2, and mp_grid(3)*a_3

Find the supercell translation (i.e. the translation by a integer number of supercell vectors, the supercell being defined by the mp_grid) that minimizes the distance between two given Wannier functions, i and j, the first in unit cell 0, the other in unit cell R. I.e., we find the translation to put WF j in the Wigner-Seitz of WF i. We also look for the number of equivalent translation, that happen when w_j,R is on the edge of the WS of w_i,0. The results are stored in global arrays wdist_ndeg, irdist_ws, crdist_ws.

Write to file the lattice vectors of the superlattice to be added to R vector in seedname_hr.dat, seedname_rmn.dat, etc. in order to have the second Wannier function inside the WS cell of the first one.