Add files using upload-large-folder tool

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/__init__.py

@@ -0,0 +1,4 @@
+from .openmx_parse import OijLoad, GetEEiEij, openmx_parse_overlap
+from .get_rc import get_rc
+from .abacus_get_data import abacus_parse
+from .siesta_get_data import siesta_parse

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/abacus_get_data.py

@@ -0,0 +1,340 @@
+# Script for interface from ABACUS (http://abacus.ustc.edu.cn/) to DeepH-pack
+# Coded by ZC Tang @ Tsinghua Univ. e-mail: az_txycha@126.com
+# Modified by He Li @ Tsinghua Univ. & XY Zhou @ Peking Univ.
+# To use this script, please add 'out_mat_hs2    1' in ABACUS INPUT File
+# Current version is capable of coping with f-orbitals
+# 20220717: Read structure from running_scf.log
+# 20220919: The suffix of the output sub-directories (OUT.suffix) can be set by ["basic"]["abacus_suffix"] keyword in preprocess.ini
+# 20220920: Supporting cartesian coordinates in the log file
+# 20231228: Supporting ABACUS v3.4
+
+import os
+import sys
+import json
+import re
+
+import numpy as np
+from scipy.sparse import csr_matrix
+from scipy.linalg import block_diag
+import argparse
+import h5py
+
+
+Bohr2Ang = 0.529177249
+periodic_table = {'Ac': 89, 'Ag': 47, 'Al': 13, 'Am': 95, 'Ar': 18, 'As': 33, 'At': 85, 'Au': 79, 'B': 5, 'Ba': 56,
+                  'Be': 4, 'Bi': 83, 'Bk': 97, 'Br': 35, 'C': 6, 'Ca': 20, 'Cd': 48, 'Ce': 58, 'Cf': 98, 'Cl': 17,
+                  'Cm': 96, 'Co': 27, 'Cr': 24, 'Cs': 55, 'Cu': 29, 'Dy': 66, 'Er': 68, 'Es': 99, 'Eu': 63, 'F': 9,
+                  'Fe': 26, 'Fm': 100, 'Fr': 87, 'Ga': 31, 'Gd': 64, 'Ge': 32, 'H': 1, 'He': 2, 'Hf': 72, 'Hg': 80,
+                  'Ho': 67, 'I': 53, 'In': 49, 'Ir': 77, 'K': 19, 'Kr': 36, 'La': 57, 'Li': 3, 'Lr': 103, 'Lu': 71,
+                  'Md': 101, 'Mg': 12, 'Mn': 25, 'Mo': 42, 'N': 7, 'Na': 11, 'Nb': 41, 'Nd': 60, 'Ne': 10, 'Ni': 28,
+                  'No': 102, 'Np': 93, 'O': 8, 'Os': 76, 'P': 15, 'Pa': 91, 'Pb': 82, 'Pd': 46, 'Pm': 61, 'Po': 84,
+                  'Pr': 59, 'Pt': 78, 'Pu': 94, 'Ra': 88, 'Rb': 37, 'Re': 75, 'Rh': 45, 'Rn': 86, 'Ru': 44, 'S': 16,
+                  'Sb': 51, 'Sc': 21, 'Se': 34, 'Si': 14, 'Sm': 62, 'Sn': 50, 'Sr': 38, 'Ta': 73, 'Tb': 65, 'Tc': 43,
+                  'Te': 52, 'Th': 90, 'Ti': 22, 'Tl': 81, 'Tm': 69, 'U': 92, 'V': 23, 'W': 74, 'Xe': 54, 'Y': 39,
+                  'Yb': 70, 'Zn': 30, 'Zr': 40, 'Rf': 104, 'Db': 105, 'Sg': 106, 'Bh': 107, 'Hs': 108, 'Mt': 109,
+                  'Ds': 110, 'Rg': 111, 'Cn': 112, 'Nh': 113, 'Fl': 114, 'Mc': 115, 'Lv': 116, 'Ts': 117, 'Og': 118}
+
+
+class OrbAbacus2DeepH:
+    def __init__(self):
+        self.Us_abacus2deeph = {}
+        self.Us_abacus2deeph[0] = np.eye(1)
+        self.Us_abacus2deeph[1] = np.eye(3)[[1, 2, 0]]
+        self.Us_abacus2deeph[2] = np.eye(5)[[0, 3, 4, 1, 2]]
+        self.Us_abacus2deeph[3] = np.eye(7)[[0, 1, 2, 3, 4, 5, 6]]
+
+        minus_dict = {
+            1: [0, 1],
+            2: [3, 4],
+            3: [1, 2, 5, 6],
+        }
+        for k, v in minus_dict.items():
+            self.Us_abacus2deeph[k][v] *= -1
+
+    def get_U(self, l):
+        if l > 3:
+            raise NotImplementedError("Only support l = s, p, d, f")
+        return self.Us_abacus2deeph[l]
+
+    def transform(self, mat, l_lefts, l_rights):
+        block_lefts = block_diag(*[self.get_U(l_left) for l_left in l_lefts])
+        block_rights = block_diag(*[self.get_U(l_right) for l_right in l_rights])
+        return block_lefts @ mat @ block_rights.T
+
+def abacus_parse(input_path, output_path, data_name, only_S=False, get_r=False):
+    input_path = os.path.abspath(input_path)
+    output_path = os.path.abspath(output_path)
+    os.makedirs(output_path, exist_ok=True)
+
+    def find_target_line(f, target):
+        line = f.readline()
+        while line:
+            if target in line:
+                return line
+            line = f.readline()
+        return None
+    if only_S:
+        log_file_name = "running_get_S.log"
+    else:
+        log_file_name = "running_scf.log"
+    with open(os.path.join(input_path, data_name, log_file_name), 'r') as f:
+        f.readline()
+        line = f.readline()
+        # assert "WELCOME TO ABACUS" in line
+        assert find_target_line(f, "READING UNITCELL INFORMATION") is not None, 'Cannot find "READING UNITCELL INFORMATION" in log file'
+        num_atom_type = int(f.readline().split()[-1])
+
+        assert find_target_line(f, "lattice constant (Bohr)") is not None
+        lattice_constant = float(f.readline().split()[-1]) # unit is Angstrom
+
+        site_norbits_dict = {}
+        orbital_types_dict = {}
+        for index_type in range(num_atom_type):
+            tmp = find_target_line(f, "READING ATOM TYPE")
+            assert tmp is not None, 'Cannot find "ATOM TYPE" in log file'
+            assert tmp.split()[-1] == str(index_type + 1)
+            if tmp is None:
+                raise Exception(f"Cannot find ATOM {index_type} in {log_file_name}")
+
+            line = f.readline()
+            assert "atom label =" in line
+            atom_label = line.split()[-1]
+            assert atom_label in periodic_table, "Atom label should be in periodic table"
+            atom_type = periodic_table[atom_label]
+
+            current_site_norbits = 0
+            current_orbital_types = []
+            while True:
+                line = f.readline()
+                if "number of zeta" in line:
+                    tmp = line.split()
+                    L = int(tmp[0][2:-1])
+                    num_L = int(tmp[-1])
+                    current_site_norbits += (2 * L + 1) * num_L
+                    current_orbital_types.extend([L] * num_L)
+                else:
+                    break
+            site_norbits_dict[atom_type] = current_site_norbits
+            orbital_types_dict[atom_type] = current_orbital_types
+
+        line = find_target_line(f, "TOTAL ATOM NUMBER")
+        assert line is not None, 'Cannot find "TOTAL ATOM NUMBER" in log file'
+        nsites = int(line.split()[-1])
+        
+        line = find_target_line(f, " COORDINATES")
+        assert line is not None, 'Cannot find "DIRECT COORDINATES" or "CARTESIAN COORDINATES" in log file'
+        if "DIRECT" in line:
+            coords_type = "direct" 
+        elif "CARTESIAN" in line:
+            coords_type = "cartesian" 
+        else:
+            raise ValueError('Cannot find "DIRECT COORDINATES" or "CARTESIAN COORDINATES" in log file')
+
+        assert "atom" in f.readline()
+        frac_coords = np.zeros((nsites, 3))
+        site_norbits = np.zeros(nsites, dtype=int)
+        element = np.zeros(nsites, dtype=int)
+        for index_site in range(nsites):
+            line = f.readline()
+            tmp = line.split()
+            assert "tau" in tmp[0]
+            atom_label = ''.join(re.findall(r'[A-Za-z]', tmp[0][5:]))
+            assert atom_label in periodic_table, "Atom label should be in periodic table"
+            element[index_site] = periodic_table[atom_label]
+            site_norbits[index_site] = site_norbits_dict[element[index_site]]
+            frac_coords[index_site, :] = np.array(tmp[1:4])
+        norbits = int(np.sum(site_norbits))
+        site_norbits_cumsum = np.cumsum(site_norbits)
+
+        assert find_target_line(f, "Lattice vectors: (Cartesian coordinate: in unit of a_0)") is not None
+        lattice = np.zeros((3, 3))
+        for index_lat in range(3):
+            lattice[index_lat, :] = np.array(f.readline().split())
+        if coords_type == "cartesian":
+            frac_coords = frac_coords @ np.matrix(lattice).I
+        lattice = lattice * lattice_constant
+        if only_S:
+            spinful = False
+        else:
+            line = find_target_line(f, "NSPIN")
+            assert line is not None, 'Cannot find "NSPIN" in log file'
+            if "NSPIN == 1" in line:
+                spinful = False
+            elif "NSPIN == 4" in line:
+                spinful = True
+            else:
+                raise ValueError(f'{line} is not supported')
+    if only_S:
+        fermi_level = 0.0
+    else:
+        with open(os.path.join(input_path, data_name, log_file_name), 'r') as f:
+            line = find_target_line(f, "EFERMI")
+            assert line is not None, 'Cannot find "EFERMI" in log file'
+            assert "eV" in line
+            fermi_level = float(line.split()[2])
+            assert find_target_line(f, "EFERMI") is None, "There is more than one EFERMI in log file"
+
+    np.savetxt(os.path.join(output_path, "lat.dat"), np.transpose(lattice))
+    np.savetxt(os.path.join(output_path, "rlat.dat"), np.linalg.inv(lattice) * 2 * np.pi)
+    cart_coords = frac_coords @ lattice
+    np.savetxt(os.path.join(output_path, "site_positions.dat").format(output_path), np.transpose(cart_coords))
+    np.savetxt(os.path.join(output_path, "element.dat"), element, fmt='%d')
+    info = {'nsites' : nsites, 'isorthogonal': False, 'isspinful': spinful, 'norbits': norbits, 'fermi_level': fermi_level}
+    with open('{}/info.json'.format(output_path), 'w') as info_f:
+        json.dump(info, info_f)
+    with open(os.path.join(output_path, "orbital_types.dat"), 'w') as f:
+        for atomic_number in element:
+            for index_l, l in enumerate(orbital_types_dict[atomic_number]):
+                if index_l == 0:
+                    f.write(str(l))
+                else:
+                    f.write(f"  {l}")
+            f.write('\n')
+
+    U_orbital = OrbAbacus2DeepH()
+    def parse_matrix(matrix_path, factor, spinful=False):
+        matrix_dict = dict()
+        with open(matrix_path, 'r') as f:
+            line = f.readline() # read "Matrix Dimension of ..."
+            if not "Matrix Dimension of" in line:
+                line = f.readline() # ABACUS >= 3.0
+                assert "Matrix Dimension of" in line
+            f.readline() # read "Matrix number of ..."
+            norbits = int(line.split()[-1])
+            for line in f:
+                line1 = line.split()
+                if len(line1) == 0:
+                    break
+                num_element = int(line1[3])
+                if num_element != 0:
+                    R_cur = np.array(line1[:3]).astype(int)
+                    line2 = f.readline().split()
+                    line3 = f.readline().split()
+                    line4 = f.readline().split()
+                    if not spinful:
+                        hamiltonian_cur = csr_matrix((np.array(line2).astype(float), np.array(line3).astype(int),
+                                                      np.array(line4).astype(int)), shape=(norbits, norbits)).toarray()
+                    else:
+                        line2 = np.char.replace(line2, '(', '')
+                        line2 = np.char.replace(line2, ')', 'j')
+                        line2 = np.char.replace(line2, ',', '+')
+                        line2 = np.char.replace(line2, '+-', '-')
+                        hamiltonian_cur = csr_matrix((np.array(line2).astype(np.complex128), np.array(line3).astype(int),
+                                                      np.array(line4).astype(int)), shape=(norbits, norbits)).toarray()
+                    for index_site_i in range(nsites):
+                        for index_site_j in range(nsites):
+                            key_str = f"[{R_cur[0]}, {R_cur[1]}, {R_cur[2]}, {index_site_i + 1}, {index_site_j + 1}]"
+                            mat = hamiltonian_cur[(site_norbits_cumsum[index_site_i]
+                                                  - site_norbits[index_site_i]) * (1 + spinful):
+                                                  site_norbits_cumsum[index_site_i] * (1 + spinful),
+                                  (site_norbits_cumsum[index_site_j] - site_norbits[index_site_j]) * (1 + spinful):
+                                  site_norbits_cumsum[index_site_j] * (1 + spinful)]
+                            if abs(mat).max() < 1e-8:
+                                continue
+                            if not spinful:
+                                mat = U_orbital.transform(mat, orbital_types_dict[element[index_site_i]],
+                                                          orbital_types_dict[element[index_site_j]])
+                            else:
+                                mat = mat.reshape((site_norbits[index_site_i], 2, site_norbits[index_site_j], 2))
+                                mat = mat.transpose((1, 0, 3, 2)).reshape((2 * site_norbits[index_site_i],
+                                                                           2 * site_norbits[index_site_j]))
+                                mat = U_orbital.transform(mat, orbital_types_dict[element[index_site_i]] * 2,
+                                                          orbital_types_dict[element[index_site_j]] * 2)
+                            matrix_dict[key_str] = mat * factor
+        return matrix_dict, norbits
+
+    if only_S:
+        overlap_dict, tmp = parse_matrix(os.path.join(input_path, "SR.csr"), 1)
+        assert tmp == norbits
+    else:
+        hamiltonian_dict, tmp = parse_matrix(
+            os.path.join(input_path, data_name, "data-HR-sparse_SPIN0.csr"), 13.605698, # Ryd2eV
+            spinful=spinful)
+        assert tmp == norbits * (1 + spinful)
+        overlap_dict, tmp = parse_matrix(os.path.join(input_path, data_name, "data-SR-sparse_SPIN0.csr"), 1,
+                                         spinful=spinful)
+        assert tmp == norbits * (1 + spinful)
+        if spinful:
+            overlap_dict_spinless = {}
+            for k, v in overlap_dict.items():
+                overlap_dict_spinless[k] = v[:v.shape[0] // 2, :v.shape[1] // 2].real
+            overlap_dict_spinless, overlap_dict = overlap_dict, overlap_dict_spinless
+
+    if not only_S:
+        with h5py.File(os.path.join(output_path, "hamiltonians.h5"), 'w') as fid:
+            for key_str, value in hamiltonian_dict.items():
+                fid[key_str] = value
+    with h5py.File(os.path.join(output_path, "overlaps.h5"), 'w') as fid:
+        for key_str, value in overlap_dict.items():
+            fid[key_str] = value
+    if get_r:
+        def parse_r_matrix(matrix_path, factor):
+            matrix_dict = dict()
+            with open(matrix_path, 'r') as f:
+                line = f.readline();
+                norbits = int(line.split()[-1])
+                for line in f:
+                    line1 = line.split()
+                    if len(line1) == 0:
+                        break
+                    assert len(line1) > 3
+                    R_cur = np.array(line1[:3]).astype(int)
+                    mat_cur = np.zeros((3, norbits * norbits))
+                    for line_index in range(norbits * norbits):
+                        line_mat = f.readline().split()
+                        assert len(line_mat) == 3
+                        mat_cur[:, line_index] = np.array(line_mat)
+                    mat_cur = mat_cur.reshape((3, norbits, norbits))
+
+                    for index_site_i in range(nsites):
+                        for index_site_j in range(nsites):
+                            for direction in range(3):
+                                key_str = f"[{R_cur[0]}, {R_cur[1]}, {R_cur[2]}, {index_site_i + 1}, {index_site_j + 1}, {direction + 1}]"
+                                mat = mat_cur[direction, site_norbits_cumsum[index_site_i]
+                                              - site_norbits[index_site_i]:site_norbits_cumsum[index_site_i],
+                                      site_norbits_cumsum[index_site_j]
+                                      - site_norbits[index_site_j]:site_norbits_cumsum[index_site_j]]
+                                if abs(mat).max() < 1e-8:
+                                    continue
+                                mat = U_orbital.transform(mat, orbital_types_dict[element[index_site_i]],
+                                                          orbital_types_dict[element[index_site_j]])
+                                matrix_dict[key_str] = mat * factor
+            return matrix_dict, norbits
+        position_dict, tmp = parse_r_matrix(os.path.join(input_path, data_name, "data-rR-tr_SPIN1"), 0.529177249) # Bohr2Ang
+        assert tmp == norbits
+
+        with h5py.File(os.path.join(output_path, "positions.h5"), 'w') as fid:
+            for key_str, value in position_dict.items():
+                fid[key_str] = value
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Predict Hamiltonian')
+    parser.add_argument(
+        '-i','--input_dir', type=str, default='./',
+        help='path of output subdirectory'
+        )
+    parser.add_argument(
+        '-o','--output_dir', type=str, default='./',
+        help='path of output .h5 and .dat'
+        )
+    parser.add_argument(
+        '-a','--abacus_suffix', type=str, default='ABACUS',
+        help='suffix of output subdirectory'
+        )
+    parser.add_argument(
+        '-S','--only_S', type=int, default=0
+        )
+    parser.add_argument(
+        '-g','--get_r', type=int, default=0
+        )
+    args = parser.parse_args()
+
+    input_path = args.input_dir
+    output_path = args.output_dir
+    data_name = "OUT." + args.abacus_suffix
+    only_S = bool(args.only_S)
+    get_r = bool(args.get_r)
+    print("only_S: {}".format(only_S))
+    print("get_r: {}".format(get_r))
+    abacus_parse(input_path, output_path, data_name, only_S, get_r)

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/aims_get_data.jl

@@ -0,0 +1,477 @@
+using JSON
+using HDF5
+using LinearAlgebra
+using DelimitedFiles
+using StaticArrays
+using ArgParse
+
+function parse_commandline()
+    s = ArgParseSettings()
+    @add_arg_table! s begin
+        "--input_dir", "-i"
+            help = "NoTB.dat, basis-indices.out, geometry.in"
+            arg_type = String
+            default = "./"
+        "--output_dir", "-o"
+            help = ""
+            arg_type = String
+            default = "./output"
+        "--save_overlap", "-s"
+            help = ""
+            arg_type = Bool
+            default = false
+        "--save_position", "-p"
+            help = ""
+            arg_type = Bool
+            default = false
+    end
+    return parse_args(s)
+end
+parsed_args = parse_commandline()
+
+input_dir = abspath(parsed_args["input_dir"])
+output_dir = abspath(parsed_args["output_dir"])
+
+@assert isfile(joinpath(input_dir, "NoTB.dat"))
+@assert isfile(joinpath(input_dir, "basis-indices.out"))
+@assert isfile(joinpath(input_dir, "geometry.in"))
+
+# @info string("get data from: ", input_dir)
+periodic_table = JSON.parsefile(joinpath(@__DIR__, "periodic_table.json"))
+mkpath(output_dir)
+
+# The function parse_openmx below is come from "https://github.com/HopTB/HopTB.jl"
+f = open(joinpath(input_dir, "NoTB.dat"))
+# number of basis
+@assert occursin("n_basis", readline(f)) # start
+norbits = parse(Int64, readline(f))
+@assert occursin("end", readline(f)) # end
+@assert occursin("n_ham", readline(f)) # start
+nhams = parse(Int64, readline(f))
+@assert occursin("end", readline(f)) # end
+@assert occursin("n_cell", readline(f)) # start
+ncells = parse(Int64, readline(f))
+@assert occursin("end", readline(f)) # end
+# lattice vector
+@assert occursin("lattice_vector", readline(f)) # start
+lat = Matrix{Float64}(I, 3, 3)
+for i in 1:3
+    lat[:, i] = map(x->parse(Float64, x), split(readline(f)))
+end
+@assert occursin("end", readline(f)) # end
+# hamiltonian
+@assert occursin("hamiltonian", readline(f)) # start
+hamiltonian = zeros(nhams)
+i = 1
+while true
+    global i
+    @assert !eof(f)
+    ln = split(readline(f))
+    if occursin("end", ln[1]) break end
+    hamiltonian[i:i + length(ln) - 1] = map(x->parse(Float64, x), ln)
+    i += length(ln)
+end
+# overlaps
+@assert occursin("overlap", readline(f)) # start
+overlaps = zeros(nhams)
+i = 1
+while true
+    global i
+    @assert !eof(f)
+    ln = split(readline(f))
+    if occursin("end", ln[1]) break end
+    overlaps[i:i + length(ln) - 1] = map(x->parse(Float64, x), ln)
+    i += length(ln)
+end
+# index hamiltonian
+@assert occursin("index_hamiltonian", readline(f)) # start
+indexhamiltonian = zeros(Int64, ncells * norbits, 4)
+i = 1
+while true
+    global i
+    @assert !eof(f)
+    ln = split(readline(f))
+    if occursin("end", ln[1]) break end
+    indexhamiltonian[i, :] = map(x->parse(Int64, x), ln)
+    i += 1
+end
+# cell index
+@assert occursin("cell_index", readline(f)) # start
+cellindex = zeros(Int64, ncells, 3)
+i = 1
+while true
+    global i
+    @assert !eof(f)
+    ln = split(readline(f))
+    if occursin("end", ln[1]) break end
+    if i <= ncells
+        cellindex[i, :] = map(x->parse(Int64, x), ln)
+    end
+    i += 1
+end
+# column index hamiltonian
+@assert occursin("column_index_hamiltonian", readline(f)) # start
+columnindexhamiltonian = zeros(Int64, nhams)
+i = 1
+while true
+    global i
+    @assert !eof(f)
+    ln = split(readline(f))
+    if occursin("end", ln[1]) break end
+    columnindexhamiltonian[i:i + length(ln) - 1] = map(x->parse(Int64, x), ln)
+    i += length(ln)
+end
+# positions
+positions = zeros(nhams, 3)
+for dir in 1:3
+    positionsdir = zeros(nhams)
+    @assert occursin("position", readline(f)) # start
+    readline(f) # skip direction
+    i = 1
+    while true
+        @assert !eof(f)
+        ln = split(readline(f))
+        if occursin("end", ln[1]) break end
+        positionsdir[i:i + length(ln) - 1] = map(x->parse(Float64, x), ln)
+        i += length(ln)
+    end
+    positions[:, dir] = positionsdir
+end
+if !eof(f)
+    spinful = true
+    soc_matrix = zeros(nhams, 3)
+    for dir in 1:3
+        socdir = zeros(nhams)
+        @assert occursin("soc_matrix", readline(f)) # start
+        readline(f) # skip direction
+        i = 1
+        while true
+            @assert !eof(f)
+            ln = split(readline(f))
+            if occursin("end", ln[1]) break end
+            socdir[i:i + length(ln) - 1] = map(x->parse(Float64, x), ln)
+            i += length(ln)
+        end
+        soc_matrix[:, dir] = socdir
+    end
+else
+    spinful = false
+end
+close(f)
+
+orbital_types = Array{Array{Int64,1},1}(undef, 0)
+basis_dir = joinpath(input_dir, "basis-indices.out")
+@assert ispath(basis_dir)
+f = open(basis_dir)
+readline(f)
+@assert split(readline(f))[1] == "fn."
+basis_indices = zeros(Int64, norbits, 4)
+for index_orbit in 1:norbits
+    line = map(x->parse(Int64, x), split(readline(f))[[1, 3, 4, 5, 6]])
+    @assert line[1] == index_orbit
+    basis_indices[index_orbit, :] = line[2:5]
+    # basis_indices: 1 ia, 2 n, 3 l, 4 m
+    if size(orbital_types, 1) < line[2]
+        orbital_type = Array{Int64,1}(undef, 0)
+        push!(orbital_types, orbital_type)
+    end
+    if line[4] == line[5]
+        push!(orbital_types[line[2]], line[4])
+    end
+end
+nsites = size(orbital_types, 1)
+site_norbits = (x->sum(x .* 2 .+ 1)).(orbital_types) * (1 + spinful)
+@assert norbits == sum(site_norbits)
+site_norbits_cumsum = cumsum(site_norbits)
+site_indices = zeros(Int64, norbits)
+for index_site in 1:nsites
+    if index_site == 1
+        site_indices[1:site_norbits_cumsum[index_site]] .= index_site
+    else
+        site_indices[site_norbits_cumsum[index_site - 1] + 1:site_norbits_cumsum[index_site]] .= index_site
+    end
+end
+close(f)
+
+f = open(joinpath(input_dir, "geometry.in"))
+# atom_frac_pos = zeros(Float64, 3, nsites)
+element = Array{Int64,1}(undef, 0)
+index_atom = 0
+while !eof(f)
+    line = split(readline(f))
+    if size(line, 1) > 0 && line[1] == "atom_frac"
+        global index_atom
+        index_atom += 1
+        # atom_frac_pos[:, index_atom] = map(x->parse(Float64, x), line[[2, 3, 4]])
+        push!(element, periodic_table[line[5]]["Atomic no"])
+    end
+end
+@assert index_atom == nsites
+# site_positions = lat * atom_frac_pos
+close(f)
+
+@info string("spinful: ", spinful)
+# write to file
+site_positions = fill(NaN, (3, nsites))
+overlaps_dict = Dict{Array{Int64, 1}, Array{Float64, 2}}()
+positions_dict = Dict{Array{Int64, 1}, Array{Float64, 2}}()
+R_list = Set{Vector{Int64}}()
+if spinful
+    hamiltonians_dict = Dict{Array{Int64, 1}, Array{Complex{Float64}, 2}}()
+    @error "spinful not implemented yet"
+    σx = [0 1; 1 0]
+    σy = [0 -im; im 0]
+    σz = [1 0; 0 -1]
+    σ0 = [1 0; 0 1]
+    nm = TBModel{ComplexF64}(2*norbits, lat, isorthogonal=false)
+    # convention here is first half up (spin=0); second half down (spin=1).
+    for i in 1:size(indexhamiltonian, 1)
+        for j in indexhamiltonian[i, 3]:indexhamiltonian[i, 4]
+            for nspin in 0:1
+                for mspin in 0:1
+                    sethopping!(nm,
+                        cellindex[indexhamiltonian[i, 1], :],
+                        columnindexhamiltonian[j] + norbits * nspin,
+                        indexhamiltonian[i, 2] + norbits * mspin,
+                        σ0[nspin + 1, mspin + 1] * hamiltonian[j] -
+                        (σx[nspin + 1, mspin + 1] * soc_matrix[j, 1] +
+                        σy[nspin + 1, mspin + 1] * soc_matrix[j, 2] +
+                        σz[nspin + 1, mspin + 1] * soc_matrix[j, 3]) * im)
+                    setoverlap!(nm,
+                        cellindex[indexhamiltonian[i, 1], :],
+                        columnindexhamiltonian[j] + norbits * nspin,
+                        indexhamiltonian[i, 2] + norbits * mspin,
+                        σ0[nspin + 1, mspin + 1] * overlaps[j])
+                end
+            end
+        end
+    end
+    for i in 1:size(indexhamiltonian, 1)
+        for j in indexhamiltonian[i, 3]:indexhamiltonian[i, 4]
+            for nspin in 0:1
+                for mspin in 0:1
+                    for dir in 1:3
+                        setposition!(nm,
+                            cellindex[indexhamiltonian[i, 1], :],
+                            columnindexhamiltonian[j] + norbits * nspin,
+                            indexhamiltonian[i, 2] + norbits * mspin,
+                            dir,
+                            σ0[nspin + 1, mspin + 1] * positions[j, dir])
+                    end
+                end
+            end
+        end
+    end
+    return nm
+else
+    hamiltonians_dict = Dict{Array{Int64, 1}, Array{Float64, 2}}()
+
+    for i in 1:size(indexhamiltonian, 1)
+        for j in indexhamiltonian[i, 3]:indexhamiltonian[i, 4]
+            R = cellindex[indexhamiltonian[i, 1], :]
+            push!(R_list, SVector{3, Int64}(R))
+            orbital_i_whole = columnindexhamiltonian[j]
+            orbital_j_whole = indexhamiltonian[i, 2]
+            site_i = site_indices[orbital_i_whole]
+            site_j = site_indices[orbital_j_whole]
+            block_matrix_i = orbital_i_whole - site_norbits_cumsum[site_i] + site_norbits[site_i]
+            block_matrix_j = orbital_j_whole - site_norbits_cumsum[site_j] + site_norbits[site_j]
+            key = cat(dims=1, R, site_i, site_j)
+            key_inv = cat(dims=1, -R, site_j, site_i)
+            
+            mi = 0
+            mj = 0
+            # p-orbital
+            if basis_indices[orbital_i_whole, 3] == 1
+                if basis_indices[orbital_i_whole, 4] == -1
+                    block_matrix_i += 1
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == 0
+                    block_matrix_i += 1
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == 1
+                    block_matrix_i += -2
+                    mi = 1
+                end
+            end
+            if basis_indices[orbital_j_whole, 3] == 1
+                if basis_indices[orbital_j_whole, 4] == -1
+                    block_matrix_j += 1
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == 0
+                    block_matrix_j += 1
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == 1
+                    block_matrix_j += -2
+                    mj = 1
+                end
+            end
+            # d-orbital
+            if basis_indices[orbital_i_whole, 3] == 2
+                if basis_indices[orbital_i_whole, 4] == -2
+                    block_matrix_i += 2
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == -1
+                    block_matrix_i += 3
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == 0
+                    block_matrix_i += -2
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == 1
+                    block_matrix_i += 0
+                    mi = 1
+                elseif basis_indices[orbital_i_whole, 4] == 2
+                    block_matrix_i += -3
+                    mi = 0
+                end
+            end
+            if basis_indices[orbital_j_whole, 3] == 2
+                if basis_indices[orbital_j_whole, 4] == -2
+                    block_matrix_j += 2
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == -1
+                    block_matrix_j += 3
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == 0
+                    block_matrix_j += -2
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == 1
+                    block_matrix_j += 0
+                    mj = 1
+                elseif basis_indices[orbital_j_whole, 4] == 2
+                    block_matrix_j += -3
+                    mj = 0
+                end
+            end
+            # f-orbital
+            if basis_indices[orbital_i_whole, 3] == 3
+                if basis_indices[orbital_i_whole, 4] == -3
+                    block_matrix_i += 6
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == -2
+                    block_matrix_i += 3
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == -1
+                    block_matrix_i += 0
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == 0
+                    block_matrix_i += -3
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == 1
+                    block_matrix_i += -3
+                    mi = 1
+                elseif basis_indices[orbital_i_whole, 4] == 2
+                    block_matrix_i += -2
+                    mi = 0
+                elseif basis_indices[orbital_i_whole, 4] == 3
+                    block_matrix_i += -1
+                    mi = 1
+                end
+            end
+            if basis_indices[orbital_j_whole, 3] == 3
+                if basis_indices[orbital_j_whole, 4] == -3
+                    block_matrix_j += 6
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == -2
+                    block_matrix_j += 3
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == -1
+                    block_matrix_j += 0
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == 0
+                    block_matrix_j += -3
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == 1
+                    block_matrix_j += -3
+                    mj = 1
+                elseif basis_indices[orbital_j_whole, 4] == 2
+                    block_matrix_j += -2
+                    mj = 0
+                elseif basis_indices[orbital_j_whole, 4] == 3
+                    block_matrix_j += -1
+                    mj = 1
+                end
+            end
+            if (basis_indices[orbital_i_whole, 3] > 3) || (basis_indices[orbital_j_whole, 3] > 3)
+                @error("The case of l>3 is not implemented")
+            end
+
+            if !(key ∈ keys(hamiltonians_dict))
+                # overlaps_dict[key] = fill(convert(Float64, NaN), (site_norbits[site_i], site_norbits[site_j]))
+                overlaps_dict[key] = zeros(Float64, site_norbits[site_i], site_norbits[site_j])
+                hamiltonians_dict[key] = zeros(Float64, site_norbits[site_i], site_norbits[site_j])
+                for direction in 1:3
+                    positions_dict[cat(dims=1, key, direction)] = zeros(Float64, site_norbits[site_i], site_norbits[site_j])
+                end
+            end
+            if !(key_inv ∈ keys(hamiltonians_dict))
+                overlaps_dict[key_inv] = zeros(Float64, site_norbits[site_j], site_norbits[site_i])
+                hamiltonians_dict[key_inv] = zeros(Float64, site_norbits[site_j], site_norbits[site_i])
+                for direction in 1:3
+                    positions_dict[cat(dims=1, key_inv, direction)] = zeros(Float64, site_norbits[site_j], site_norbits[site_i])
+                end
+            end
+            overlaps_dict[key][block_matrix_i, block_matrix_j] = overlaps[j] * (-1) ^ (mi + mj)
+            hamiltonians_dict[key][block_matrix_i, block_matrix_j] = hamiltonian[j] * (-1) ^ (mi + mj)
+            for direction in 1:3
+                positions_dict[cat(dims=1, key, direction)][block_matrix_i, block_matrix_j] = positions[j, direction] * (-1) ^ (mi + mj)
+            end
+
+            overlaps_dict[key_inv][block_matrix_j, block_matrix_i] = overlaps[j] * (-1) ^ (mi + mj)
+            hamiltonians_dict[key_inv][block_matrix_j, block_matrix_i] = hamiltonian[j] * (-1) ^ (mi + mj)
+            for direction in 1:3
+                positions_dict[cat(dims=1, key_inv, direction)][block_matrix_j, block_matrix_i] = positions[j, direction] * (-1) ^ (mi + mj)
+                if (R == [0, 0, 0]) && (block_matrix_i == block_matrix_j) && isnan(site_positions[direction, site_i])
+                    site_positions[direction, site_i] = positions[j, direction]
+                end
+            end
+        end
+    end
+end
+
+if parsed_args["save_overlap"]
+    h5open(joinpath(output_dir, "overlaps.h5"), "w") do fid
+        for (key, overlap) in overlaps_dict
+            write(fid, string(key), permutedims(overlap))
+        end
+    end
+end
+h5open(joinpath(output_dir, "hamiltonians.h5"), "w") do fid
+    for (key, hamiltonian) in hamiltonians_dict
+        write(fid, string(key), permutedims(hamiltonian)) # npz似乎为julia专门做了个转置而h5没有做
+    end
+end
+if parsed_args["save_position"]
+    h5open(joinpath(output_dir, "positions.h5"), "w") do fid
+        for (key, position) in positions_dict
+            write(fid, string(key), permutedims(position)) # npz似乎为julia专门做了个转置而h5没有做
+        end
+    end
+end
+
+open(joinpath(output_dir, "orbital_types.dat"), "w") do f
+    writedlm(f, orbital_types)
+end
+open(joinpath(output_dir, "lat.dat"), "w") do f
+    writedlm(f, lat)
+end
+rlat = 2pi * inv(lat)'
+open(joinpath(output_dir, "rlat.dat"), "w") do f
+    writedlm(f, rlat)
+end
+open(joinpath(output_dir, "site_positions.dat"), "w") do f
+    writedlm(f, site_positions)
+end
+R_list = collect(R_list)
+open(joinpath(output_dir, "R_list.dat"), "w") do f
+    writedlm(f, R_list)
+end
+info_dict = Dict(
+    "isspinful" => spinful
+    )
+open(joinpath(output_dir, "info.json"), "w") do f
+    write(f, json(info_dict, 4))
+end
+open(joinpath(output_dir, "element.dat"), "w") do f
+    writedlm(f, element)
+end

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/get_rc.py

@@ -0,0 +1,165 @@
+import os
+import json
+
+import h5py
+import numpy as np
+import torch
+
+
+class Neighbours:
+    def __init__(self):
+        self.Rs = []
+        self.dists = []
+        self.eijs = []
+        self.indices = []
+
+    def __str__(self):
+        return 'Rs: {}\ndists: {}\neijs: {}\nindices: {}'.format(
+            self.Rs, self.dists, self.indices, self.eijs)
+
+
+def _get_local_coordinate(eij, neighbours_i, gen_rc_idx=False, atom_j=None, atom_j_R=None, r2_rand=False):
+    if gen_rc_idx:
+        rc_idx = np.full(8, np.nan, dtype=np.int32)
+        assert r2_rand is False
+        assert atom_j is not None, 'atom_j must be specified when gen_rc_idx is True'
+        assert atom_j_R is not None, 'atom_j_R must be specified when gen_rc_idx is True'
+    else:
+        rc_idx = None
+    if r2_rand:
+        r2_list = []
+
+    if not np.allclose(eij.detach(), torch.zeros_like(eij)):
+        r1 = eij
+        if gen_rc_idx:
+            rc_idx[0] = atom_j
+            rc_idx[1:4] = atom_j_R
+    else:
+        r1 = neighbours_i.eijs[1]
+        if gen_rc_idx:
+            rc_idx[0] = neighbours_i.indices[1]
+            rc_idx[1:4] = neighbours_i.Rs[1]
+    r2_flag = None
+    for r2, r2_index, r2_R in zip(neighbours_i.eijs[1:], neighbours_i.indices[1:], neighbours_i.Rs[1:]):
+        if torch.norm(torch.cross(r1, r2)) > 1e-6:
+            if gen_rc_idx:
+                rc_idx[4] = r2_index
+                rc_idx[5:8] = r2_R
+            r2_flag = True
+            if r2_rand:
+                if (len(r2_list) == 0) or (torch.norm(r2_list[0]) + 0.5 > torch.norm(r2)):
+                    r2_list.append(r2)
+                else:
+                    break
+            else:
+                break
+    assert r2_flag is not None, "There is no linear independent chemical bond in the Rcut range, this may be caused by a too small Rcut or the structure is 1D"
+    if r2_rand:
+        # print(f"r2 is randomly chosen from {len(r2_list)} candidates")
+        r2 = r2_list[np.random.randint(len(r2_list))]
+    local_coordinate_1 = r1 / torch.norm(r1)
+    local_coordinate_2 = torch.cross(r1, r2) / torch.norm(torch.cross(r1, r2))
+    local_coordinate_3 = torch.cross(local_coordinate_1, local_coordinate_2)
+    return torch.stack([local_coordinate_1, local_coordinate_2, local_coordinate_3], dim=-1), rc_idx
+
+
+def get_rc(input_dir, output_dir, radius, r2_rand=False, gen_rc_idx=False, gen_rc_by_idx="", create_from_DFT=True, neighbour_file='overlaps.h5', if_require_grad=False, cart_coords=None):
+    if not if_require_grad:
+        assert os.path.exists(os.path.join(input_dir, 'site_positions.dat')), 'No site_positions.dat found in {}'.format(input_dir)
+        cart_coords = torch.tensor(np.loadtxt(os.path.join(input_dir, 'site_positions.dat')).T)
+    else:
+        assert cart_coords is not None, 'cart_coords must be provided if "if_require_grad" is True'
+    assert os.path.exists(os.path.join(input_dir, 'lat.dat')), 'No lat.dat found in {}'.format(input_dir)
+    lattice = torch.tensor(np.loadtxt(os.path.join(input_dir, 'lat.dat')).T, dtype=cart_coords.dtype)
+
+    rc_dict = {}
+    if gen_rc_idx:
+        assert r2_rand is False, 'r2_rand must be False when gen_rc_idx is True'
+        assert gen_rc_by_idx == "", 'gen_rc_by_idx must be "" when gen_rc_idx is True'
+        rc_idx_dict = {}
+    neighbours_dict = {}
+    if gen_rc_by_idx != "":
+        # print(f'get local coordinate using {os.path.join(gen_rc_by_idx, "rc_idx.h5")} from: {input_dir}')
+        assert os.path.exists(os.path.join(gen_rc_by_idx, "rc_idx.h5")), 'Atomic indices for constructing rc rc_idx.h5 is not found in {}'.format(gen_rc_by_idx)
+        fid_rc_idx = h5py.File(os.path.join(gen_rc_by_idx, "rc_idx.h5"), 'r')
+        for key_str, rc_idx in fid_rc_idx.items():
+            key = json.loads(key_str)
+            # R = torch.tensor([key[0], key[1], key[2]])
+            atom_i = key[3] - 1
+            cart_coords_i = cart_coords[atom_i]
+
+            r1 = cart_coords[rc_idx[0]] + torch.tensor(rc_idx[1:4]).type(cart_coords.dtype) @ lattice - cart_coords_i
+            r2 = cart_coords[rc_idx[4]] + torch.tensor(rc_idx[5:8]).type(cart_coords.dtype) @ lattice - cart_coords_i
+            local_coordinate_1 = r1 / torch.norm(r1)
+            local_coordinate_2 = torch.cross(r1, r2) / torch.norm(torch.cross(r1, r2))
+            local_coordinate_3 = torch.cross(local_coordinate_1, local_coordinate_2)
+
+            rc_dict[key_str] = torch.stack([local_coordinate_1, local_coordinate_2, local_coordinate_3], dim=-1)
+        fid_rc_idx.close()
+    else:
+        # print("get local coordinate from:", input_dir)
+        if create_from_DFT:
+            assert os.path.exists(os.path.join(input_dir, neighbour_file)), 'No {} found in {}'.format(neighbour_file, input_dir)
+            fid_OLP = h5py.File(os.path.join(input_dir, neighbour_file), 'r')
+            for key_str in fid_OLP.keys():
+                key = json.loads(key_str)
+                R = torch.tensor([key[0], key[1], key[2]])
+                atom_i = key[3] - 1
+                atom_j = key[4] - 1
+                cart_coords_i = cart_coords[atom_i]
+                cart_coords_j = cart_coords[atom_j] + R.type(cart_coords.dtype) @ lattice
+                eij = cart_coords_j - cart_coords_i
+                dist = torch.norm(eij)
+                if radius > 0 and dist > radius:
+                    continue
+                if atom_i not in neighbours_dict:
+                    neighbours_dict[atom_i] = Neighbours()
+                neighbours_dict[atom_i].Rs.append(R)
+                neighbours_dict[atom_i].dists.append(dist)
+                neighbours_dict[atom_i].eijs.append(eij)
+                neighbours_dict[atom_i].indices.append(atom_j)
+
+            for atom_i, neighbours_i in neighbours_dict.items():
+                neighbours_i.Rs = torch.stack(neighbours_i.Rs)
+                neighbours_i.dists = torch.tensor(neighbours_i.dists, dtype=cart_coords.dtype)
+                neighbours_i.eijs = torch.stack(neighbours_i.eijs)
+                neighbours_i.indices = torch.tensor(neighbours_i.indices)
+
+                neighbours_i.dists, sorted_index = torch.sort(neighbours_i.dists)
+                neighbours_i.Rs = neighbours_i.Rs[sorted_index]
+                neighbours_i.eijs = neighbours_i.eijs[sorted_index]
+                neighbours_i.indices = neighbours_i.indices[sorted_index]
+
+                assert np.allclose(neighbours_i.eijs[0].detach(), torch.zeros_like(neighbours_i.eijs[0])), 'eijs[0] should be zero'
+
+                for R, eij, atom_j, atom_j_R in zip(neighbours_i.Rs, neighbours_i.eijs, neighbours_i.indices, neighbours_i.Rs):
+                    key_str = str(list([*R.tolist(), atom_i + 1, atom_j.item() + 1]))
+                    if gen_rc_idx:
+                        rc_dict[key_str], rc_idx_dict[key_str] = _get_local_coordinate(eij, neighbours_i, gen_rc_idx, atom_j, atom_j_R)
+                    else:
+                        rc_dict[key_str] = _get_local_coordinate(eij, neighbours_i, r2_rand=r2_rand)[0]
+        else:
+            raise NotImplementedError
+
+        if create_from_DFT:
+            fid_OLP.close()
+
+    if if_require_grad:
+        return rc_dict
+    else:
+        if os.path.exists(os.path.join(output_dir, 'rc_julia.h5')):
+            rc_old_flag = True
+            fid_rc_old = h5py.File(os.path.join(output_dir, 'rc_julia.h5'), 'r')
+        else:
+            rc_old_flag = False
+        fid_rc = h5py.File(os.path.join(output_dir, 'rc.h5'), 'w')
+        for k, v in rc_dict.items():
+            if rc_old_flag:
+                assert np.allclose(v, fid_rc_old[k][...], atol=1e-4), f"{k}, {v}, {fid_rc_old[k][...]}"
+            fid_rc[k] = v
+        fid_rc.close()
+        if gen_rc_idx:
+            fid_rc_idx = h5py.File(os.path.join(output_dir, 'rc_idx.h5'), 'w')
+            for k, v in rc_idx_dict.items():
+                fid_rc_idx[k] = v
+            fid_rc_idx.close()

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/openmx_get_data.jl

@@ -0,0 +1,471 @@
+using StaticArrays
+using LinearAlgebra
+using HDF5
+using JSON
+using DelimitedFiles
+using Statistics
+using ArgParse
+
+function parse_commandline()
+    s = ArgParseSettings()
+    @add_arg_table! s begin
+        "--input_dir", "-i"
+            help = ""
+            arg_type = String
+            default = "./"
+        "--output_dir", "-o"
+            help = ""
+            arg_type = String
+            default = "./output"
+        "--if_DM", "-d"
+            help = ""
+            arg_type = Bool
+            default = false
+       "--save_overlap", "-s"
+            help = ""
+            arg_type = Bool
+            default = false
+    end
+    return parse_args(s)
+end
+parsed_args = parse_commandline()
+
+# @info string("get data from: ", parsed_args["input_dir"])
+periodic_table = JSON.parsefile(joinpath(@__DIR__, "periodic_table.json"))
+
+#=
+struct Site_list
+    R::Array{StaticArrays.SArray{Tuple{3},Int16,1,3},1}
+    site::Array{Int64,1}
+    pos::Array{Float64,2}
+end
+
+function _cal_neighbour_site(e_ij::Array{Float64,2},Rcut::Float64)
+    r_ij = sum(dims=1,e_ij.^2)[1,:]
+    p = sortperm(r_ij)
+    j_cut = searchsorted(r_ij[p],Rcut^2).stop
+    return p[1:j_cut]
+end
+
+function cal_neighbour_site(site_positions::Matrix{<:Real}, lat::Matrix{<:Real}, R_list::Union{Vector{SVector{3, Int64}}, Vector{Vector{Int64}}}, nsites::Int64, Rcut::Float64)
+    # writed by lihe
+    neighbour_site = Array{Site_list,1}([])
+    # R_list = collect(keys(tm.hoppings))
+    pos_R_list = map(R -> collect(lat * R), R_list)
+    pos_j_list = cat(dims=2, map(pos_R -> pos_R .+ site_positions, pos_R_list)...)
+    for site_i in 1:nsites
+        pos_i = site_positions[:, site_i]
+        e_ij = pos_j_list .- pos_i
+        p = _cal_neighbour_site(e_ij, Rcut)
+        R_ordered = R_list[map(x -> div(x + (nsites - 1), nsites),p)]
+        site_ordered = map(x -> mod(x - 1, nsites) + 1,p)
+        pos_ordered = e_ij[:,p]
+        @assert pos_ordered[:,1] ≈ [0,0,0]
+        push!(neighbour_site, Site_list(R_ordered, site_ordered, pos_ordered))
+    end
+    return neighbour_site
+end
+
+function _get_local_coordinate(e_ij::Array{Float64,1},site_list_i::Site_list)
+    if e_ij != [0,0,0]
+        r1 = e_ij
+    else
+        r1 = site_list_i.pos[:,2]
+    end
+    nsites_i = length(site_list_i.R)
+    r2 = [0,0,0]
+    for j in 1:nsites_i
+        r2 = site_list_i.pos[:,j]
+        if norm(cross(r1,r2)) != 0
+            break
+        end
+        if j == nsites_i
+            for k in 1:3
+                r2 = [[1,0,0],[0,1,0],[0,0,1]][k]
+                if norm(cross(r1,r2)) != 0
+                    break
+                end
+            end
+        end
+    end
+    if r2 == [0,0,0]
+        error("there is no linear independent chemical bond in the Rcut range, this may be caused by a too small  Rcut or the structure  is1D")
+    end
+    local_coordinate = zeros(Float64,(3,3))
+    local_coordinate[:,1] = r1/norm(r1)
+
+    local_coordinate[:,2] = cross(r1,r2)/norm(cross(r1,r2))
+    local_coordinate[:,3] = cross(local_coordinate[:,1],local_coordinate[:,2])
+    return local_coordinate
+end
+
+function get_local_coordinates(site_positions::Matrix{<:Real}, lat::Matrix{<:Real}, R_list::Vector{SVector{3, Int64}}, Rcut::Float64)::Dict{Array{Int64,1},Array{Float64,2}}
+    nsites = size(site_positions, 2)
+    neighbour_site = cal_neighbour_site(site_positions, lat, R_list, nsites, Rcut)
+    local_coordinates = Dict{Array{Int64,1},Array{Float64,2}}()
+    for site_i = 1:nsites
+        site_list_i = neighbour_site[site_i]
+        nsites_i = length(site_list_i.R)
+        for j = 1:nsites_i
+            R = site_list_i.R[j]; site_j = site_list_i.site[j]; e_ij = site_list_i.pos[:,j]
+            local_coordinate = _get_local_coordinate(e_ij, site_list_i)
+            local_coordinates[cat(dims=1, R, site_i, site_j)] = local_coordinate
+        end
+    end
+    return local_coordinates
+end
+=#
+
+# The function parse_openmx below is come from "https://github.com/HopTB/HopTB.jl"
+function parse_openmx(filepath::String; return_DM::Bool = false)
+    # define some helper functions for mixed structure of OpenMX binary data file.
+    function multiread(::Type{T}, f, size)::Vector{T} where T
+        ret = Vector{T}(undef, size)
+        read!(f, ret);ret
+    end
+    multiread(f, size) = multiread(Int32, f, size)
+
+    function read_mixed_matrix(::Type{T}, f, dims::Vector{<:Integer}) where T
+        ret::Vector{Vector{T}} = []
+        for i = dims; t = Vector{T}(undef, i);read!(f, t);push!(ret, t); end; ret
+    end
+
+    function read_matrix_in_mixed_matrix(::Type{T}, f, spins, atomnum, FNAN, natn, Total_NumOrbs) where T
+        ret = Vector{Vector{Vector{Matrix{T}}}}(undef, spins)
+        for spin = 1:spins;t_spin = Vector{Vector{Matrix{T}}}(undef, atomnum)
+            for ai = 1:atomnum;t_ai = Vector{Matrix{T}}(undef, FNAN[ai])
+                for aj_inner = 1:FNAN[ai]
+                    t = Matrix{T}(undef, Total_NumOrbs[natn[ai][aj_inner]], Total_NumOrbs[ai])
+                    read!(f, t);t_ai[aj_inner] = t
+                end;t_spin[ai] = t_ai
+            end;ret[spin] = t_spin
+        end;return ret
+    end
+    read_matrix_in_mixed_matrix(f, spins, atomnum, FNAN, natn, Total_NumOrbs) = read_matrix_in_mixed_matrix(Float64, f, spins, atomnum, FNAN, natn, Total_NumOrbs)
+
+    read_3d_vecs(::Type{T}, f, num) where T = reshape(multiread(T, f, 4 * num), 4, Int(num))[2:4,:]
+    read_3d_vecs(f, num) = read_3d_vecs(Float64, f, num)
+    # End of helper functions
+
+    bound_multiread(T, size) = multiread(T, f, size)
+    bound_multiread(size) = multiread(f, size)
+    bound_read_mixed_matrix() = read_mixed_matrix(Int32, f, FNAN)
+    bound_read_matrix_in_mixed_matrix(spins) = read_matrix_in_mixed_matrix(f, spins, atomnum, FNAN, natn, Total_NumOrbs)
+    bound_read_3d_vecs(num) = read_3d_vecs(f, num)
+    bound_read_3d_vecs(::Type{T}, num) where T = read_3d_vecs(T, f, num)
+    # End of bound helper functions
+
+    f = open(filepath)
+    atomnum, SpinP_switch, Catomnum, Latomnum, Ratomnum, TCpyCell, order_max = bound_multiread(7)
+    @assert (SpinP_switch >> 2) == 3 "DeepH-pack only supports OpenMX v3.9. Please check your OpenMX version"
+    SpinP_switch &= 0x03
+
+    atv, atv_ijk = bound_read_3d_vecs.([Float64,Int32], TCpyCell + 1)
+
+    Total_NumOrbs, FNAN = bound_multiread.([atomnum,atomnum])
+    FNAN .+= 1
+    natn = bound_read_mixed_matrix()
+    ncn = ((x)->x .+ 1).(bound_read_mixed_matrix()) # These is to fix that atv and atv_ijk starts from 0 in original C code.
+
+    tv, rtv, Gxyz = bound_read_3d_vecs.([3,3,atomnum])
+
+    Hk = bound_read_matrix_in_mixed_matrix(SpinP_switch + 1)
+    iHk = SpinP_switch == 3 ? bound_read_matrix_in_mixed_matrix(3) : nothing
+    OLP = bound_read_matrix_in_mixed_matrix(1)[1]
+    OLP_r = []
+    for dir in 1:3, order in 1:order_max
+        t = bound_read_matrix_in_mixed_matrix(1)[1]
+        if order == 1 push!(OLP_r, t) end
+    end
+    OLP_p = bound_read_matrix_in_mixed_matrix(3)
+    DM = bound_read_matrix_in_mixed_matrix(SpinP_switch + 1)
+    iDM = bound_read_matrix_in_mixed_matrix(2)
+    solver = bound_multiread(1)[1]
+    chem_p, E_temp = bound_multiread(Float64, 2)
+    dipole_moment_core, dipole_moment_background = bound_multiread.(Float64, [3,3])
+    Valence_Electrons, Total_SpinS = bound_multiread(Float64, 2)
+    dummy_blocks = bound_multiread(1)[1]
+    for i in 1:dummy_blocks
+        bound_multiread(UInt8, 256)
+    end
+
+    # we suppose that the original output file(.out) was appended to the end of the scfout file.
+    function strip1(s::Vector{UInt8})
+        startpos = 0
+        for i = 1:length(s) + 1
+            if i > length(s) || s[i] & 0x80 != 0 || !isspace(Char(s[i] & 0x7f))
+                startpos = i
+                break
+            end
+        end
+        return s[startpos:end]
+    end
+    function startswith1(s::Vector{UInt8}, prefix::Vector{UInt8})
+        return length(s) >= length(prefix) && s[1:length(prefix)] == prefix
+    end
+    function isnum(s::Char)
+        if s >= '1' && s <= '9'
+            return true
+        else
+            return false
+        end
+    end
+
+    function isorb(s::Char)
+        if s in ['s','p','d','f']
+            return true
+        else
+            return false
+        end
+    end
+
+    function orbital_types_str2num(str::AbstractString)
+        orbs = split(str, isnum, keepempty = false)
+        nums = map(x->parse(Int, x), split(str, isorb, keepempty = false))
+        orb2l = Dict("s" => 0, "p" => 1, "d" => 2, "f" => 3)
+        @assert length(orbs) == length(nums)
+        orbital_types = Array{Int64,1}(undef, 0)
+        for (orb, num) in zip(orbs, nums)
+            for i = 1:num
+                push!(orbital_types, orb2l[orb])
+            end
+        end
+        return orbital_types
+    end
+
+    function find_target_line(target_line::String)
+        target_line_UInt8 = Vector{UInt8}(target_line)
+        while !startswith1(strip1(Vector{UInt8}(readline(f))), target_line_UInt8)
+            if eof(f)
+                error(string(target_line, "not found. Please check if the .out file was appended to the end of .scfout file!"))
+            end
+        end
+    end
+
+#     @info """get orbital setting of element:orbital_types_element::Dict{String,Array{Int64,1}} "element" => orbital_types"""
+    find_target_line("<Definition.of.Atomic.Species")
+    orbital_types_element = Dict{String,Array{Int64,1}}([])
+    while true
+        str = readline(f)
+        if str == "Definition.of.Atomic.Species>"
+            break
+        end
+        element = split(str)[1]
+        orbital_types_str = split(split(str)[2], "-")[2]
+        orbital_types_element[element] = orbital_types_str2num(orbital_types_str)
+    end
+
+    
+#     @info "get Chemical potential (Hartree)"
+    find_target_line("(see also PRB 72, 045121(2005) for the energy contributions)")
+    readline(f)
+    readline(f)
+    readline(f)
+    str = split(readline(f))
+    @assert "Chemical" == str[1]
+    @assert "potential" == str[2]
+    @assert "(Hartree)" == str[3]
+    ev2Hartree = 0.036749324533634074
+    fermi_level = parse(Float64, str[length(str)])/ev2Hartree
+
+    # @info "get Chemical potential (Hartree)"
+    # find_target_line("Eigenvalues (Hartree)")
+    # for i = 1:2;@assert readline(f) == "***********************************************************";end
+    # readline(f)
+    # str = split(readline(f))
+    # ev2Hartree = 0.036749324533634074
+    # fermi_level = parse(Float64, str[length(str)])/ev2Hartree
+    
+
+#     @info "get Fractional coordinates & orbital types:"
+    find_target_line("Fractional coordinates of the final structure")
+    target_line = Vector{UInt8}("Fractional coordinates of the final structure")
+    for i = 1:2;@assert readline(f) == "***********************************************************";end
+    @assert readline(f) == ""
+    orbital_types = Array{Array{Int64,1},1}(undef, 0) #orbital_types
+    element = Array{Int64,1}(undef, 0) #orbital_types
+    atom_frac_pos = zeros(3, atomnum) #Fractional coordinates
+    for i = 1:atomnum
+        str = readline(f)
+        element_str = split(str)[2]
+        push!(orbital_types, orbital_types_element[element_str])
+        m = match(r"^\s*\d+\s+\w+\s+([0-9+-.Ee]+)\s+([0-9+-.Ee]+)\s+([0-9+-.Ee]+)", str)
+        push!(element, periodic_table[element_str]["Atomic no"])
+        atom_frac_pos[:,i] = ((x)->parse(Float64, x)).(m.captures)
+    end
+    atom_pos = tv * atom_frac_pos
+    close(f)
+
+    # use the atom_pos to fix
+    # TODO: Persuade wangc to accept the following code, which seems hopeless and meaningless.
+    """
+    for axis = 1:3
+        ((x2, y2, z)->((x, y)->x .+= z * y).(x2, y2)).(OLP_r[axis], OLP, atom_pos[axis,:])
+    end
+    """
+    for axis in 1:3,i in 1:atomnum, j in 1:FNAN[i]
+        OLP_r[axis][i][j] .+= atom_pos[axis,i] * OLP[i][j]
+    end
+
+    # fix type mismatch
+    atv_ijk = Matrix{Int64}(atv_ijk)
+
+    if return_DM
+        return element, atomnum, SpinP_switch, atv, atv_ijk, Total_NumOrbs, FNAN, natn, ncn, tv, Hk, iHk, OLP, OLP_r, orbital_types, fermi_level, atom_pos, DM
+    else
+        return element, atomnum, SpinP_switch, atv, atv_ijk, Total_NumOrbs, FNAN, natn, ncn, tv, Hk, iHk, OLP, OLP_r, orbital_types, fermi_level, atom_pos, nothing
+    end
+end
+
+function get_data(filepath_scfout::String, Rcut::Float64; if_DM::Bool = false)
+    element, nsites, SpinP_switch, atv, atv_ijk, Total_NumOrbs, FNAN, natn, ncn, lat, Hk, iHk, OLP, OLP_r, orbital_types, fermi_level, site_positions, DM = parse_openmx(filepath_scfout; return_DM=if_DM)
+
+    for t in [Hk, iHk]
+        if t != nothing
+            ((x)->((y)->((z)->z .*= 27.2113845).(y)).(x)).(t) # Hartree to eV
+        end
+    end
+    site_positions .*= 0.529177249 # Bohr to Ang
+    lat .*= 0.529177249 # Bohr to Ang
+
+    # get R_list
+    R_list = Set{Vector{Int64}}()
+    for atom_i in 1:nsites, index_nn_i in 1:FNAN[atom_i]
+        atom_j = natn[atom_i][index_nn_i]
+        R = atv_ijk[:, ncn[atom_i][index_nn_i]]
+        push!(R_list, SVector{3, Int64}(R))
+    end
+    R_list = collect(R_list)
+
+    # get neighbour_site
+    nsites = size(site_positions, 2)
+    # neighbour_site = cal_neighbour_site(site_positions, lat, R_list, nsites, Rcut)
+    # local_coordinates = Dict{Array{Int64, 1}, Array{Float64, 2}}()
+
+    # process hamiltonian
+    norbits = sum(Total_NumOrbs)
+    overlaps = Dict{Array{Int64, 1}, Array{Float64, 2}}()
+    if SpinP_switch == 0
+        spinful = false
+        hamiltonians = Dict{Array{Int64, 1}, Array{Float64, 2}}()
+        if if_DM
+            density_matrixs = Dict{Array{Int64, 1}, Array{Float64, 2}}()
+        else
+            density_matrixs = nothing
+        end
+    elseif SpinP_switch == 1
+        error("Collinear spin is not supported currently")
+    elseif SpinP_switch == 3
+        @assert if_DM == false
+        density_matrixs = nothing
+        spinful = true
+        for i in 1:length(Hk[4]),j in 1:length(Hk[4][i])
+            Hk[4][i][j] += iHk[3][i][j]
+            iHk[3][i][j] = -Hk[4][i][j]
+        end
+        hamiltonians = Dict{Array{Int64, 1}, Array{Complex{Float64}, 2}}()
+    else
+        error("SpinP_switch is $SpinP_switch, rather than valid values 0, 1 or 3")
+    end
+
+    for site_i in 1:nsites, index_nn_i in 1:FNAN[site_i]
+        site_j = natn[site_i][index_nn_i]
+        R = atv_ijk[:, ncn[site_i][index_nn_i]]
+        e_ij = lat * R + site_positions[:, site_j] - site_positions[:, site_i]
+        # if norm(e_ij) > Rcut
+            # continue
+        # end
+        key = cat(dims=1, R, site_i, site_j)
+        # site_list_i = neighbour_site[site_i]
+        # local_coordinate = _get_local_coordinate(e_ij, site_list_i)
+        # local_coordinates[key] = local_coordinate
+        
+        overlap = permutedims(OLP[site_i][index_nn_i])
+        overlaps[key] = overlap
+        if SpinP_switch == 0
+            hamiltonian = permutedims(Hk[1][site_i][index_nn_i])
+            hamiltonians[key] = hamiltonian
+            if if_DM
+                density_matrix = permutedims(DM[1][site_i][index_nn_i])
+                density_matrixs[key] = density_matrix
+            end
+        elseif SpinP_switch == 1
+            error("Collinear spin is not supported currently")
+        elseif SpinP_switch == 3
+            key_inv = cat(dims=1, -R, site_j, site_i)
+
+            len_i_wo_spin = Total_NumOrbs[site_i]
+            len_j_wo_spin = Total_NumOrbs[site_j]
+    
+            if !(key in keys(hamiltonians))
+                @assert !(key_inv in keys(hamiltonians))
+                hamiltonians[key] = zeros(Complex{Float64}, len_i_wo_spin * 2, len_j_wo_spin * 2)
+                hamiltonians[key_inv] = zeros(Complex{Float64}, len_j_wo_spin * 2, len_i_wo_spin * 2)
+            end
+            for spini in 0:1,spinj in spini:1
+                Hk_real, Hk_imag = spini == 0 ? spinj == 0 ? (Hk[1][site_i][index_nn_i], iHk[1][site_i][index_nn_i]) : (Hk[3][site_i][index_nn_i], Hk[4][site_i][index_nn_i]) : spinj == 0 ? (Hk[3][site_i][index_nn_i], iHk[3][site_i][index_nn_i]) : (Hk[2][site_i][index_nn_i], iHk[2][site_i][index_nn_i])
+                hamiltonians[key][spini * len_i_wo_spin + 1 : (spini + 1) * len_i_wo_spin, spinj * len_j_wo_spin + 1 : (spinj + 1) * len_j_wo_spin] = permutedims(Hk_real) + im * permutedims(Hk_imag)
+                if spini == 0 && spinj == 1
+                    hamiltonians[key_inv][1 * len_j_wo_spin + 1 : (1 + 1) * len_j_wo_spin, 0 * len_i_wo_spin + 1 : (0 + 1) * len_i_wo_spin] = (permutedims(Hk_real) + im * permutedims(Hk_imag))'
+                end
+            end
+        else
+            error("SpinP_switch is $SpinP_switch, rather than valid values 0, 1 or 3")
+        end
+    end
+
+    return element, overlaps, density_matrixs, hamiltonians, fermi_level, orbital_types, lat, site_positions, spinful, R_list
+end
+
+parsed_args["input_dir"] = abspath(parsed_args["input_dir"])
+mkpath(parsed_args["output_dir"])
+cd(parsed_args["output_dir"])
+
+element, overlaps, density_matrixs, hamiltonians, fermi_level, orbital_types, lat, site_positions, spinful, R_list = get_data(joinpath(parsed_args["input_dir"], "openmx.scfout"), -1.0; if_DM=parsed_args["if_DM"])
+
+if parsed_args["if_DM"]
+    h5open("density_matrixs.h5", "w") do fid
+        for (key, density_matrix) in density_matrixs
+            write(fid, string(key), permutedims(density_matrix))
+        end
+    end
+end
+if parsed_args["save_overlap"]
+    h5open("overlaps.h5", "w") do fid
+        for (key, overlap) in overlaps
+            write(fid, string(key), permutedims(overlap))
+        end
+    end
+end
+h5open("hamiltonians.h5", "w") do fid
+    for (key, hamiltonian) in hamiltonians
+        write(fid, string(key), permutedims(hamiltonian))
+    end
+end
+
+info_dict = Dict(
+    "fermi_level" => fermi_level,
+    "isspinful" => spinful
+    )
+open("info.json", "w") do f
+    write(f, json(info_dict, 4))
+end
+open("site_positions.dat", "w") do f
+    writedlm(f, site_positions)
+end
+open("R_list.dat", "w") do f
+    writedlm(f, R_list)
+end
+open("lat.dat", "w") do f
+    writedlm(f, lat)
+end
+rlat = 2pi * inv(lat)'
+open("rlat.dat", "w") do f
+    writedlm(f, rlat)
+end
+open("orbital_types.dat", "w") do f
+    writedlm(f, orbital_types)
+end
+open("element.dat", "w") do f
+    writedlm(f, element)
+end

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/openmx_parse.py

@@ -0,0 +1,425 @@
+import os
+import json
+from math import pi
+
+import tqdm
+import argparse
+import h5py
+import numpy as np
+from pymatgen.core.structure import Structure
+
+from .abacus_get_data import periodic_table
+
+Hartree2Ev = 27.2113845
+Ev2Kcalmol = 23.061
+Bohr2R = 0.529177249
+
+
+def openmx_force_intferface(out_file_dir, save_dir=None, return_Etot=False, return_force=False):
+    with open(out_file_dir, 'r') as out_file:
+        lines = out_file.readlines()
+        for index_line, line in enumerate(lines):
+            if line.find('Total energy (Hartree) at MD = 1') != -1:
+                assert lines[index_line + 3].find("Uele.") != -1
+                assert lines[index_line + 5].find("Ukin.") != -1
+                assert lines[index_line + 7].find("UH1.") != -1
+                assert lines[index_line + 8].find("Una.") != -1
+                assert lines[index_line + 9].find("Unl.") != -1
+                assert lines[index_line + 10].find("Uxc0.") != -1
+                assert lines[index_line + 20].find("Utot.") != -1
+                parse_E = lambda x: float(x.split()[-1])
+                E_tot = parse_E(lines[index_line + 20]) * Hartree2Ev
+                E_kin = parse_E(lines[index_line + 5]) * Hartree2Ev
+                E_delta_ee = parse_E(lines[index_line + 7]) * Hartree2Ev
+                E_NA = parse_E(lines[index_line + 8]) * Hartree2Ev
+                E_NL = parse_E(lines[index_line + 9]) * Hartree2Ev
+                E_xc = parse_E(lines[index_line + 10]) * 2 * Hartree2Ev
+                if save_dir is not None:
+                    with open(os.path.join(save_dir, "openmx_E.json"), 'w') as E_file:
+                        json.dump({
+                            "Total energy": E_tot,
+                            "E_kin": E_kin,
+                            "E_delta_ee": E_delta_ee,
+                            "E_NA": E_NA,
+                            "E_NL": E_NL,
+                            "E_xc": E_xc
+                        }, E_file)
+            if line.find('xyz-coordinates (Ang) and forces (Hartree/Bohr)') != -1:
+                assert lines[index_line + 4].find("<coordinates.forces") != -1
+                num_atom = int(lines[index_line + 5])
+                forces = np.zeros((num_atom, 3))
+                for index_atom in range(num_atom):
+                    forces[index_atom] = list(
+                        map(lambda x: float(x) * Hartree2Ev / Bohr2R, lines[index_line + 6 + index_atom].split()[-3:]))
+                break
+    if save_dir is not None:
+        np.savetxt(os.path.join(save_dir, "openmx_forces.dat"), forces)
+    ret = (E_kin, E_delta_ee, E_NA, E_NL, E_xc)
+    if return_Etot is True:
+        ret = ret + (E_tot,)
+    if return_force is True:
+        ret = ret + (forces,)
+    return ret
+
+
+def openmx_parse_overlap(OLP_dir, output_dir):
+    assert os.path.exists(os.path.join(OLP_dir, "output", "overlaps_0.h5")), "No overlap files found"
+    assert os.path.exists(os.path.join(OLP_dir, "openmx.out")), "openmx.out not found"
+
+    overlaps = read_non_parallel_hdf5('overlaps', os.path.join(OLP_dir, 'output'))
+    assert len(overlaps.keys()) != 0, 'Can not found any overlap file'
+    fid = h5py.File(os.path.join(output_dir, 'overlaps.h5'), 'w')
+    for key_str, v in overlaps.items():
+        fid[key_str] = v
+    fid.close()
+
+    orbital2l = {"s": 0, "p": 1, "d": 2, "f": 3}
+    # parse openmx.out
+    with open(os.path.join(OLP_dir, "openmx.out"), "r") as f:
+        lines = f.readlines()
+    orbital_dict = {}
+    lattice = np.zeros((3, 3))
+    frac_coords = []
+    atomic_elements_str = []
+    flag_read_orbital = False
+    flag_read_lattice = False
+    for index_line, line in enumerate(lines):
+        if line.find('Definition.of.Atomic.Species>') != -1:
+            flag_read_orbital = False
+        if flag_read_orbital:
+            element = line.split()[0]
+            orbital_str = (line.split()[1]).split('-')[-1]
+            l_list = []
+            assert len(orbital_str) % 2 == 0
+            for index_str in range(len(orbital_str) // 2):
+                l_list.extend([orbital2l[orbital_str[index_str * 2]]] * int(orbital_str[index_str * 2 + 1]))
+            orbital_dict[element] = l_list
+        if line.find('<Definition.of.Atomic.Species') != -1:
+            flag_read_orbital = True
+
+        if line.find('Atoms.UnitVectors.Unit') != -1:
+            assert line.split()[1] == "Ang", "Unit of lattice vector is not Angstrom"
+            assert lines[index_line + 1].find("<Atoms.UnitVectors") != -1
+            lattice[0, :] = np.array(list(map(float, lines[index_line + 2].split())))
+            lattice[1, :] = np.array(list(map(float, lines[index_line + 3].split())))
+            lattice[2, :] = np.array(list(map(float, lines[index_line + 4].split())))
+            flag_read_lattice = True
+
+        if line.find('Fractional coordinates of the final structure') != -1:
+            index_atom = 0
+            while (index_line + index_atom + 4) < len(lines):
+                index_atom += 1
+                line_split = lines[index_line + index_atom + 3].split()
+                if len(line_split) == 0:
+                    break
+                assert len(line_split) == 5
+                assert line_split[0] == str(index_atom)
+                atomic_elements_str.append(line_split[1])
+                frac_coords.append(np.array(list(map(float, line_split[2:]))))
+    print("Found", len(frac_coords), "atoms")
+    if flag_read_lattice is False:
+        raise RuntimeError("Could not find lattice vector in openmx.out")
+    if len(orbital_dict) == 0:
+        raise RuntimeError("Could not find orbital information in openmx.out")
+    frac_coords = np.array(frac_coords)
+    cart_coords = frac_coords @ lattice
+
+    np.savetxt(os.path.join(output_dir, "site_positions.dat"), cart_coords.T)
+    np.savetxt(os.path.join(output_dir, "lat.dat"), lattice.T)
+    np.savetxt(os.path.join(output_dir, "rlat.dat"), np.linalg.inv(lattice) * 2 * pi)
+    np.savetxt(os.path.join(output_dir, "element.dat"),
+               np.array(list(map(lambda x: periodic_table[x], atomic_elements_str))), fmt='%d')
+    with open(os.path.join(output_dir, 'orbital_types.dat'), 'w') as orbital_types_f:
+        for element_str in atomic_elements_str:
+            for index_l, l in enumerate(orbital_dict[element_str]):
+                if index_l == 0:
+                    orbital_types_f.write(str(l))
+                else:
+                    orbital_types_f.write(f"  {l}")
+            orbital_types_f.write('\n')
+
+
+def read_non_parallel_hdf5(name, file_dir, num_p=256):
+    Os = {}
+    for index_p in range(num_p):
+        if os.path.exists(os.path.join(file_dir, f"{name}_{index_p}.h5")):
+            fid = h5py.File(os.path.join(file_dir, f"{name}_{index_p}.h5"), 'r')
+            for key_str, O_nm in fid.items():
+                Os[key_str] = O_nm[...]
+    assert not os.path.exists(os.path.join(file_dir, f"{name}_{num_p}.h5")), "Increase num_p because some overlap files are missing"
+    return Os
+
+
+def read_hdf5(name, file_dir):
+    Os = {}
+    fid = h5py.File(os.path.join(file_dir, f"{name}.h5"), 'r')
+    for key_str, O_nm in fid.items():
+        Os[key_str] = O_nm[...]
+    return Os
+
+
+class OijLoad:
+    def __init__(self, output_dir):
+        print("get data from:", output_dir)
+        self.if_load_scfout = False
+        self.output_dir = output_dir
+        term_non_parallel_list = ['H', 'T', 'V_xc', 'O_xc', 'O_dVHart', 'O_NA', 'O_NL', 'Rho']
+        self.term_h5_dict = {}
+        for term in term_non_parallel_list:
+            self.term_h5_dict[term] = read_non_parallel_hdf5(term, output_dir)
+
+        self.term_h5_dict['H_add'] = {}
+        for key_str in self.term_h5_dict['T'].keys():
+            tmp = np.zeros_like(self.term_h5_dict['T'][key_str])
+            for term in ['T', 'V_xc', 'O_dVHart', 'O_NA', 'O_NL']:
+                tmp += self.term_h5_dict[term][key_str]
+            self.term_h5_dict['H_add'][key_str] = tmp
+
+        self.dig_term = {}
+        for term in ['E_dVHart_a', 'E_xc_pcc']:
+            self.dig_term[term] = np.loadtxt(os.path.join(output_dir, f'{term}.dat'))
+
+    def cal_Eij(self):
+        term_list = ["E_kin", "E_NA", "E_NL", "E_delta_ee", "E_xc"]
+        self.Eij = {term: {} for term in term_list}
+        self.R_list = []
+        for key_str in self.term_h5_dict['T'].keys():
+            key = json.loads(key_str)
+            R = (key[0], key[1], key[2])
+            if R not in self.R_list:
+                self.R_list.append(R)
+            atom_i = key[3] - 1
+            atom_j = key[4] - 1
+
+            self.Eij["E_NA"][key_str] = (self.term_h5_dict["O_NA"][key_str] * self.term_h5_dict["Rho"][key_str]).sum() * 2
+            self.Eij["E_NL"][key_str] = (self.term_h5_dict["O_NL"][key_str] * self.term_h5_dict["Rho"][key_str]).sum() * 2
+            self.Eij["E_kin"][key_str] = (self.term_h5_dict["T"][key_str] * self.term_h5_dict["Rho"][key_str]).sum() * 2
+            self.Eij["E_delta_ee"][key_str] = (self.term_h5_dict["O_dVHart"][key_str] * self.term_h5_dict["Rho"][key_str]).sum()
+            self.Eij["E_xc"][key_str] = (self.term_h5_dict["O_xc"][key_str] * self.term_h5_dict["Rho"][key_str]).sum() * 2
+            if (atom_i == atom_j) and (R == (0, 0, 0)):
+                self.Eij["E_delta_ee"][key_str] -= self.dig_term['E_dVHart_a'][atom_i]
+                self.Eij["E_xc"][key_str] += self.dig_term['E_xc_pcc'][atom_i] * 2
+
+    def load_scfout(self):
+        self.if_load_scfout = True
+        term_list = ["hamiltonians", "overlaps", "density_matrixs"]
+        default_dtype = np.complex128
+
+        for term in term_list:
+            self.term_h5_dict[term] = read_hdf5(term, self.output_dir)
+
+        site_positions = np.loadtxt(os.path.join(self.output_dir, 'site_positions.dat')).T
+        self.lat = np.loadtxt(os.path.join(self.output_dir, 'lat.dat')).T
+        self.rlat = np.loadtxt(os.path.join(self.output_dir, 'rlat.dat')).T
+        nsites = site_positions.shape[0]
+
+        self.orbital_types = []
+        with open(os.path.join(self.output_dir, 'orbital_types.dat'), 'r') as orbital_types_f:
+            for index_site in range(nsites):
+                self.orbital_types.append(np.array(list(map(int, orbital_types_f.readline().split()))))
+        site_norbits = list(map(lambda x: (2 * x + 1).sum(), self.orbital_types))
+        site_norbits_cumsum = np.cumsum(site_norbits)
+        norbits = sum(site_norbits)
+
+        self.term_R_dict = {term: {} for term in self.term_h5_dict.keys()}
+        for key_str in tqdm.tqdm(self.term_h5_dict['overlaps'].keys()):
+            key = json.loads(key_str)
+            R = (key[0], key[1], key[2])
+            atom_i = key[3] - 1
+            atom_j = key[4] - 1
+            if R not in self.term_R_dict['overlaps']:
+                for term_R in self.term_R_dict.values():
+                    term_R[R] = np.zeros((norbits, norbits), dtype=default_dtype)
+            matrix_slice_i = slice(site_norbits_cumsum[atom_i] - site_norbits[atom_i], site_norbits_cumsum[atom_i])
+            matrix_slice_j = slice(site_norbits_cumsum[atom_j] - site_norbits[atom_j], site_norbits_cumsum[atom_j])
+            for term, term_R in self.term_R_dict.items():
+                term_R[R][matrix_slice_i, matrix_slice_j] = np.array(self.term_h5_dict[term][key_str]).astype(
+                    dtype=default_dtype)
+
+    def get_E_band(self):
+        E_band = 0.0
+        for R in self.term_R_dict['T'].keys():
+            E_band += (self.term_R_dict['density_matrixs'][R] * self.term_R_dict['H_add'][R]).sum()
+        return E_band
+
+    def get_E_band2(self):
+        E_band = 0.0
+        for R in self.term_R_dict['T'].keys():
+            E_band += (self.term_R_dict['density_matrixs'][R] * self.term_R_dict['hamiltonians'][R]).sum()
+        return E_band
+
+    def get_E_band3(self):
+        E_band = 0.0
+        for R in self.term_R_dict['T'].keys():
+            E_band += (self.term_R_dict['density_matrixs'][R] * self.term_R_dict['H'][R]).sum()
+        return E_band
+
+    def sum_Eij(self, term):
+        ret = 0.0
+        for value in self.Eij[term].values():
+            ret += value
+        return ret
+
+    def get_E_NL(self):
+        assert self.if_load_scfout == True
+        E_NL = 0.0
+        for R in self.term_R_dict['T'].keys():
+            E_NL += (self.term_R_dict['density_matrixs'][R] * self.term_R_dict['O_NL'][R]).sum()
+        return E_NL
+
+    def save_Vij(self, save_dir):
+        for term, h5_file_name in zip(["O_NA", "O_dVHart", "V_xc", "H_add", "Rho"],
+                                      ["V_nas", "V_delta_ees", "V_xcs", "hamiltonians", "density_matrixs"]):
+            fid = h5py.File(os.path.join(save_dir, f'{h5_file_name}.h5'), "w")
+            for k, v in self.term_h5_dict[term].items():
+                fid[k] = v
+            fid.close()
+
+    def get_E5ij(self):
+        term_list = ["E_kin", "E_NA", "E_NL", "E_delta_ee", "E_xc"]
+        E_dict = {term: 0 for term in term_list}
+        E5ij = {}
+        for key_str in self.Eij[term_list[0]].keys():
+            tmp = 0.0
+            for term in term_list:
+                v = self.Eij[term][key_str]
+                E_dict[term] += v
+                tmp += v
+            if key_str in E5ij:
+                E5ij[key_str] += tmp
+            else:
+                E5ij[key_str] = tmp
+        return E5ij, E_dict
+
+    def save_Eij(self, save_dir):
+        fid_tmp, E_dict = self.get_E5ij()
+
+        fid = h5py.File(os.path.join(save_dir, f'E_ij.h5'), "w")
+        for k, v in fid_tmp.items():
+            fid[k] = v
+        fid.close()
+
+        with open(os.path.join(save_dir, "openmx_E_ij_E.json"), 'w') as E_file:
+            json.dump({
+                "E_kin": E_dict["E_kin"],
+                "E_delta_ee": E_dict["E_delta_ee"],
+                "E_NA": E_dict["E_NA"],
+                "E_NL": E_dict["E_NL"],
+                "E_xc": E_dict["E_xc"]
+            }, E_file)
+
+        # return E_dict["E_delta_ee"], E_dict["E_xc"]
+        return E_dict["E_kin"], E_dict["E_delta_ee"], E_dict["E_NA"], E_dict["E_NL"], E_dict["E_xc"]
+
+    def get_E5i(self):
+        term_list = ["E_kin", "E_NA", "E_NL", "E_delta_ee", "E_xc"]
+        E_dict = {term: 0 for term in term_list}
+        E5i = {}
+        for key_str in self.Eij[term_list[0]].keys():
+            key = json.loads(key_str)
+            atom_i_str = str(key[3] - 1)
+            tmp = 0.0
+            for term in term_list:
+                v = self.Eij[term][key_str]
+                E_dict[term] += v
+                tmp += v
+            if atom_i_str in E5i:
+                E5i[atom_i_str] += tmp
+            else:
+                E5i[atom_i_str] = tmp
+        return E5i, E_dict
+
+    def save_Ei(self, save_dir):
+        fid_tmp, E_dict = self.get_E5i()
+
+        fid = h5py.File(os.path.join(save_dir, f'E_i.h5'), "w")
+        for k, v in fid_tmp.items():
+            fid[k] = v
+        fid.close()
+        with open(os.path.join(save_dir, "openmx_E_i_E.json"), 'w') as E_file:
+            json.dump({
+                "E_kin": E_dict["E_kin"],
+                "E_delta_ee": E_dict["E_delta_ee"],
+                "E_NA": E_dict["E_NA"],
+                "E_NL": E_dict["E_NL"],
+                "E_xc": E_dict["E_xc"]
+            }, E_file)
+        return E_dict["E_kin"], E_dict["E_delta_ee"], E_dict["E_NA"], E_dict["E_NL"], E_dict["E_xc"]
+
+    def get_R_list(self):
+        return self.R_list
+
+
+class GetEEiEij:
+    def __init__(self, input_dir):
+        self.load_kernel = OijLoad(os.path.join(input_dir, "output"))
+        self.E_kin, self.E_delta_ee, self.E_NA, self.E_NL, self.E_xc, self.Etot, self.force = openmx_force_intferface(
+            os.path.join(input_dir, "openmx.out"), save_dir=None, return_Etot=True, return_force=True)
+        self.load_kernel.cal_Eij()
+
+    def get_Etot(self):
+        # unit: kcal mol^-1
+        return self.Etot * Ev2Kcalmol
+
+    def get_force(self):
+        # unit: kcal mol^-1 Angstrom^-1
+        return self.force * Ev2Kcalmol
+
+    def get_E5(self):
+        # unit: kcal mol^-1
+        return (self.E_kin + self.E_delta_ee + self.E_NA + self.E_NL + self.E_xc) * Ev2Kcalmol
+
+    def get_E5i(self):
+        # unit: kcal mol^-1
+        E5i, E_from_i_dict = self.load_kernel.get_E5i()
+        assert np.allclose(self.E_kin, E_from_i_dict["E_kin"])
+        assert np.allclose(self.E_delta_ee, E_from_i_dict["E_delta_ee"])
+        assert np.allclose(self.E_NA, E_from_i_dict["E_NA"])
+        assert np.allclose(self.E_NL, E_from_i_dict["E_NL"])
+        assert np.allclose(self.E_xc, E_from_i_dict["E_xc"], rtol=1.e-3)
+        return {k: v * Ev2Kcalmol for k, v in E5i.items()}
+
+    def get_E5ij(self):
+        # unit: kcal mol^-1
+        E5ij, E_from_ij_dict = self.load_kernel.get_E5ij()
+        assert np.allclose(self.E_kin, E_from_ij_dict["E_kin"])
+        assert np.allclose(self.E_delta_ee, E_from_ij_dict["E_delta_ee"])
+        assert np.allclose(self.E_NA, E_from_ij_dict["E_NA"])
+        assert np.allclose(self.E_NL, E_from_ij_dict["E_NL"])
+        assert np.allclose(self.E_xc, E_from_ij_dict["E_xc"], rtol=1.e-3)
+        return {k: v * Ev2Kcalmol for k, v in E5ij.items()}
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Predict Hamiltonian')
+    parser.add_argument(
+        '--input_dir', type=str, default='./',
+        help='path of openmx.out, and output'
+    )
+    parser.add_argument(
+        '--output_dir', type=str, default='./',
+        help='path of output E_xc_ij.h5, E_delta_ee_ij.h5, site_positions.dat, lat.dat, element.dat, and R_list.dat'
+    )
+    parser.add_argument('--Ei', action='store_true')
+    parser.add_argument('--stru_dir', type=str, default='POSCAR', help='path of structure file')
+    args = parser.parse_args()
+
+    os.makedirs(args.output_dir, exist_ok=True)
+    load_kernel = OijLoad(os.path.join(args.input_dir, "output"))
+    E_kin, E_delta_ee, E_NA, E_NL, E_xc = openmx_force_intferface(os.path.join(args.input_dir, "openmx.out"), args.output_dir)
+    load_kernel.cal_Eij()
+    if args.Ei:
+        E_kin_from_ij, E_delta_ee_from_ij, E_NA_from_ij, E_NL_from_ij, E_xc_from_ij = load_kernel.save_Ei(args.output_dir)
+    else:
+        E_kin_from_ij, E_delta_ee_from_ij, E_NA_from_ij, E_NL_from_ij, E_xc_from_ij = load_kernel.save_Eij(args.output_dir)
+    assert np.allclose(E_kin, E_kin_from_ij)
+    assert np.allclose(E_delta_ee, E_delta_ee_from_ij)
+    assert np.allclose(E_NA, E_NA_from_ij)
+    assert np.allclose(E_NL, E_NL_from_ij)
+    assert np.allclose(E_xc, E_xc_from_ij, rtol=1.e-3)
+
+    structure = Structure.from_file(args.stru_dir)
+    np.savetxt(os.path.join(args.output_dir, "site_positions.dat"), structure.cart_coords.T)
+    np.savetxt(os.path.join(args.output_dir, "lat.dat"), structure.lattice.matrix.T)
+    np.savetxt(os.path.join(args.output_dir, "element.dat"), structure.atomic_numbers, fmt='%d')
+    np.savetxt(os.path.join(args.output_dir, "R_list.dat"), load_kernel.get_R_list(), fmt='%d')

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/preprocess_default.ini

@@ -0,0 +1,20 @@
+[basic]
+raw_dir = /your/own/path
+processed_dir = /your/own/path
+target = hamiltonian
+interface = openmx
+multiprocessing = 0
+local_coordinate = True
+get_S = False
+
+[interpreter]
+julia_interpreter = julia
+
+[graph]
+radius = -1.0
+create_from_DFT = True
+r2_rand = False
+
+[magnetic_moment]
+parse_magnetic_moment = False
+magnetic_element = ["Cr", "Mn", "Fe", "Co", "Ni"]

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/preprocess/siesta_get_data.py

@@ -0,0 +1,336 @@
+import os
+import numpy as np
+from numpy.core.fromnumeric import sort
+import scipy as sp
+import h5py
+import json
+from scipy.io import FortranFile
+
+# Transfer SIESTA output to DeepH format
+# DeepH-pack: https://deeph-pack.readthedocs.io/en/latest/index.html
+# Coded by ZC Tang @ Tsinghua Univ. e-mail: az_txycha@126.com
+
+def siesta_parse(input_path, output_path):
+    input_path = os.path.abspath(input_path)
+    output_path = os.path.abspath(output_path)
+    os.makedirs(output_path, exist_ok=True)
+
+    # finds system name
+    f_list = os.listdir(input_path)
+    for f_name in f_list:
+        if f_name[::-1][0:9] == 'XDNI_BRO.':
+            system_name = f_name[:-9]
+
+    with open('{}/{}.STRUCT_OUT'.format(input_path,system_name), 'r') as struct: # structure info from standard output
+        lattice = np.empty((3,3))
+        for i in range(3):
+            line = struct.readline()
+            linesplit = line.split()
+            lattice[i,:] = linesplit[:]
+        np.savetxt('{}/lat.dat'.format(output_path), np.transpose(lattice), fmt='%.18e') 
+        line = struct.readline()
+        linesplit = line.split()
+        num_atoms = int(linesplit[0])
+        atom_coord = np.empty((num_atoms, 4))
+        for i in range(num_atoms):
+            line = struct.readline()
+            linesplit = line.split()
+            atom_coord[i, :] = linesplit[1:]
+        np.savetxt('{}/element.dat'.format(output_path), atom_coord[:,0], fmt='%d')
+
+    atom_coord_cart = np.genfromtxt('{}/{}.XV'.format(input_path,system_name),skip_header = 4)
+    atom_coord_cart = atom_coord_cart[:,2:5] * 0.529177249
+    np.savetxt('{}/site_positions.dat'.format(output_path), np.transpose(atom_coord_cart))
+
+    orb_indx = np.genfromtxt('{}/{}.ORB_INDX'.format(input_path,system_name), skip_header=3, skip_footer=17)
+    # orb_indx rows: 0 orbital id   1 atom id   2 atom type   3 element symbol
+    #                4 orbital id within atom   5 n           6 l
+    #                7 m            8 zeta      9 Polarized? 10 orbital symmetry
+    #               11 rc(a.u.)     12-14 R     15 equivalent orbital index in uc
+
+    orb_indx[:,12:15]=orb_indx[:,12:15]
+
+    with open('{}/R_list.dat'.format(output_path),'w') as R_list_f:
+        R_prev = np.empty(3)
+        for i in range(len(orb_indx)):
+            R = orb_indx[i, 12:15]
+            if (R != R_prev).any():
+                R_prev = R
+                R_list_f.write('{} {} {}\n'.format(int(R[0]), int(R[1]), int(R[2])))
+
+    ia2Riua = np.empty((0,4)) #DeepH key
+    ia = 0
+    for i in range(len(orb_indx)):
+        if orb_indx[i][1] != ia:
+            ia = orb_indx[i][1]
+            Riua = np.empty((1,4))
+            Riua[0,0:3] = orb_indx[i][12:15]
+            iuo = int(orb_indx[i][15])
+            iua = int(orb_indx[iuo-1,1])
+            Riua[0,3] = int(iua)
+            ia2Riua = np.append(ia2Riua, Riua)
+    ia2Riua = ia2Riua.reshape(int(len(ia2Riua)/4),4)
+
+
+    #hamiltonians.h5, density_matrixs.h5, overlap.h5
+    info = {'nsites' : num_atoms, 'isorthogonal': False, 'isspinful': False, 'norbits': len(orb_indx)}
+    with open('{}/info.json'.format(output_path), 'w') as info_f:
+        json.dump(info, info_f)
+
+    a1 = lattice[0, :]
+    a2 = lattice[1, :]
+    a3 = lattice[2, :]
+    b1 = 2 * np.pi * np.cross(a2, a3) / (np.dot(a1, np.cross(a2, a3)))
+    b2 = 2 * np.pi * np.cross(a3, a1) / (np.dot(a2, np.cross(a3, a1)))
+    b3 = 2 * np.pi * np.cross(a1, a2) / (np.dot(a3, np.cross(a1, a2)))
+    rlattice = np.array([b1, b2, b3])
+    np.savetxt('{}/rlat.dat'.format(output_path), np.transpose(rlattice), fmt='%.18e')
+
+    # Cope with orbital type information
+    i = 0
+    with open('{}/orbital_types.dat'.format(output_path), 'w') as orb_type_f:
+        atom_current = 0
+        while True: # Loop over atoms in unitcell
+            if atom_current != orb_indx[i, 1]:
+                if atom_current != 0:
+                    for j in range(4):
+                        for _ in range(int(atom_orb_cnt[j]/(2*j+1))):
+                            orb_type_f.write('{}  '.format(j))
+                    orb_type_f.write('\n')
+
+                atom_current = int(orb_indx[i, 1])
+                atom_orb_cnt = np.array([0,0,0,0]) # number of s, p, d, f orbitals in specific atom
+            l = int(orb_indx[i, 6])
+            atom_orb_cnt[l] += 1
+            i += 1
+            if i > len(orb_indx)-1:
+                for j in range(4):
+                    for _ in range(int(atom_orb_cnt[j]/(2*j+1))):
+                        orb_type_f.write('{}  '.format(j))
+                orb_type_f.write('\n')
+                break
+            if orb_indx[i, 0] != orb_indx[i, 15]:
+                for j in range(4):
+                    for _ in range(int(atom_orb_cnt[j]/(2*j+1))):
+                        orb_type_f.write('{}  '.format(j))
+                orb_type_f.write('\n')
+                break
+
+    # yields key for *.h5 file
+    orb2deephorb = np.zeros((len(orb_indx), 5))
+    atom_current = 1
+    orb_atom_current = np.empty((0)) # stores orbitals' id in siesta, n, l, m and z, will be reshaped into orb*5
+    t = 0 
+    for i in range(len(orb_indx)):  
+        orb_atom_current = np.append(orb_atom_current, i)
+        orb_atom_current = np.append(orb_atom_current, orb_indx[i,5:9])
+        if i != len(orb_indx)-1 :
+            if orb_indx[i+1,1] != atom_current:
+                orb_atom_current = np.reshape(orb_atom_current,((int(len(orb_atom_current)/5),5)))
+                for j in range(len(orb_atom_current)):
+                    if orb_atom_current[j,2] == 1: #p
+                        if orb_atom_current[j,3] == -1:
+                            orb_atom_current[j,3] = 0
+                        elif orb_atom_current[j,3] == 0:
+                            orb_atom_current[j,3] = 1
+                        elif orb_atom_current[j,3] == 1:
+                            orb_atom_current[j,3] = -1
+                    if orb_atom_current[j,2] == 2: #d
+                        if orb_atom_current[j,3] == -2:
+                            orb_atom_current[j,3] = 0
+                        elif orb_atom_current[j,3] == -1:
+                            orb_atom_current[j,3] = 2
+                        elif orb_atom_current[j,3] == 0:
+                            orb_atom_current[j,3] = -2
+                        elif orb_atom_current[j,3] == 1:
+                            orb_atom_current[j,3] = 1
+                        elif orb_atom_current[j,3] == 2:
+                            orb_atom_current[j,3] = -1
+                    if orb_atom_current[j,2] == 3: #f
+                        if orb_atom_current[j,3] == -3:
+                            orb_atom_current[j,3] = 0
+                        elif orb_atom_current[j,3] == -2:
+                            orb_atom_current[j,3] = 1
+                        elif orb_atom_current[j,3] == -1:
+                            orb_atom_current[j,3] = -1
+                        elif orb_atom_current[j,3] == 0:
+                            orb_atom_current[j,3] = 2
+                        elif orb_atom_current[j,3] == 1:
+                            orb_atom_current[j,3] = -2
+                        elif orb_atom_current[j,3] == 2:
+                            orb_atom_current[j,3] = 3
+                        elif orb_atom_current[j,3] == 3:
+                            orb_atom_current[j,3] = -3
+                sort_index = np.zeros(len(orb_atom_current))
+                for j in range(len(orb_atom_current)):
+                    sort_index[j] = orb_atom_current[j,3] + 10 * orb_atom_current[j,4] + 100 * orb_atom_current[j,1] + 1000 * orb_atom_current[j,2]
+                orb_order = np.argsort(sort_index)
+                tmpt = np.empty(len(orb_order))
+                for j in range(len(orb_order)):
+                    tmpt[orb_order[j]] = j
+                orb_order = tmpt
+                for j in range(len(orb_atom_current)):
+                    orb2deephorb[t,0:3] = np.round(orb_indx[t,12:15])
+                    orb2deephorb[t,3] = ia2Riua[int(orb_indx[t,1])-1,3]
+                    orb2deephorb[t,4] = int(orb_order[j])
+                    t += 1
+                atom_current += 1
+                orb_atom_current = np.empty((0))
+
+    orb_atom_current = np.reshape(orb_atom_current,((int(len(orb_atom_current)/5),5)))
+    for j in range(len(orb_atom_current)):
+        if orb_atom_current[j,2] == 1:
+            if orb_atom_current[j,3] == -1:
+                orb_atom_current[j,3] = 0
+            elif orb_atom_current[j,3] == 0:
+                orb_atom_current[j,3] = 1
+            elif orb_atom_current[j,3] == 1:
+                orb_atom_current[j,3] = -1
+        if orb_atom_current[j,2] == 2:
+            if orb_atom_current[j,3] == -2:
+                orb_atom_current[j,3] = 0
+            elif orb_atom_current[j,3] == -1:
+                orb_atom_current[j,3] = 2
+            elif orb_atom_current[j,3] == 0:
+                orb_atom_current[j,3] = -2
+            elif orb_atom_current[j,3] == 1:
+                orb_atom_current[j,3] = 1
+            elif orb_atom_current[j,3] == 2:
+                orb_atom_current[j,3] = -1
+        if orb_atom_current[j,2] == 3: #f
+            if orb_atom_current[j,3] == -3:
+                orb_atom_current[j,3] = 0
+            elif orb_atom_current[j,3] == -2:
+                orb_atom_current[j,3] = 1
+            elif orb_atom_current[j,3] == -1:
+                orb_atom_current[j,3] = -1
+            elif orb_atom_current[j,3] == 0:
+                orb_atom_current[j,3] = 2
+            elif orb_atom_current[j,3] == 1:
+                orb_atom_current[j,3] = -2
+            elif orb_atom_current[j,3] == 2:
+                orb_atom_current[j,3] = 3
+            elif orb_atom_current[j,3] == 3:
+                orb_atom_current[j,3] = -3
+    sort_index = np.zeros(len(orb_atom_current))
+    for j in range(len(orb_atom_current)):
+        sort_index[j] = orb_atom_current[j,3] + 10 * orb_atom_current[j,4] + 100 * orb_atom_current[j,1] + 1000 * orb_atom_current[j,2]
+    orb_order = np.argsort(sort_index)
+    tmpt = np.empty(len(orb_order))
+    for j in range(len(orb_order)):
+        tmpt[orb_order[j]] = j
+    orb_order = tmpt
+    for j in range(len(orb_atom_current)):
+        orb2deephorb[t,0:3] = np.round(orb_indx[t,12:15])
+        orb2deephorb[t,3] = ia2Riua[int(orb_indx[t,1])-1,3]
+        orb2deephorb[t,4] = int(orb_order[j])
+        t += 1
+
+    # Read Useful info of HSX, We only need H and S from this file, but due to structure of fortran unformatted, extra information must be read
+    f = FortranFile('{}/{}.HSX'.format(input_path,system_name), 'r')
+    tmpt = f.read_ints() # no_u, no_s, nspin, nh
+    no_u = tmpt[0]
+    no_s = tmpt[1]
+    nspin = tmpt[2]
+    nh = tmpt[3]
+    tmpt = f.read_ints() # gamma
+    tmpt = f.read_ints() # indxuo
+    tmpt = f.read_ints() # numh
+    maxnumh = max(tmpt)
+    listh = np.zeros((no_u, maxnumh),dtype=int)
+    for i in range(no_u):
+        tmpt=f.read_ints() # listh
+        for j in range(len(tmpt)):
+            listh[i,j] = tmpt[j]
+
+    # finds set of connected atoms
+    connected_atoms = set()
+    for i in range(no_u):
+        for j in range(maxnumh):
+            if listh[i,j] == 0:
+                #print(j)
+                break
+            else:
+                atom_1 = int(orb2deephorb[i,3])#orbit i belongs to atom_1
+                atom_2 = int(orb2deephorb[listh[i,j]-1,3])# orbit j belongs to atom_2
+                Rijk = orb2deephorb[listh[i,j]-1,0:3]
+                Rijk = Rijk.astype(int)
+            connected_atoms = connected_atoms | set(['[{}, {}, {}, {}, {}]'.format(Rijk[0],Rijk[1],Rijk[2],atom_1,atom_2)])
+
+
+    H_block_sparse = dict()
+    for atom_pair in connected_atoms:
+        H_block_sparse[atom_pair] = []
+    # converts csr-like matrix into coo form in atomic pairs
+    for i in range(nspin):
+        for j in range(no_u):
+            tmpt=f.read_reals(dtype='<f4') # Hamiltonian
+            for k in range(len(tmpt)):
+                m = 0 # several orbits in siesta differs with DeepH in a (-1) factor
+                i2 = j
+                j2 = k
+                atom_1 = int(orb2deephorb[i2,3])
+                m += orb_indx[i2,7]
+                atom_2 = int(orb2deephorb[listh[i2,j2]-1,3])
+                m += orb_indx[listh[i2,j2]-1,7]
+                Rijk = orb2deephorb[listh[i2,j2]-1,0:3]
+                Rijk = Rijk.astype(int)
+                H_block_sparse['[{}, {}, {}, {}, {}]'.format(Rijk[0],Rijk[1],Rijk[2],atom_1,atom_2)].append([int(orb2deephorb[i2,4]),int(orb2deephorb[listh[i2,j2]-1,4]),tmpt[k]*((-1)**m)])
+                pass
+
+    S_block_sparse = dict()
+    for atom_pair in connected_atoms:
+        S_block_sparse[atom_pair] = []
+
+    for j in range(no_u):
+        tmpt=f.read_reals(dtype='<f4') # Overlap
+        for k in range(len(tmpt)):
+            m = 0
+            i2 = j
+            j2 = k
+            atom_1 = int(orb2deephorb[i2,3])
+            m += orb_indx[i2,7]
+            atom_2 = int(orb2deephorb[listh[i2,j2]-1,3])
+            m += orb_indx[listh[i2,j2]-1,7]
+            Rijk = orb2deephorb[listh[i2,j2]-1,0:3]
+            Rijk = Rijk.astype(int)
+            S_block_sparse['[{}, {}, {}, {}, {}]'.format(Rijk[0],Rijk[1],Rijk[2],atom_1,atom_2)].append([int(orb2deephorb[i2,4]),int(orb2deephorb[listh[i2,j2]-1,4]),tmpt[k]*((-1)**m)])
+            pass
+        pass
+
+    # finds number of orbitals of each atoms
+    nua = int(max(orb2deephorb[:,3]))
+    atom2nu = np.zeros(nua)
+    for i in range(len(orb_indx)):
+        if orb_indx[i,12]==0 and orb_indx[i,13]==0 and orb_indx[i,14]==0:
+            if orb_indx[i,4] > atom2nu[int(orb_indx[i,1])-1]:
+                atom2nu[int(orb_indx[i,1]-1)] = int(orb_indx[i,4])
+
+    # converts coo sparse matrix into full matrix
+    for Rijkab in H_block_sparse.keys():
+        sparse_form = H_block_sparse[Rijkab]
+        ia1 = int(Rijkab[1:-1].split(',')[3])
+        ia2 = int(Rijkab[1:-1].split(',')[4])
+        tmpt = np.zeros((int(atom2nu[ia1-1]),int(atom2nu[ia2-1])))
+        for i in range(len(sparse_form)):
+            tmpt[int(sparse_form[i][0]),int(sparse_form[i][1])]=sparse_form[i][2]/0.036749324533634074/2
+        H_block_sparse[Rijkab]=tmpt
+    f.close()
+    f = h5py.File('{}/hamiltonians.h5'.format(output_path),'w')
+    for Rijkab in H_block_sparse.keys():
+        f[Rijkab] = H_block_sparse[Rijkab]
+
+    for Rijkab in S_block_sparse.keys():
+        sparse_form = S_block_sparse[Rijkab]
+        ia1 = int(Rijkab[1:-1].split(',')[3])
+        ia2 = int(Rijkab[1:-1].split(',')[4])
+        tmpt = np.zeros((int(atom2nu[ia1-1]),int(atom2nu[ia2-1])))
+        for i in range(len(sparse_form)):
+            tmpt[int(sparse_form[i][0]),int(sparse_form[i][1])]=sparse_form[i][2]
+        S_block_sparse[Rijkab]=tmpt
+
+    f.close()
+    f = h5py.File('{}/overlaps.h5'.format(output_path),'w')
+    for Rijkab in S_block_sparse.keys():
+        f[Rijkab] = S_block_sparse[Rijkab]
+    f.close()

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/scripts/inference.py

@@ -0,0 +1,157 @@
+import os
+import time
+import subprocess as sp
+import json
+
+import argparse
+
+from deeph import get_inference_config, rotate_back, abacus_parse
+from deeph.preprocess import openmx_parse_overlap, get_rc
+from deeph.inference import predict, predict_with_grad
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Deep Hamiltonian')
+    parser.add_argument('--config', default=[], nargs='+', type=str, metavar='N')
+    args = parser.parse_args()
+
+    print(f'User config name: {args.config}')
+    config = get_inference_config(args.config)
+
+    work_dir = os.path.abspath(config.get('basic', 'work_dir'))
+    OLP_dir = os.path.abspath(config.get('basic', 'OLP_dir'))
+    interface = config.get('basic', 'interface')
+    abacus_suffix = str(config.get('basic', 'abacus_suffix', fallback='ABACUS'))
+    task = json.loads(config.get('basic', 'task'))
+    assert isinstance(task, list)
+    eigen_solver = config.get('basic', 'eigen_solver')
+    disable_cuda = config.getboolean('basic', 'disable_cuda')
+    device = config.get('basic', 'device')
+    huge_structure = config.getboolean('basic', 'huge_structure')
+    restore_blocks_py = config.getboolean('basic', 'restore_blocks_py')
+    gen_rc_idx = config.getboolean('basic', 'gen_rc_idx')
+    gen_rc_by_idx = config.get('basic', 'gen_rc_by_idx')
+    with_grad = config.getboolean('basic', 'with_grad')
+    julia_interpreter = config.get('interpreter', 'julia_interpreter', fallback='')
+    python_interpreter = config.get('interpreter', 'python_interpreter', fallback='')
+    radius = config.getfloat('graph', 'radius')
+
+    if 5 in task:
+        if eigen_solver in ['sparse_jl', 'dense_jl']:
+            assert julia_interpreter, "Please specify julia_interpreter to use Julia code to calculate eigenpairs"
+        elif eigen_solver in ['dense_py']:
+            assert python_interpreter, "Please specify python_interpreter to use Python code to calculate eigenpairs"
+        else:
+            raise ValueError(f"Unknown eigen_solver: {eigen_solver}")
+    if 3 in task and not restore_blocks_py:
+        assert julia_interpreter, "Please specify julia_interpreter to use Julia code to rearrange matrix blocks"
+
+    if with_grad:
+        assert restore_blocks_py is True
+        assert 4 not in task
+        assert 5 not in task
+
+    os.makedirs(work_dir, exist_ok=True)
+    config.write(open(os.path.join(work_dir, 'config.ini'), "w"))
+
+
+    if not restore_blocks_py:
+        cmd3_post = f"{julia_interpreter} " \
+                    f"{os.path.join(os.path.dirname(os.path.dirname(__file__)), 'inference', 'restore_blocks.jl')} " \
+                    f"--input_dir {work_dir} --output_dir {work_dir}"
+
+    if eigen_solver == 'sparse_jl':
+        cmd5 = f"{julia_interpreter} " \
+               f"{os.path.join(os.path.dirname(os.path.dirname(__file__)), 'inference', 'sparse_calc.jl')} " \
+               f"--input_dir {work_dir} --output_dir {work_dir} --config {config.get('basic', 'sparse_calc_config')}"
+    elif eigen_solver == 'dense_jl':
+        cmd5 = f"{julia_interpreter} " \
+               f"{os.path.join(os.path.dirname(os.path.dirname(__file__)), 'inference', 'dense_calc.jl')} " \
+               f"--input_dir {work_dir} --output_dir {work_dir} --config {config.get('basic', 'sparse_calc_config')}"
+    elif eigen_solver == 'dense_py':
+        cmd5 = f"{python_interpreter} " \
+               f"{os.path.join(os.path.dirname(os.path.dirname(__file__)), 'inference', 'dense_calc.py')} " \
+               f"--input_dir {work_dir} --output_dir {work_dir} --config {config.get('basic', 'sparse_calc_config')}"
+    else:
+        raise ValueError(f"Unknown eigen_solver: {eigen_solver}")
+
+    print(f"\n~~~~~~~ 1.parse_Overlap\n")
+    print(f"\n~~~~~~~ 2.get_local_coordinate\n")
+    print(f"\n~~~~~~~ 3.get_pred_Hamiltonian\n")
+    if not restore_blocks_py:
+        print(f"\n~~~~~~~ 3_post.restore_blocks, command: \n{cmd3_post}\n")
+    print(f"\n~~~~~~~ 4.rotate_back\n")
+    print(f"\n~~~~~~~ 5.sparse_calc, command: \n{cmd5}\n")
+
+    if 1 in task:
+        begin = time.time()
+        print(f"\n####### Begin 1.parse_Overlap")
+        if interface == 'openmx':
+            assert os.path.exists(os.path.join(OLP_dir, 'openmx.out')), "Necessary files could not be found in OLP_dir"
+            assert os.path.exists(os.path.join(OLP_dir, 'output')), "Necessary files could not be found in OLP_dir"
+            openmx_parse_overlap(OLP_dir, work_dir)
+        elif interface == 'abacus':
+            print("Output subdirectories:", "OUT." + abacus_suffix)
+            assert os.path.exists(os.path.join(OLP_dir, 'SR.csr')), "Necessary files could not be found in OLP_dir"
+            assert os.path.exists(os.path.join(OLP_dir, f'OUT.{abacus_suffix}')), "Necessary files could not be found in OLP_dir"
+            abacus_parse(OLP_dir, work_dir, data_name=f'OUT.{abacus_suffix}', only_S=True)
+        assert os.path.exists(os.path.join(work_dir, "overlaps.h5"))
+        assert os.path.exists(os.path.join(work_dir, "lat.dat"))
+        assert os.path.exists(os.path.join(work_dir, "rlat.dat"))
+        assert os.path.exists(os.path.join(work_dir, "site_positions.dat"))
+        assert os.path.exists(os.path.join(work_dir, "orbital_types.dat"))
+        assert os.path.exists(os.path.join(work_dir, "element.dat"))
+        print('\n******* Finish 1.parse_Overlap, cost %d seconds\n' % (time.time() - begin))
+
+    if not with_grad and 2 in task:
+        begin = time.time()
+        print(f"\n####### Begin 2.get_local_coordinate")
+        get_rc(work_dir, work_dir, radius=radius, gen_rc_idx=gen_rc_idx, gen_rc_by_idx=gen_rc_by_idx,
+               create_from_DFT=config.getboolean('graph', 'create_from_DFT'))
+        assert os.path.exists(os.path.join(work_dir, "rc.h5"))
+        print('\n******* Finish 2.get_local_coordinate, cost %d seconds\n' % (time.time() - begin))
+
+    if 3 in task:
+        begin = time.time()
+        print(f"\n####### Begin 3.get_pred_Hamiltonian")
+        trained_model_dir = config.get('basic', 'trained_model_dir')
+        if trained_model_dir[0] == '[' and trained_model_dir[-1] == ']':
+            trained_model_dir = json.loads(trained_model_dir)
+        if with_grad:
+            predict_with_grad(input_dir=work_dir, output_dir=work_dir, disable_cuda=disable_cuda, device=device,
+                              huge_structure=huge_structure, trained_model_dirs=trained_model_dir)
+        else:
+            predict(input_dir=work_dir, output_dir=work_dir, disable_cuda=disable_cuda, device=device,
+                    huge_structure=huge_structure, restore_blocks_py=restore_blocks_py,
+                    trained_model_dirs=trained_model_dir)
+        if restore_blocks_py:
+            if with_grad:
+                assert os.path.exists(os.path.join(work_dir, "hamiltonians_grad_pred.h5"))
+                assert os.path.exists(os.path.join(work_dir, "hamiltonians_pred.h5"))
+            else:
+                assert os.path.exists(os.path.join(work_dir, "rh_pred.h5"))
+        else:
+            capture_output = sp.run(cmd3_post, shell=True, capture_output=False, encoding="utf-8")
+            assert capture_output.returncode == 0
+            assert os.path.exists(os.path.join(work_dir, "rh_pred.h5"))
+        print('\n******* Finish 3.get_pred_Hamiltonian, cost %d seconds\n' % (time.time() - begin))
+
+    if 4 in task:
+        begin = time.time()
+        print(f"\n####### Begin 4.rotate_back")
+        rotate_back(input_dir=work_dir, output_dir=work_dir)
+        assert os.path.exists(os.path.join(work_dir, "hamiltonians_pred.h5"))
+        print('\n******* Finish 4.rotate_back, cost %d seconds\n' % (time.time() - begin))
+
+    if 5 in task:
+        begin = time.time()
+        print(f"\n####### Begin 5.sparse_calc")
+        capture_output = sp.run(cmd5, shell=True, capture_output=False, encoding="utf-8")
+        assert capture_output.returncode == 0
+        if eigen_solver in ['sparse_jl']:
+            assert os.path.exists(os.path.join(work_dir, "sparse_matrix.jld"))
+        print('\n******* Finish 5.sparse_calc, cost %d seconds\n' % (time.time() - begin))
+
+
+if __name__ == '__main__':
+    main()

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/scripts/preprocess.py

@@ -0,0 +1,199 @@
+import os
+import subprocess as sp
+import time
+
+import numpy as np
+import argparse
+from pathos.multiprocessing import ProcessingPool as Pool
+
+from deeph import get_preprocess_config, get_rc, get_rh, abacus_parse, siesta_parse
+
+
+def collect_magmom_from_openmx(input_dir, output_dir, num_atom, mag_element):
+    magmom_data = np.zeros((num_atom, 4))
+
+    cmd = f'grep --text -A {num_atom + 3} "Total spin moment" {os.path.join(input_dir, "openmx.scfout")}'
+    magmom_str = os.popen(cmd).read().splitlines()
+    # print("Total local magnetic moment:", magmom_str[0].split()[4])
+
+    for index in range(num_atom):
+        line = magmom_str[3 + index].split()
+        assert line[0] == str(index + 1)
+        element_str = line[1]
+        magmom_r = line[5]
+        magmom_theta = line[6]
+        magmom_phi = line[7]
+        magmom_data[index] = int(element_str in mag_element), magmom_r, magmom_theta, magmom_phi
+
+    np.savetxt(os.path.join(output_dir, "magmom.txt"), magmom_data)
+
+def collect_magmom_from_abacus(input_dir, output_dir, abacus_suffix, num_atom, mag_element): #to use this feature, be sure to turn out_chg and out_mul in abacus INPUT file, if not, will use mag setting in STRU file, and this may loss accuracy or incorrect
+    magmom_data = np.zeros((num_atom, 4))
+
+    # using running_scf.log file with INPUT file out_chg and out_mul == 1
+    cmd = f"grep 'Total Magnetism' {os.path.join(input_dir, 'OUT.' + abacus_suffix, 'running_scf.log')}"
+    datas = os.popen(cmd).read().strip().splitlines()
+    if datas:
+        for index, data in enumerate(datas):
+            element_str = data.split()[4]
+            x, y, z = map(float, data.split('(')[-1].split(')')[0].split(','))
+            vector = np.array([x, y, z])
+            r = np.linalg.norm(vector)
+            theta = np.degrees(np.arctan2(vector[1], vector[0]))
+            phi = np.degrees(np.arccos(vector[2] / r))
+            magmom_data[index] = int(element_str in mag_element), r, theta, phi
+    else: # using STRU file magmom setting, THIS MAY CAUSE WRONG OUTPUT!
+        index_atom = 0
+        with open(os.path.join(input_dir, "STRU"), 'r') as file:
+            lines = file.readlines()
+            for k in range(len(lines)): # k = line index
+                if lines[k].strip() == 'ATOMIC_POSITIONS':
+                    kk = k + 2 # kk = current line index
+                    while kk < len(lines):
+                        if lines[kk] == "\n": # for if empty line between two elements, as ABACUS accepts
+                            continue
+                        element_str = lines[kk].strip()
+                        element_amount = int(lines[kk + 2].strip())
+                        for j in range(element_amount):
+                            line = lines[kk + 3 + j].strip().split()
+                            if len(line) < 11: # check if magmom is included
+                                raise ValueError('this line do not contain magmom: {} in this file: {}'.format(line, input_dir))
+                            if line[7] != "angle1" and line[8] != "angle1": # check if magmom is in angle mode
+                                raise ValueError('mag in STRU should be mag * angle1 * angle2 *')
+                            if line[6] == "mag": # for if 'm' is included
+                                index_str = 7
+                            else:
+                                index_str = 8
+                            magmom_data[index_atom] = int(element_str in mag_element), line[index_str], line[index_str + 2], line[index_str + 4]
+                            index_atom += 1
+                        kk += 3 + element_amount
+
+    np.savetxt(os.path.join(output_dir, "magmom.txt"), magmom_data)
+
+def main():
+    parser = argparse.ArgumentParser(description='Deep Hamiltonian')
+    parser.add_argument('--config', default=[], nargs='+', type=str, metavar='N')
+    args = parser.parse_args()
+
+    print(f'User config name: {args.config}')
+    config = get_preprocess_config(args.config)
+
+    raw_dir = os.path.abspath(config.get('basic', 'raw_dir'))
+    processed_dir = os.path.abspath(config.get('basic', 'processed_dir'))
+    abacus_suffix = str(config.get('basic', 'abacus_suffix', fallback='ABACUS'))
+    target = config.get('basic', 'target')
+    interface = config.get('basic', 'interface')
+    local_coordinate = config.getboolean('basic', 'local_coordinate')
+    multiprocessing = config.getint('basic', 'multiprocessing')
+    get_S = config.getboolean('basic', 'get_S')
+
+    julia_interpreter = config.get('interpreter', 'julia_interpreter')
+
+    def make_cmd(input_dir, output_dir, target, interface, get_S):
+        if interface == 'openmx':
+            if target == 'hamiltonian':
+                cmd = f"{julia_interpreter} " \
+                      f"{os.path.join(os.path.dirname(os.path.dirname(__file__)), 'preprocess', 'openmx_get_data.jl')} " \
+                      f"--input_dir {input_dir} --output_dir {output_dir} --save_overlap {str(get_S).lower()}"
+            elif target == 'density_matrix':
+                cmd = f"{julia_interpreter} " \
+                      f"{os.path.join(os.path.dirname(os.path.dirname(__file__)), 'preprocess', 'openmx_get_data.jl')} " \
+                      f"--input_dir {input_dir} --output_dir {output_dir} --save_overlap {str(get_S).lower()} --if_DM true"
+            else:
+                raise ValueError('Unknown target: {}'.format(target))
+        elif interface == 'siesta' or interface == 'abacus':
+            cmd = ''
+        elif interface == 'aims':
+            cmd = f"{julia_interpreter} " \
+                  f"{os.path.join(os.path.dirname(os.path.dirname(__file__)), 'preprocess', 'aims_get_data.jl')} " \
+                  f"--input_dir {input_dir} --output_dir {output_dir} --save_overlap {str(get_S).lower()}"
+        else:
+            raise ValueError('Unknown interface: {}'.format(interface))
+        return cmd
+
+    os.chdir(raw_dir)
+    relpath_list = []
+    abspath_list = []
+    for root, dirs, files in os.walk('./'):
+        if (interface == 'openmx' and 'openmx.scfout' in files) or (
+            interface == 'abacus' and 'OUT.' + abacus_suffix in dirs) or (
+            interface == 'siesta' and any(['.HSX' in ifile for ifile in files])) or (
+            interface == 'aims' and 'NoTB.dat' in files):
+            relpath_list.append(root)
+            abspath_list.append(os.path.abspath(root))
+
+    os.makedirs(processed_dir, exist_ok=True)
+    os.chdir(processed_dir)
+    print(f"Found {len(abspath_list)} directories to preprocess")
+
+    def worker(index):
+        time_cost = time.time() - begin_time
+        current_block = index // nodes
+        if current_block < 1:
+            time_estimate = '?'
+        else:
+            num_blocks = (len(abspath_list) + nodes - 1) // nodes
+            time_estimate = time.localtime(time_cost / (current_block) * (num_blocks - current_block))
+            time_estimate = time.strftime("%H:%M:%S", time_estimate)
+        print(f'\rPreprocessing No. {index + 1}/{len(abspath_list)} '
+              f'[{time.strftime("%H:%M:%S", time.localtime(time_cost))}<{time_estimate}]...', end='')
+        abspath = abspath_list[index]
+        relpath = relpath_list[index]
+        os.makedirs(relpath, exist_ok=True)
+        cmd = make_cmd(
+            abspath,
+            os.path.abspath(relpath),
+            target=target,
+            interface=interface,
+            get_S=get_S,
+        )
+        capture_output = sp.run(cmd, shell=True, capture_output=True, encoding="utf-8")
+        if capture_output.returncode != 0:
+            with open(os.path.join(os.path.abspath(relpath), 'error.log'), 'w') as f:
+                f.write(f'[stdout of cmd "{cmd}"]:\n\n{capture_output.stdout}\n\n\n'
+                        f'[stderr of cmd "{cmd}"]:\n\n{capture_output.stderr}')
+            print(f'\nFailed to preprocess: {abspath}, '
+                  f'log file was saved to {os.path.join(os.path.abspath(relpath), "error.log")}')
+            return
+
+        if interface == 'abacus':
+            print("Output subdirectories:", "OUT." + abacus_suffix)
+            abacus_parse(abspath, os.path.abspath(relpath), 'OUT.' + abacus_suffix)
+        elif interface == 'siesta':
+            siesta_parse(abspath, os.path.abspath(relpath))
+        if local_coordinate:
+            get_rc(os.path.abspath(relpath), os.path.abspath(relpath), radius=config.getfloat('graph', 'radius'),
+                   r2_rand=config.getboolean('graph', 'r2_rand'),
+                   create_from_DFT=config.getboolean('graph', 'create_from_DFT'), neighbour_file='hamiltonians.h5')
+            get_rh(os.path.abspath(relpath), os.path.abspath(relpath), target)
+        if config.getboolean('magnetic_moment', 'parse_magnetic_moment'):
+            num_atom = np.loadtxt(os.path.join(os.path.abspath(relpath), 'element.dat')).shape[0]
+            if interface == 'openmx':
+                collect_magmom_from_openmx(
+                    abspath, os.path.abspath(relpath),
+                    num_atom, eval(config.get('magnetic_moment', 'magnetic_element')))
+            elif interface == 'abacus':
+                collect_magmom_from_abacus(
+                    abspath, os.path.abspath(relpath), abacus_suffix,
+                    num_atom, eval(config.get('magnetic_moment', 'magnetic_element')))
+            else:
+            	raise ValueError('Magnetic moment can only be parsed from OpenMX or ABACUS output for now, but your interface is {}'.format(interface))
+
+    begin_time = time.time()
+    if multiprocessing != 0:
+        if multiprocessing > 0:
+            pool_dict = {'nodes': multiprocessing}
+        else:
+            pool_dict = {}
+        with Pool(**pool_dict) as pool:
+            nodes = pool.nodes
+            print(f'Use multiprocessing (nodes = {nodes})')
+            pool.map(worker, range(len(abspath_list)))
+    else:
+        nodes = 1
+        for index in range(len(abspath_list)):
+            worker(index)
+    print(f'\nPreprocess finished in {time.time() - begin_time:.2f} seconds')
+
+if __name__ == '__main__':
+    main()

2_training/hamiltonian/infer_sc/dataset/00/pred_ham_std/src/deeph/scripts/train.py

@@ -0,0 +1,23 @@
+import argparse
+
+from deeph import DeepHKernel, get_config
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Deep Hamiltonian')
+    parser.add_argument('--config', default=[], nargs='+', type=str, metavar='N')
+    args = parser.parse_args()
+
+    print(f'User config name: {args.config}')
+    config = get_config(args.config)
+    only_get_graph = config.getboolean('basic', 'only_get_graph')
+    kernel = DeepHKernel(config)
+    train_loader, val_loader, test_loader, transform = kernel.get_dataset(only_get_graph)
+    if only_get_graph:
+        return
+    kernel.build_model()
+    kernel.set_train()
+    kernel.train(train_loader, val_loader, test_loader)
+
+if __name__ == '__main__':
+    main()