1_data_prepare/prepare.py

#!/usr/bin/env python
"""
Prepare displaced supercell configurations and band structure inputs for diamond.

Reads scf.in (pristine unit cell), then:
  - Creates data/disp-XX/ with QE SCF + pw2bgw + HPRO calc inputs
  - Creates data/bands/uc/ and data/bands/sc/ with pristine band structure inputs
  - Saves k-path info to data/bands/kpath.json for use by compare_bands.py

Usage: python prepare.py [params.json]
"""
import json
import os
import sys

import numpy as np
from ase.io import read
from ase.io.espresso import read_fortran_namelist
from ase.build import make_supercell

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))


def load_params(path=None):
    if path is None:
        path = os.path.join(SCRIPT_DIR, 'params.json')
    with open(path) as f:
        return json.load(f)


def parse_scf_qe_params(scf_path):
    """Parse ecutwfc, conv_thr, and k_uc from a QE scf.in using ASE."""
    with open(scf_path) as f:
        namelists, cards = read_fortran_namelist(f)
    ecutwfc = namelists['system']['ecutwfc']
    conv_thr = namelists['electrons']['conv_thr']
    k_uc = None
    for i, line in enumerate(cards):
        if line.strip().upper().startswith('K_POINTS') and 'AUTOMATIC' in line.upper():
            vals = cards[i + 1].split()
            k_uc = [int(vals[0]), int(vals[1]), int(vals[2])]
            break
    return ecutwfc, conv_thr, k_uc


def _scf_header(prefix, pseudo_dir, a, ecutwfc, conv_thr, n_atoms):
    return (
        f"&CONTROL\n calculation = 'scf'\n prefix = '{prefix}'\n"
        f" pseudo_dir = '{pseudo_dir}'\n outdir = './'\n/\n\n"
        f"&SYSTEM\n ibrav = 0\n A = {a}\n ecutwfc = {ecutwfc}\n"
        f" nat = {n_atoms}\n ntyp = 1\n/\n\n"
        f"&ELECTRONS\n conv_thr = {conv_thr}\n/\n\n"
    )


def _cell_and_atoms(lat_frac, atoms_frac):
    s = (
        f"CELL_PARAMETERS alat\n"
        f"    {lat_frac[0,0]:.8f}    {lat_frac[0,1]:.8f}    {lat_frac[0,2]:.8f}\n"
        f"    {lat_frac[1,0]:.8f}    {lat_frac[1,1]:.8f}    {lat_frac[1,2]:.8f}\n"
        f"    {lat_frac[2,0]:.8f}    {lat_frac[2,1]:.8f}    {lat_frac[2,2]:.8f}\n\n"
        f"ATOMIC_SPECIES\n  C  12.011  C.upf\n\nATOMIC_POSITIONS crystal\n"
    )
    for af in atoms_frac:
        s += f"  C   {af[0]:16.12f} {af[1]:16.12f} {af[2]:16.12f}\n"
    return s


def write_scf_input(atoms_frac, lat_frac, a, params, pseudo_dir, k_grid,
                    prefix='diamond'):
    q = params['qe']
    out = _scf_header(prefix, pseudo_dir, a, q['ecutwfc'], q['conv_thr'],
                      len(atoms_frac))
    out += _cell_and_atoms(lat_frac, atoms_frac)
    out += f"\nK_POINTS automatic\n{k_grid[0]} {k_grid[1]} {k_grid[2]} 0 0 0\n"
    return out


def write_bands_input(atoms_frac, lat_frac, a, params, pseudo_dir,
                      kpts_frac, nbnd, prefix='diamond', kpts_tpiba=None):
    q = params['qe']
    out = (
        f"&CONTROL\n calculation = 'bands'\n prefix = '{prefix}'\n"
        f" pseudo_dir = '{pseudo_dir}'\n outdir = './'\n/\n\n"
        f"&SYSTEM\n ibrav = 0\n A = {a}\n ecutwfc = {q['ecutwfc']}\n"
        f" nat = {len(atoms_frac)}\n ntyp = 1\n nbnd = {nbnd}\n/\n\n"
        f"&ELECTRONS\n/\n\n"
    )
    out += _cell_and_atoms(lat_frac, atoms_frac)
    if kpts_tpiba is not None:
        out += f"\nK_POINTS tpiba\n{len(kpts_tpiba)}\n"
        for k in kpts_tpiba:
            out += f"  {k[0]:12.8f}  {k[1]:12.8f}  {k[2]:12.8f}  1.0\n"
    else:
        out += f"\nK_POINTS crystal\n{len(kpts_frac)}\n"
        for k in kpts_frac:
            out += f"  {k[0]:12.8f}  {k[1]:12.8f}  {k[2]:12.8f}  1.0\n"
    return out


def write_pw2bgw_input(prefix='diamond'):
    return (
        f"&input_pw2bgw\n   prefix = '{prefix}'\n   real_or_complex = 2\n"
        f"   wfng_flag = .false.\n   wfng_file = 'WFN'\n"
        f"   rhog_flag = .false.\n   rhog_file = 'RHO'\n"
        f"   vxcg_flag = .false.\n   vxcg_file = 'VXC'\n"
        f"   vscg_flag = .true.\n   vscg_file = 'VSC'\n"
        f"   vkbg_flag = .false.\n   vkbg_file = 'VKB'\n/\n"
    )


def write_bands_pp_input(prefix='diamond'):
    return f"&BANDS\n  prefix = '{prefix}'\n  outdir = './'\n  filband = 'bands.dat'\n/\n"


def write_hpro_calc(vscdir, aobasis_dir, upfdir, ecutwfn):
    return (
        f"from HPRO import PW2AOkernel\n\n"
        f"kernel = PW2AOkernel(\n"
        f"    lcao_interface='siesta',\n"
        f"    lcaodata_root='{aobasis_dir}',\n"
        f"    hrdata_interface='qe-bgw',\n"
        f"    vscdir='{vscdir}',\n"
        f"    upfdir='{upfdir}',\n"
        f"    ecutwfn={ecutwfn}\n"
        f")\n"
        f"kernel.run_pw2ao_rs('./aohamiltonian')\n"
    )


def build_kpath(uc, npts_per_seg):
    """Build k-path for the unit cell.

    Uses the standard diamond FCC path G-X-W-K-G-L (5 segments) with
    npts_per_seg points per segment. Total = 5*npts_per_seg + 1 k-points.

    Returns:
      kpts_hs  (N_hs, 3) high-sym k-points in UC fractional reciprocal coords
      npts     list of n_points per segment (last element = 1 = final endpoint)
      labels   list of labels at each high-sym point
      kpts_all (nk, 3) all k-points for the QE bands.in and HPRO diag
      x        cumulative distances (1/Ang) for band plot x-axis
      x_hs     x positions of each high-sym point
    """
    bp = uc.cell.bandpath('GXWKGL', npoints=npts_per_seg * 5)
    sp = bp.special_points

    labels = ['G', 'X', 'W', 'K', 'G', 'L']
    kpts_hs = np.array([sp[c] for c in labels])
    npts = [npts_per_seg] * (len(labels) - 1) + [1]

    kpts_all = []
    for iseg in range(len(labels) - 1):
        n = npts[iseg]
        k0, k1 = kpts_hs[iseg], kpts_hs[iseg + 1]
        for j in range(n):
            kpts_all.append(k0 + (j / n) * (k1 - k0))
    kpts_all.append(kpts_hs[-1])
    kpts_all = np.array(kpts_all)

    # Cumulative distances in reciprocal Angstrom (ASE reciprocal has no 2pi)
    recip = uc.cell.reciprocal()
    kpts_cart = kpts_all @ recip
    dk = np.diff(kpts_cart, axis=0)
    x = np.concatenate([[0.0], np.cumsum(np.linalg.norm(dk, axis=1))])

    x_hs = [x[iseg * npts_per_seg] for iseg in range(len(labels) - 1)]
    x_hs.append(x[-1])

    return kpts_hs, npts, labels, kpts_all, x, x_hs


def _make_dir(base_dir, atoms_frac, lat_frac, a, params,
              pseudos_dir, aobasis_dir, ecutwfn, k_grid,
              kpts_all=None, nbnd=None, kpts_tpiba=None):
    """Create scf/ and reconstruction/ in base_dir with all input files."""
    scf_dir = os.path.join(base_dir, 'scf')
    recon_dir = os.path.join(base_dir, 'reconstruction')
    os.makedirs(scf_dir, exist_ok=True)
    os.makedirs(recon_dir, exist_ok=True)

    pseudo_rel = os.path.relpath(pseudos_dir, scf_dir)
    aobasis_rel = os.path.relpath(aobasis_dir, recon_dir)
    pseudo_rel_r = os.path.relpath(pseudos_dir, recon_dir)
    vsc_rel = os.path.relpath(scf_dir, recon_dir) + '/VSC'

    with open(os.path.join(scf_dir, 'pw.in'), 'w') as f:
        f.write(write_scf_input(atoms_frac, lat_frac, a, params,
                                pseudo_rel, k_grid))
    with open(os.path.join(scf_dir, 'pw2bgw.in'), 'w') as f:
        f.write(write_pw2bgw_input())
    with open(os.path.join(recon_dir, 'calc.py'), 'w') as f:
        f.write(write_hpro_calc(vsc_rel, aobasis_rel, pseudo_rel_r, ecutwfn))

    if kpts_all is not None:
        with open(os.path.join(scf_dir, 'bands.in'), 'w') as f:
            f.write(write_bands_input(atoms_frac, lat_frac, a, params,
                                     pseudo_rel, kpts_all, nbnd,
                                     kpts_tpiba=kpts_tpiba))
        with open(os.path.join(scf_dir, 'bands_pp.in'), 'w') as f:
            f.write(write_bands_pp_input())


def main():
    params_path = sys.argv[1] if len(sys.argv) > 1 else \
        os.path.join(SCRIPT_DIR, 'params.json')
    params = load_params(params_path)

    diamond_dir = os.path.dirname(SCRIPT_DIR)
    aobasis_dir = os.path.join(diamond_dir, 'aobasis')
    pseudos_dir = os.path.join(diamond_dir, 'pseudos')
    data_dir = os.path.join(SCRIPT_DIR, 'data')

    ecutwfn = params['hpro']['ecutwfn']
    nbnd = params['reconstruction']['nbnd']
    nbnd_sc = params['reconstruction'].get('nbnd_sc', nbnd)
    npts_per_seg = params['reconstruction']['npts_per_seg']
    sc_size = params['supercell_size']

    scf_path = os.path.join(SCRIPT_DIR, 'scf.in')
    uc = read(scf_path, format='espresso-in')
    a = float(np.linalg.norm(uc.cell[0]))  # alat = length of first primitive vector

    # Parse QE params from scf.in; params.json values take precedence if present
    ecutwfc_scf, conv_thr_scf, k_uc_scf = parse_scf_qe_params(scf_path)
    q = params.setdefault('qe', {})
    q.setdefault('ecutwfc', ecutwfc_scf)
    q.setdefault('conv_thr', conv_thr_scf)
    k_uc = q.get('k_uc', k_uc_scf)
    k_sc = q.get('k_sc', [max(1, k_uc[i] // sc_size[i]) for i in range(3)])

    lat_frac = uc.cell / a
    uc_frac = uc.get_scaled_positions()

    sc_matrix = np.diag(sc_size)
    sc = make_supercell(uc, sc_matrix)
    sc_frac_ideal = sc.get_scaled_positions()
    sc_lat_frac = np.array([lat_frac[i] * sc_size[i] for i in range(3)])
    sc_lat_ang = sc.cell[:]
    n_sc = len(sc)

    kpts_hs, npts, labels, kpts_all, x_arr, x_hs = build_kpath(uc, npts_per_seg)
    print(f"Band path: {'-'.join(labels)} ({len(kpts_all)} k-points)")

    os.makedirs(os.path.join(data_dir, 'bands'), exist_ok=True)
    kpath_info = {
        'kpts_hs': kpts_hs.tolist(),
        'npts': npts,
        'labels': labels,
        'kpts_all': kpts_all.tolist(),
        'x': x_arr.tolist(),
        'x_hs': x_hs,
    }
    with open(os.path.join(data_dir, 'bands', 'kpath.json'), 'w') as f:
        json.dump(kpath_info, f, indent=2)

    np.random.seed(params['random_seed'])
    n_disp = params['n_displacements']
    amplitudes = []
    for g in params['displacement_groups']:
        s, e = g['range']
        amplitudes.extend([g['amplitude']] * (e - s + 1))
    amplitudes = amplitudes[:n_disp]

    print(f"Creating {n_disp} displaced supercell configurations...")
    for idx in range(1, n_disp + 1):
        disp_amp = amplitudes[idx - 1]
        disp_frac = (np.random.randn(n_sc, 3) * disp_amp) @ np.linalg.inv(sc_lat_ang)
        atoms_frac = sc_frac_ideal + disp_frac

        disp_dir = os.path.join(data_dir, f'disp-{idx:02d}')
        _make_dir(disp_dir, atoms_frac, sc_lat_frac, a, params,
                  pseudos_dir, aobasis_dir, ecutwfn, k_sc)

    print(f"  Created disp-01 .. disp-{n_disp:02d}")

    print("Creating data/bands/uc/ ...")
    B_uc = np.linalg.inv(lat_frac).T  # UC reciprocal lattice (rows = b1,b2,b3) in 2pi/alat
    kpts_uc_tpiba = kpts_all @ B_uc   # crystal fractional -> tpiba
    _make_dir(os.path.join(data_dir, 'bands', 'uc'),
              uc_frac, lat_frac, a, params,
              pseudos_dir, aobasis_dir, ecutwfn, k_uc,
              kpts_all=kpts_all, nbnd=nbnd, kpts_tpiba=kpts_uc_tpiba)

    print("Creating data/bands/sc/ ...")
    _make_dir(os.path.join(data_dir, 'bands', 'sc'),
              sc_frac_ideal, sc_lat_frac, a, params,
              pseudos_dir, aobasis_dir, ecutwfn, k_sc,
              kpts_all=kpts_all, nbnd=nbnd_sc)

    print("Done. data/ structure created.")
    print(f"  {n_disp} displaced configs + bands/uc + bands/sc")
    print(f"  k-path saved to data/bands/kpath.json")


if __name__ == '__main__':
    main()