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

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)

Reduce complex data to all nodes

Reduce real data to all nodes

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

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 3)

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

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 3)

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)

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

Multi-class Otsu thresholding of a scalar distribution in [lower_bound, upper_bound]. Histograms values into nbins equal-width bins over that FIXED range and finds the nclasses-1 ascending thresholds that maximise the between-class variance (exhaustive search, strict tie-break so the first-found maximum in ascending enumeration wins). Returns bin-centre thresholds in thr(1:nclasses_eff-1). The number of classes cannot exceed the number of populated bins (a cut must fall in a gap between clusters), so the effective class count is nclasses_eff = min(nclasses, populated bins); the caller is expected to note any reduction. Sets degenerate = .true. (thresholds undefined) only when fewer than three bins are populated.

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 selects the states for disentanglement and frozen based on projectability. States with projectability < dis_proj_min are discarded, states with projectability >= dis_proj_min are included in the disentanglement, states with projectability

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:

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)

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)

assigns value read to constraint parameters based on column

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 SH_R = <0n|sigma_{x,y,z}.H|Rm>

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>

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 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>

Read key variables from main input (.win) file; of use by wannier90.x only

This subroutine checks that the states in the columns of the final matrix U_opt are orthonormal at every k-point, i.e., that the matrix is unitary in the sense that conjg(U_opt).U_opt = 1 (but not U_opt.conjg(U_opt) = 1).

This subroutine finds the initial guess for the square unitary rotation matrix u_matrix. The method is similar to Sec. III.D of SMV, but with square instead of rectangular matrices:

Make initial u_matrix real Must be the case when gamma_only = .true.

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

This subroutine slims down the original Mmn(k,b), removing rows and columns corresponding to u_nks that fall outside the outer energy window.

Determine whether minimisation of non-gauge invariant spread is converged

Check if we have converged

Writes a header for the output file(s).

Compute the Z-matrix

Compute Z-matrix (Gamma point routine)

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

Abort the code giving an error message

Output timing information to stdout

Stopwatch to time parts of the code

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

Obtain possible permutation in ordering of b-vectors at different kpoints

Check if the obtained bweight satisfy the conditions for finite-difference, including (B1).

Release memory from the kmesh module

Main routine to calculate the b-vectors

Find amat(coefficients to find bweight) and the numbers of x, y, z components for a given order

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 activated via kmesh_shell_from_file = T It is not intended for regular use.

Include more shells to calculate higher-order finite difference: 2b, 3b, ... Nb shells Note: some shells are overwritten

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)

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

Write the Mmn and Amn from files

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

Read a single UNK file into wvfn (or wvfn_nc for spinors), keeping the first num_inc bands flagged in inc_band (bands not flagged are read and discarded).

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

Write out the matrix elements of r

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

Setup data ready for interpolation

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

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)

Fills the atom data block

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

triangle 1

Construct h00 and h01

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 adjoint divided by the determinant, so that inverse(a) = b/det

Return in b int inverse of a. Uses utility_inv3

Takes a string and converts to lowercase characters

Computes the diagonal elements of the matrix mat1.mat2

Calculate the metric for a lattice

Real part of the trace

Calculates the reciprical lattice vectors and the cell volume Includes a check that the volume isn't almost 0 Use the first time the lattice is read to check its sensible

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:

return a c-pointer to a instance of the wannier90 library data structure

causes w90 to calculate finite difference neighbour lists

deallocates/clears a c-pointer to a instance of the wannier90 library data structure

perform disentanglement; assumes library data object is already setup after w90_input_setopt() call no effect if number of bands == number of WF

provide a distribution of num_kpts k-points across mpi_size MPI ranks

probes w90 library for (current) wannier centres

open a (formatted) file and return the corresponding fortran unit number

fortran unit number for stderr

fortran unit number for stdout

probe w90 library for the triple of reciprocal lattice translations determining phase in k'= k+b setup k-mesh (b vectors) if not already done (sets setup_complete)

probe w90 library for number of finite difference k-point neighbours setup k-mesh (b vectors) if not already done (sets setup_complete)

probe w90 library for finite difference k-point neighbour indices setup k-mesh (b vectors) if not already done (sets setup_complete)

probes library data object and returns arrays describing a list of projections projectors defined either in .win file or passed (using same syntax) through w90_setopt array arguments assumed allocated at call array arguments must have length >= number of projectors (checked here)

probes w90 library for (current) wannier spreads

mechanism to act upon tokens read from the input ".win" file input is parsed and interpreted (any errors are identified) and the library data structure (variable common_data), already setup by w90_input_setopt, is modified

mechanism to act upon options supplied to the library input is parsed and interpreted (any errors are identified) and the library data structure (variable common_data) is populated ready for use

performs a variety of plotting functions

Read parameters and calculate derived values

Read parameters and calculate derived values

write postw90 parameters to stdout

Distribute the chk files

release memory from allocated parameters

Finds the length of the data block

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 explicit_kpath_labels 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 parses a string containing the type of smearing and returns the correct index for the smearing_index variable

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

reads the "optimisation" flag

Read checkpoint file This is used to allocate the matrices.

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

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

Reads disentanglement windows "dis_win_min" and "dis_win_max" (both are optional) Reads frozen window "dis_froz_min" and "dis_froz_max" (either neither or both to be supplied)

Read MPI distribution of k-points The array to be read must have num_kpt entries, with each entry being the MPI rank to which each k-point is assigned

Read the eigenvalues from wannier.eig

Read (and allocate) excluded_bands list "exclude_bands"

Read Fermi energy ("fermi_energy") and/or ranges ("fermi_energy_min", "fermi_energy_max" and "fermi_energy_step") used to setup fermi_energy_list tabulation _max and _step are only sought if _min found and are optional

Reads the flag for Gamma-only mode ("gamma_only")

Reads finite-difference input variables: "search_shells" "kmesh_tol" "shell_list" "num_shells" "skip_B1_tests"

Read band plotting path variables: "kpoint_path" and "bands_num_points"

Read the mandatory k-point mesh input ("mp_grid")

Read the number of bands ("num_bands") If not specified (and exclude_bands and total_bands are not both provided), defaults to num_wann

reads the number of wannier functions "num_wann" (mandatory input)

Read a group of variables defining the system "spinors" -- coupled spins "num_elec_per_state" -- spin degeneracy "num_valence_bands"

read the "total_bands" variable this is a convenience for combination with an "exclude_bands" to evaluate num_bands

reads the "energy_unit" and "length_unit" (valid: "ang" or "bohr") variables

read verbosity "iprint" and timing "timing_level" variables if iprint>2 svd_omega printing is enabled printing is supressed on all non-root MPI ranks

Reads "use_ws_distance", "ws_distance_tol", "ws_search_size"

Fills the atom data block during a library call

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.

Write a suitable header for the calculation - version authors etc

used to set the bohr_to_angstrom value as used in the SCF code

performs a variety of transport calculations

Estimate how much memory we will allocate

Read parameters and calculate derived values

Read parameters and calculate derived values

write wannier90 parameters to stdout

Write checkpoint file IMPORTANT! If you change the chkpt format, adapt accordingly also the w90chk2chk.x utility! note that this routine writes the full u_matrix and the m_matrix --remember to gather them from u_matrix_loc and m_matrix_loc first! (nothing here is parallel)

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

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

If use_ws_distance = true, get list of all R vectors that appear in irdist_ws and write them to irvec_pw90. Set the index map ir_ind_ws_to_pw90

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

Writes the .nnkp file instructing a DFT code what projections and overlaps to construct

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.